RTEMS 4.11Annotated Report
Wed Mar 9 16:11:35 2011
0010d738 <IMFS_Set_handlers>:
#define MAXSYMLINK 5
int IMFS_Set_handlers(
rtems_filesystem_location_info_t *loc
)
{
10d738: 55 push %ebp
10d739: 89 e5 mov %esp,%ebp
10d73b: 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;
10d73e: 8b 50 10 mov 0x10(%eax),%edx
10d741: 8b 52 34 mov 0x34(%edx),%edx
switch( node->type ) {
10d744: 8b 08 mov (%eax),%ecx
10d746: 8b 49 4c mov 0x4c(%ecx),%ecx
10d749: 49 dec %ecx
10d74a: 83 f9 06 cmp $0x6,%ecx
10d74d: 77 29 ja 10d778 <IMFS_Set_handlers+0x40><== NEVER TAKEN
10d74f: ff 24 8d d8 f3 11 00 jmp *0x11f3d8(,%ecx,4)
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
10d756: 8b 52 0c mov 0xc(%edx),%edx
10d759: eb 1a jmp 10d775 <IMFS_Set_handlers+0x3d>
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
10d75b: c7 40 08 fc f3 11 00 movl $0x11f3fc,0x8(%eax)
break;
10d762: eb 14 jmp 10d778 <IMFS_Set_handlers+0x40>
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
10d764: c7 40 08 6c f4 11 00 movl $0x11f46c,0x8(%eax)
break;
10d76b: eb 0b jmp 10d778 <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;
10d76d: 8b 52 08 mov 0x8(%edx),%edx
10d770: eb 03 jmp 10d775 <IMFS_Set_handlers+0x3d>
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
10d772: 8b 52 10 mov 0x10(%edx),%edx
10d775: 89 50 08 mov %edx,0x8(%eax)
break;
}
return 0;
}
10d778: 31 c0 xor %eax,%eax
10d77a: c9 leave
10d77b: c3 ret
0010d5eb <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
10d5eb: 55 push %ebp
10d5ec: 89 e5 mov %esp,%ebp
10d5ee: 57 push %edi
10d5ef: 56 push %esi
10d5f0: 53 push %ebx
10d5f1: 83 ec 1c sub $0x1c,%esp
10d5f4: 8b 4d 08 mov 0x8(%ebp),%ecx
10d5f7: 8b 5d 0c mov 0xc(%ebp),%ebx
10d5fa: 8b 75 18 mov 0x18(%ebp),%esi
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
return NULL;
10d5fd: 31 c0 xor %eax,%eax
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
10d5ff: 85 c9 test %ecx,%ecx
10d601: 0f 84 f4 00 00 00 je 10d6fb <IMFS_create_node+0x110><== NEVER TAKEN
return NULL;
parent = parent_loc->node_access;
10d607: 8b 11 mov (%ecx),%edx
fs_info = parent_loc->mt_entry->fs_info;
10d609: 8b 49 10 mov 0x10(%ecx),%ecx
10d60c: 8b 79 34 mov 0x34(%ecx),%edi
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
10d60f: 83 fb 07 cmp $0x7,%ebx
10d612: 75 0d jne 10d621 <IMFS_create_node+0x36>
10d614: 81 7f 10 70 f3 11 00 cmpl $0x11f370,0x10(%edi)
10d61b: 0f 84 da 00 00 00 je 10d6fb <IMFS_create_node+0x110>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
10d621: 50 push %eax
10d622: a1 80 30 12 00 mov 0x123080,%eax
10d627: 8b 40 2c mov 0x2c(%eax),%eax
10d62a: f7 d0 not %eax
10d62c: 23 45 14 and 0x14(%ebp),%eax
10d62f: 50 push %eax
10d630: ff 75 10 pushl 0x10(%ebp)
10d633: 53 push %ebx
10d634: 89 55 e4 mov %edx,-0x1c(%ebp)
10d637: e8 40 ff ff ff call 10d57c <IMFS_allocate_node>
if ( !node )
10d63c: 83 c4 10 add $0x10,%esp
10d63f: 85 c0 test %eax,%eax
10d641: 8b 55 e4 mov -0x1c(%ebp),%edx
10d644: 0f 84 b1 00 00 00 je 10d6fb <IMFS_create_node+0x110>
return NULL;
/*
* Set the type specific information
*/
if ( type == IMFS_DIRECTORY ) {
10d64a: 83 fb 01 cmp $0x1,%ebx
10d64d: 75 15 jne 10d664 <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 );
10d64f: 8d 48 54 lea 0x54(%eax),%ecx
10d652: 89 48 50 mov %ecx,0x50(%eax)
head->next = tail;
head->previous = NULL;
10d655: 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 );
10d65c: 8d 48 50 lea 0x50(%eax),%ecx
10d65f: 89 48 58 mov %ecx,0x58(%eax)
10d662: eb 75 jmp 10d6d9 <IMFS_create_node+0xee>
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
10d664: 83 fb 03 cmp $0x3,%ebx
10d667: 74 05 je 10d66e <IMFS_create_node+0x83>
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
10d669: 83 fb 04 cmp $0x4,%ebx
10d66c: 75 07 jne 10d675 <IMFS_create_node+0x8a>
node->info.sym_link.name = info->sym_link.name;
10d66e: 8b 0e mov (%esi),%ecx
10d670: 89 48 50 mov %ecx,0x50(%eax)
10d673: eb 64 jmp 10d6d9 <IMFS_create_node+0xee>
} else if ( type == IMFS_DEVICE ) {
10d675: 83 fb 02 cmp $0x2,%ebx
10d678: 75 0d jne 10d687 <IMFS_create_node+0x9c>
node->info.device.major = info->device.major;
10d67a: 8b 0e mov (%esi),%ecx
10d67c: 89 48 50 mov %ecx,0x50(%eax)
node->info.device.minor = info->device.minor;
10d67f: 8b 4e 04 mov 0x4(%esi),%ecx
10d682: 89 48 54 mov %ecx,0x54(%eax)
10d685: eb 52 jmp 10d6d9 <IMFS_create_node+0xee>
} else if ( type == IMFS_LINEAR_FILE ) {
10d687: 83 fb 06 cmp $0x6,%ebx
10d68a: 75 17 jne 10d6a3 <IMFS_create_node+0xb8>
node->info.linearfile.size = 0;
10d68c: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10d693: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.linearfile.direct = 0;
10d69a: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
10d6a1: eb 36 jmp 10d6d9 <IMFS_create_node+0xee>
} else if ( type == IMFS_MEMORY_FILE ) {
10d6a3: 83 fb 05 cmp $0x5,%ebx
10d6a6: 75 25 jne 10d6cd <IMFS_create_node+0xe2>
node->info.file.size = 0;
10d6a8: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10d6af: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.file.indirect = 0;
10d6b6: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
node->info.file.doubly_indirect = 0;
10d6bd: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
node->info.file.triply_indirect = 0;
10d6c4: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
10d6cb: eb 0c jmp 10d6d9 <IMFS_create_node+0xee>
} else if ( type == IMFS_FIFO ) {
10d6cd: 83 fb 07 cmp $0x7,%ebx
10d6d0: 75 07 jne 10d6d9 <IMFS_create_node+0xee> <== NEVER TAKEN
node->info.fifo.pipe = NULL;
10d6d2: 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;
10d6d9: 89 50 08 mov %edx,0x8(%eax)
node->st_ino = ++fs_info->ino_count;
10d6dc: 8b 4f 04 mov 0x4(%edi),%ecx
10d6df: 41 inc %ecx
10d6e0: 89 4f 04 mov %ecx,0x4(%edi)
10d6e3: 89 48 38 mov %ecx,0x38(%eax)
10d6e6: 53 push %ebx
10d6e7: 53 push %ebx
10d6e8: 50 push %eax
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
10d6e9: 83 c2 50 add $0x50,%edx
10d6ec: 52 push %edx
10d6ed: 89 45 e4 mov %eax,-0x1c(%ebp)
10d6f0: e8 3f d3 ff ff call 10aa34 <_Chain_Append>
return node;
10d6f5: 83 c4 10 add $0x10,%esp
10d6f8: 8b 45 e4 mov -0x1c(%ebp),%eax
}
10d6fb: 8d 65 f4 lea -0xc(%ebp),%esp
10d6fe: 5b pop %ebx
10d6ff: 5e pop %esi
10d700: 5f pop %edi
10d701: c9 leave
10d702: c3 ret
0010d819 <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
10d819: 55 push %ebp
10d81a: 89 e5 mov %esp,%ebp
10d81c: 57 push %edi
10d81d: 56 push %esi
10d81e: 53 push %ebx
10d81f: 83 ec 5c sub $0x5c,%esp
10d822: 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 ) ) {
10d825: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp)
10d82c: 74 0d je 10d83b <IMFS_eval_path+0x22> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
10d82e: e8 05 39 00 00 call 111138 <__errno> <== NOT EXECUTED
10d833: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
10d839: eb 42 jmp 10d87d <IMFS_eval_path+0x64> <== NOT EXECUTED
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10d83b: 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;
10d83d: 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;
10d842: 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) ) {
10d849: e9 29 01 00 00 jmp 10d977 <IMFS_eval_path+0x15e>
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
10d84e: 8d 45 e4 lea -0x1c(%ebp),%eax
10d851: 50 push %eax
10d852: 8d 4d af lea -0x51(%ebp),%ecx
10d855: 51 push %ecx
10d856: ff 75 0c pushl 0xc(%ebp)
10d859: 8b 45 08 mov 0x8(%ebp),%eax
10d85c: 03 45 a4 add -0x5c(%ebp),%eax
10d85f: 50 push %eax
10d860: e8 b3 05 00 00 call 10de18 <IMFS_get_token>
10d865: 89 c6 mov %eax,%esi
pathnamelen -= len;
10d867: 8b 55 e4 mov -0x1c(%ebp),%edx
i += len;
if ( !pathloc->node_access )
10d86a: 83 c4 10 add $0x10,%esp
10d86d: 83 3b 00 cmpl $0x0,(%ebx)
10d870: 75 13 jne 10d885 <IMFS_eval_path+0x6c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOENT );
10d872: e8 c1 38 00 00 call 111138 <__errno>
10d877: c7 00 02 00 00 00 movl $0x2,(%eax)
10d87d: 83 cf ff or $0xffffffff,%edi
10d880: e9 75 01 00 00 jmp 10d9fa <IMFS_eval_path+0x1e1>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10d885: 85 c0 test %eax,%eax
10d887: 74 21 je 10d8aa <IMFS_eval_path+0x91>
if ( node->type == IMFS_DIRECTORY )
10d889: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10d88d: 75 1b jne 10d8aa <IMFS_eval_path+0x91>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10d88f: 57 push %edi
10d890: 57 push %edi
10d891: 6a 01 push $0x1
10d893: 53 push %ebx
10d894: 89 55 a0 mov %edx,-0x60(%ebp)
10d897: e8 e0 fe ff ff call 10d77c <IMFS_evaluate_permission>
10d89c: 83 c4 10 add $0x10,%esp
10d89f: 85 c0 test %eax,%eax
10d8a1: 8b 55 a0 mov -0x60(%ebp),%edx
10d8a4: 0f 84 3e 01 00 00 je 10d9e8 <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;
10d8aa: 29 55 0c sub %edx,0xc(%ebp)
i += len;
10d8ad: 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;
10d8b0: 8b 3b mov (%ebx),%edi
switch( type ) {
10d8b2: 83 fe 03 cmp $0x3,%esi
10d8b5: 74 38 je 10d8ef <IMFS_eval_path+0xd6>
10d8b7: 83 fe 04 cmp $0x4,%esi
10d8ba: 0f 84 a7 00 00 00 je 10d967 <IMFS_eval_path+0x14e>
10d8c0: 83 fe 02 cmp $0x2,%esi
10d8c3: 0f 85 ae 00 00 00 jne 10d977 <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 )
10d8c9: a1 80 30 12 00 mov 0x123080,%eax
10d8ce: 3b 78 18 cmp 0x18(%eax),%edi
10d8d1: 0f 84 a0 00 00 00 je 10d977 <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) {
10d8d7: 8b 43 10 mov 0x10(%ebx),%eax
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
10d8da: 3b 78 1c cmp 0x1c(%eax),%edi
10d8dd: 75 0b jne 10d8ea <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;
10d8df: 8d 7d d0 lea -0x30(%ebp),%edi
10d8e2: 8d 70 08 lea 0x8(%eax),%esi
10d8e5: e9 ad 00 00 00 jmp 10d997 <IMFS_eval_path+0x17e>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
10d8ea: 8b 7f 08 mov 0x8(%edi),%edi
10d8ed: eb 6c jmp 10d95b <IMFS_eval_path+0x142>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
10d8ef: 8b 47 4c mov 0x4c(%edi),%eax
10d8f2: 83 f8 03 cmp $0x3,%eax
10d8f5: 75 11 jne 10d908 <IMFS_eval_path+0xef>
IMFS_evaluate_hard_link( pathloc, 0 );
10d8f7: 51 push %ecx
10d8f8: 51 push %ecx
10d8f9: 6a 00 push $0x0
10d8fb: 53 push %ebx
10d8fc: e8 d9 fe ff ff call 10d7da <IMFS_evaluate_hard_link>
node = pathloc->node_access;
10d901: 8b 3b mov (%ebx),%edi
10d903: 83 c4 10 add $0x10,%esp
10d906: eb 1d jmp 10d925 <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 ) {
10d908: 83 f8 04 cmp $0x4,%eax
10d90b: 75 18 jne 10d925 <IMFS_eval_path+0x10c>
result = IMFS_evaluate_sym_link( pathloc, 0 );
10d90d: 52 push %edx
10d90e: 52 push %edx
10d90f: 6a 00 push $0x0
10d911: 53 push %ebx
10d912: e8 ed 00 00 00 call 10da04 <IMFS_evaluate_sym_link>
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
10d917: 8b 3b mov (%ebx),%edi
if ( result == -1 )
10d919: 83 c4 10 add $0x10,%esp
10d91c: 83 f8 ff cmp $0xffffffff,%eax
10d91f: 0f 84 d3 00 00 00 je 10d9f8 <IMFS_eval_path+0x1df> <== NEVER TAKEN
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10d925: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10d929: 74 10 je 10d93b <IMFS_eval_path+0x122>
rtems_set_errno_and_return_minus_one( ENOTDIR );
10d92b: e8 08 38 00 00 call 111138 <__errno>
10d930: c7 00 14 00 00 00 movl $0x14,(%eax)
10d936: e9 42 ff ff ff jmp 10d87d <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 ) {
10d93b: 8b 47 5c mov 0x5c(%edi),%eax
10d93e: 85 c0 test %eax,%eax
10d940: 74 08 je 10d94a <IMFS_eval_path+0x131>
newloc = node->info.directory.mt_fs->mt_fs_root;
10d942: 8d 7d d0 lea -0x30(%ebp),%edi
10d945: 8d 70 1c lea 0x1c(%eax),%esi
10d948: eb 4d jmp 10d997 <IMFS_eval_path+0x17e>
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10d94a: 50 push %eax
10d94b: 50 push %eax
10d94c: 8d 45 af lea -0x51(%ebp),%eax
10d94f: 50 push %eax
10d950: 57 push %edi
10d951: e8 56 04 00 00 call 10ddac <IMFS_find_match_in_dir>
10d956: 89 c7 mov %eax,%edi
if ( !node )
10d958: 83 c4 10 add $0x10,%esp
10d95b: 85 ff test %edi,%edi
10d95d: 0f 84 0f ff ff ff je 10d872 <IMFS_eval_path+0x59>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
10d963: 89 3b mov %edi,(%ebx)
10d965: eb 10 jmp 10d977 <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 );
10d967: e8 cc 37 00 00 call 111138 <__errno>
10d96c: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10d972: e9 06 ff ff ff jmp 10d87d <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) ) {
10d977: 83 fe 04 cmp $0x4,%esi
10d97a: 74 08 je 10d984 <IMFS_eval_path+0x16b> <== NEVER TAKEN
10d97c: 85 f6 test %esi,%esi
10d97e: 0f 85 ca fe ff ff jne 10d84e <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 ) {
10d984: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10d988: 75 41 jne 10d9cb <IMFS_eval_path+0x1b2>
if ( node->info.directory.mt_fs != NULL ) {
10d98a: 8b 77 5c mov 0x5c(%edi),%esi
10d98d: 85 f6 test %esi,%esi
10d98f: 74 3a je 10d9cb <IMFS_eval_path+0x1b2>
newloc = node->info.directory.mt_fs->mt_fs_root;
10d991: 8d 7d d0 lea -0x30(%ebp),%edi
10d994: 83 c6 1c add $0x1c,%esi
10d997: b9 05 00 00 00 mov $0x5,%ecx
10d99c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10d99e: 8d 75 d0 lea -0x30(%ebp),%esi
10d9a1: b1 05 mov $0x5,%cl
10d9a3: 89 df mov %ebx,%edi
10d9a5: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
10d9a7: 8b 45 e4 mov -0x1c(%ebp),%eax
10d9aa: 8b 53 0c mov 0xc(%ebx),%edx
10d9ad: 53 push %ebx
10d9ae: ff 75 10 pushl 0x10(%ebp)
10d9b1: 8b 4d 0c mov 0xc(%ebp),%ecx
10d9b4: 01 c1 add %eax,%ecx
10d9b6: 51 push %ecx
10d9b7: 8b 4d a4 mov -0x5c(%ebp),%ecx
10d9ba: 29 c1 sub %eax,%ecx
10d9bc: 8b 45 08 mov 0x8(%ebp),%eax
10d9bf: 01 c8 add %ecx,%eax
10d9c1: 50 push %eax
10d9c2: ff 12 call *(%edx)
10d9c4: 89 c7 mov %eax,%edi
10d9c6: 83 c4 10 add $0x10,%esp
10d9c9: eb 2f jmp 10d9fa <IMFS_eval_path+0x1e1>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
10d9cb: 83 ec 0c sub $0xc,%esp
10d9ce: 53 push %ebx
10d9cf: e8 64 fd ff ff call 10d738 <IMFS_Set_handlers>
10d9d4: 89 c7 mov %eax,%edi
10d9d6: 5a pop %edx
10d9d7: 59 pop %ecx
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
10d9d8: ff 75 10 pushl 0x10(%ebp)
10d9db: 53 push %ebx
10d9dc: e8 9b fd ff ff call 10d77c <IMFS_evaluate_permission>
10d9e1: 83 c4 10 add $0x10,%esp
10d9e4: 85 c0 test %eax,%eax
10d9e6: 75 12 jne 10d9fa <IMFS_eval_path+0x1e1>
rtems_set_errno_and_return_minus_one( EACCES );
10d9e8: e8 4b 37 00 00 call 111138 <__errno>
10d9ed: c7 00 0d 00 00 00 movl $0xd,(%eax)
10d9f3: e9 85 fe ff ff jmp 10d87d <IMFS_eval_path+0x64>
10d9f8: 89 c7 mov %eax,%edi <== NOT EXECUTED
return result;
}
10d9fa: 89 f8 mov %edi,%eax
10d9fc: 8d 65 f4 lea -0xc(%ebp),%esp
10d9ff: 5b pop %ebx
10da00: 5e pop %esi
10da01: 5f pop %edi
10da02: c9 leave
10da03: c3 ret
0010daf8 <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 */
)
{
10daf8: 55 push %ebp
10daf9: 89 e5 mov %esp,%ebp
10dafb: 57 push %edi
10dafc: 56 push %esi
10dafd: 53 push %ebx
10dafe: 83 ec 5c sub $0x5c,%esp
10db01: 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;
10db04: 8b 1a mov (%edx),%ebx
/*
* Get the path length.
*/
pathlen = strlen( path );
10db06: 31 c0 xor %eax,%eax
10db08: 83 c9 ff or $0xffffffff,%ecx
10db0b: 8b 7d 08 mov 0x8(%ebp),%edi
10db0e: f2 ae repnz scas %es:(%edi),%al
10db10: f7 d1 not %ecx
10db12: 49 dec %ecx
10db13: 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;
10db16: 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 );
10db1d: 8d 7d af lea -0x51(%ebp),%edi
10db20: 89 d6 mov %edx,%esi
10db22: 8d 45 e4 lea -0x1c(%ebp),%eax
10db25: 50 push %eax
10db26: 57 push %edi
10db27: ff 75 a0 pushl -0x60(%ebp)
10db2a: 8b 45 08 mov 0x8(%ebp),%eax
10db2d: 03 45 a4 add -0x5c(%ebp),%eax
10db30: 50 push %eax
10db31: e8 e2 02 00 00 call 10de18 <IMFS_get_token>
10db36: 89 c2 mov %eax,%edx
pathlen -= len;
10db38: 8b 4d e4 mov -0x1c(%ebp),%ecx
10db3b: 29 4d a0 sub %ecx,-0x60(%ebp)
i += len;
if ( !pathloc->node_access )
10db3e: 83 c4 10 add $0x10,%esp
10db41: 83 3e 00 cmpl $0x0,(%esi)
10db44: 0f 84 79 01 00 00 je 10dcc3 <IMFS_evaluate_for_make+0x1cb><== NEVER TAKEN
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10db4a: 85 c0 test %eax,%eax
10db4c: 74 36 je 10db84 <IMFS_evaluate_for_make+0x8c>
if ( node->type == IMFS_DIRECTORY )
10db4e: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10db52: 75 30 jne 10db84 <IMFS_evaluate_for_make+0x8c>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10db54: 53 push %ebx
10db55: 53 push %ebx
10db56: 6a 01 push $0x1
10db58: 56 push %esi
10db59: 89 45 9c mov %eax,-0x64(%ebp)
10db5c: 89 4d 98 mov %ecx,-0x68(%ebp)
10db5f: e8 18 fc ff ff call 10d77c <IMFS_evaluate_permission>
10db64: 83 c4 10 add $0x10,%esp
10db67: 85 c0 test %eax,%eax
10db69: 8b 55 9c mov -0x64(%ebp),%edx
10db6c: 8b 4d 98 mov -0x68(%ebp),%ecx
10db6f: 75 13 jne 10db84 <IMFS_evaluate_for_make+0x8c>
rtems_set_errno_and_return_minus_one( EACCES );
10db71: e8 c2 35 00 00 call 111138 <__errno>
10db76: c7 00 0d 00 00 00 movl $0xd,(%eax)
10db7c: 83 cb ff or $0xffffffff,%ebx
10db7f: e9 99 01 00 00 jmp 10dd1d <IMFS_evaluate_for_make+0x225>
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
10db84: 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;
10db87: 8b 1e mov (%esi),%ebx
switch( type ) {
10db89: 83 fa 02 cmp $0x2,%edx
10db8c: 74 1f je 10dbad <IMFS_evaluate_for_make+0xb5>
10db8e: 77 0a ja 10db9a <IMFS_evaluate_for_make+0xa2>
10db90: 85 d2 test %edx,%edx
10db92: 0f 84 d9 00 00 00 je 10dc71 <IMFS_evaluate_for_make+0x179>
10db98: eb 88 jmp 10db22 <IMFS_evaluate_for_make+0x2a>
10db9a: 83 fa 03 cmp $0x3,%edx
10db9d: 74 40 je 10dbdf <IMFS_evaluate_for_make+0xe7>
10db9f: 83 fa 04 cmp $0x4,%edx
10dba2: 0f 85 7a ff ff ff jne 10db22 <IMFS_evaluate_for_make+0x2a><== NEVER TAKEN
10dba8: e9 d4 00 00 00 jmp 10dc81 <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 )
10dbad: a1 80 30 12 00 mov 0x123080,%eax
10dbb2: 3b 58 18 cmp 0x18(%eax),%ebx
10dbb5: 0f 84 67 ff ff ff je 10db22 <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){
10dbbb: 8b 46 10 mov 0x10(%esi),%eax
10dbbe: 3b 58 1c cmp 0x1c(%eax),%ebx
10dbc1: 75 0c jne 10dbcf <IMFS_evaluate_for_make+0xd7>
10dbc3: 89 f2 mov %esi,%edx
10dbc5: 89 c6 mov %eax,%esi
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
10dbc7: 8d 7d d0 lea -0x30(%ebp),%edi
10dbca: 83 c6 08 add $0x8,%esi
10dbcd: eb 5a jmp 10dc29 <IMFS_evaluate_for_make+0x131>
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
10dbcf: 8b 5b 08 mov 0x8(%ebx),%ebx
10dbd2: 85 db test %ebx,%ebx
10dbd4: 0f 85 90 00 00 00 jne 10dc6a <IMFS_evaluate_for_make+0x172>
10dbda: e9 e4 00 00 00 jmp 10dcc3 <IMFS_evaluate_for_make+0x1cb>
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
10dbdf: 8b 43 4c mov 0x4c(%ebx),%eax
10dbe2: 83 f8 03 cmp $0x3,%eax
10dbe5: 74 05 je 10dbec <IMFS_evaluate_for_make+0xf4>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
10dbe7: 83 f8 04 cmp $0x4,%eax
10dbea: 75 16 jne 10dc02 <IMFS_evaluate_for_make+0x10a>
result = IMFS_evaluate_link( pathloc, 0 );
10dbec: 50 push %eax
10dbed: 50 push %eax
10dbee: 6a 00 push $0x0
10dbf0: 56 push %esi
10dbf1: e8 7f fe ff ff call 10da75 <IMFS_evaluate_link>
if ( result == -1 )
10dbf6: 83 c4 10 add $0x10,%esp
10dbf9: 83 f8 ff cmp $0xffffffff,%eax
10dbfc: 0f 84 19 01 00 00 je 10dd1b <IMFS_evaluate_for_make+0x223><== NEVER TAKEN
return -1;
}
node = pathloc->node_access;
10dc02: 8b 06 mov (%esi),%eax
if ( !node )
10dc04: 85 c0 test %eax,%eax
10dc06: 0f 84 e9 00 00 00 je 10dcf5 <IMFS_evaluate_for_make+0x1fd><== NEVER TAKEN
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10dc0c: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10dc10: 0f 85 df 00 00 00 jne 10dcf5 <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 ) {
10dc16: 8b 50 5c mov 0x5c(%eax),%edx
10dc19: 85 d2 test %edx,%edx
10dc1b: 74 3b je 10dc58 <IMFS_evaluate_for_make+0x160>
10dc1d: 89 f0 mov %esi,%eax
10dc1f: 89 d6 mov %edx,%esi
10dc21: 89 c2 mov %eax,%edx
newloc = node->info.directory.mt_fs->mt_fs_root;
10dc23: 8d 7d d0 lea -0x30(%ebp),%edi
10dc26: 83 c6 1c add $0x1c,%esi
10dc29: b9 05 00 00 00 mov $0x5,%ecx
10dc2e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10dc30: 8d 75 d0 lea -0x30(%ebp),%esi
10dc33: b1 05 mov $0x5,%cl
10dc35: 89 d7 mov %edx,%edi
10dc37: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
10dc39: 56 push %esi
10dc3a: 8b 42 0c mov 0xc(%edx),%eax
10dc3d: ff 75 10 pushl 0x10(%ebp)
10dc40: 52 push %edx
10dc41: 8b 55 a4 mov -0x5c(%ebp),%edx
10dc44: 2b 55 e4 sub -0x1c(%ebp),%edx
10dc47: 03 55 08 add 0x8(%ebp),%edx
10dc4a: 52 push %edx
10dc4b: ff 50 04 call *0x4(%eax)
10dc4e: 89 c3 mov %eax,%ebx
10dc50: 83 c4 10 add $0x10,%esp
10dc53: e9 c5 00 00 00 jmp 10dd1d <IMFS_evaluate_for_make+0x225>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10dc58: 53 push %ebx
10dc59: 53 push %ebx
10dc5a: 57 push %edi
10dc5b: 50 push %eax
10dc5c: e8 4b 01 00 00 call 10ddac <IMFS_find_match_in_dir>
10dc61: 89 c3 mov %eax,%ebx
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
10dc63: 83 c4 10 add $0x10,%esp
10dc66: 85 c0 test %eax,%eax
10dc68: 74 27 je 10dc91 <IMFS_evaluate_for_make+0x199>
done = true;
else
pathloc->node_access = node;
10dc6a: 89 1e mov %ebx,(%esi)
10dc6c: e9 b1 fe ff ff jmp 10db22 <IMFS_evaluate_for_make+0x2a>
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
10dc71: e8 c2 34 00 00 call 111138 <__errno>
10dc76: c7 00 11 00 00 00 movl $0x11,(%eax)
10dc7c: e9 fb fe ff ff jmp 10db7c <IMFS_evaluate_for_make+0x84>
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
10dc81: e8 b2 34 00 00 call 111138 <__errno>
10dc86: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10dc8c: e9 eb fe ff ff jmp 10db7c <IMFS_evaluate_for_make+0x84>
10dc91: 89 f2 mov %esi,%edx
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
10dc93: 8b 45 a4 mov -0x5c(%ebp),%eax
10dc96: 2b 45 e4 sub -0x1c(%ebp),%eax
10dc99: 03 45 08 add 0x8(%ebp),%eax
10dc9c: 8b 4d 10 mov 0x10(%ebp),%ecx
10dc9f: 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(
10dca1: 8b 5d 08 mov 0x8(%ebp),%ebx
10dca4: 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++) {
10dca7: eb 2a jmp 10dcd3 <IMFS_evaluate_for_make+0x1db>
if ( !IMFS_is_separator( path[ i ] ) )
10dca9: 83 ec 0c sub $0xc,%esp
10dcac: 0f be c0 movsbl %al,%eax
10dcaf: 50 push %eax
10dcb0: 89 55 9c mov %edx,-0x64(%ebp)
10dcb3: e8 9c a3 ff ff call 108054 <rtems_filesystem_is_separator>
10dcb8: 43 inc %ebx
10dcb9: 83 c4 10 add $0x10,%esp
10dcbc: 85 c0 test %eax,%eax
10dcbe: 8b 55 9c mov -0x64(%ebp),%edx
10dcc1: 75 10 jne 10dcd3 <IMFS_evaluate_for_make+0x1db>
rtems_set_errno_and_return_minus_one( ENOENT );
10dcc3: e8 70 34 00 00 call 111138 <__errno>
10dcc8: c7 00 02 00 00 00 movl $0x2,(%eax)
10dcce: e9 a9 fe ff ff jmp 10db7c <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++) {
10dcd3: 8a 03 mov (%ebx),%al
10dcd5: 84 c0 test %al,%al
10dcd7: 75 d0 jne 10dca9 <IMFS_evaluate_for_make+0x1b1>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
10dcd9: 83 ec 0c sub $0xc,%esp
10dcdc: 52 push %edx
10dcdd: 89 55 9c mov %edx,-0x64(%ebp)
10dce0: e8 53 fa ff ff call 10d738 <IMFS_Set_handlers>
10dce5: 89 c3 mov %eax,%ebx
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
10dce7: 8b 55 9c mov -0x64(%ebp),%edx
10dcea: 8b 02 mov (%edx),%eax
10dcec: 83 c4 10 add $0x10,%esp
10dcef: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10dcf3: 74 10 je 10dd05 <IMFS_evaluate_for_make+0x20d><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
10dcf5: e8 3e 34 00 00 call 111138 <__errno>
10dcfa: c7 00 14 00 00 00 movl $0x14,(%eax)
10dd00: e9 77 fe ff ff jmp 10db7c <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 ) )
10dd05: 51 push %ecx
10dd06: 51 push %ecx
10dd07: 6a 03 push $0x3
10dd09: 52 push %edx
10dd0a: e8 6d fa ff ff call 10d77c <IMFS_evaluate_permission>
10dd0f: 83 c4 10 add $0x10,%esp
10dd12: 85 c0 test %eax,%eax
10dd14: 75 07 jne 10dd1d <IMFS_evaluate_for_make+0x225>
10dd16: e9 56 fe ff ff jmp 10db71 <IMFS_evaluate_for_make+0x79>
10dd1b: 89 c3 mov %eax,%ebx <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10dd1d: 89 d8 mov %ebx,%eax
10dd1f: 8d 65 f4 lea -0xc(%ebp),%esp
10dd22: 5b pop %ebx
10dd23: 5e pop %esi
10dd24: 5f pop %edi
10dd25: c9 leave
10dd26: c3 ret
0010d77c <IMFS_evaluate_permission>:
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
10d77c: 55 push %ebp
10d77d: 89 e5 mov %esp,%ebp
10d77f: 57 push %edi
10d780: 56 push %esi
10d781: 53 push %ebx
10d782: 83 ec 0c sub $0xc,%esp
10d785: 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 ) )
10d788: f7 c6 f8 ff ff ff test $0xfffffff8,%esi
10d78e: 74 10 je 10d7a0 <IMFS_evaluate_permission+0x24><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
10d790: e8 a3 39 00 00 call 111138 <__errno> <== NOT EXECUTED
10d795: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10d79b: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10d79e: eb 32 jmp 10d7d2 <IMFS_evaluate_permission+0x56><== NOT EXECUTED
jnode = node->node_access;
10d7a0: 8b 45 08 mov 0x8(%ebp),%eax
10d7a3: 8b 18 mov (%eax),%ebx
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
10d7a5: e8 2e 0a 00 00 call 10e1d8 <geteuid>
10d7aa: 89 c7 mov %eax,%edi
st_gid = getegid();
10d7ac: e8 17 0a 00 00 call 10e1c8 <getegid>
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
10d7b1: 66 3b 7b 3c cmp 0x3c(%ebx),%di
10d7b5: 75 05 jne 10d7bc <IMFS_evaluate_permission+0x40>
flags_to_test <<= 6;
10d7b7: c1 e6 06 shl $0x6,%esi
10d7ba: eb 09 jmp 10d7c5 <IMFS_evaluate_permission+0x49>
else if ( st_gid == jnode->st_gid )
10d7bc: 66 3b 43 3e cmp 0x3e(%ebx),%ax
10d7c0: 75 03 jne 10d7c5 <IMFS_evaluate_permission+0x49><== NEVER TAKEN
flags_to_test <<= 3;
10d7c2: 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 )
10d7c5: 8b 43 30 mov 0x30(%ebx),%eax
10d7c8: 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 );
10d7ca: 39 f0 cmp %esi,%eax
10d7cc: 0f 94 c0 sete %al
10d7cf: 0f b6 c0 movzbl %al,%eax
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
10d7d2: 83 c4 0c add $0xc,%esp
10d7d5: 5b pop %ebx
10d7d6: 5e pop %esi
10d7d7: 5f pop %edi
10d7d8: c9 leave
10d7d9: c3 ret
00107b98 <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
107b98: 55 push %ebp
107b99: 89 e5 mov %esp,%ebp
107b9b: 53 push %ebx
107b9c: 83 ec 10 sub $0x10,%esp
107b9f: 8b 45 08 mov 0x8(%ebp),%eax
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
107ba2: 50 push %eax
107ba3: ff 75 14 pushl 0x14(%ebp)
107ba6: ff 75 10 pushl 0x10(%ebp)
107ba9: ff 75 0c pushl 0xc(%ebp)
107bac: 8b 40 18 mov 0x18(%eax),%eax
107baf: ff 70 50 pushl 0x50(%eax)
107bb2: e8 fa 86 00 00 call 1102b1 <pipe_lseek>
107bb7: 89 c3 mov %eax,%ebx
IMFS_FIFO_RETURN(err);
107bb9: 83 c4 20 add $0x20,%esp
107bbc: 99 cltd
107bbd: 85 d2 test %edx,%edx
107bbf: 79 0e jns 107bcf <IMFS_fifo_lseek+0x37> <== NEVER TAKEN
107bc1: e8 8e b3 00 00 call 112f54 <__errno>
107bc6: f7 db neg %ebx
107bc8: 89 18 mov %ebx,(%eax)
107bca: 83 c8 ff or $0xffffffff,%eax
107bcd: 89 c2 mov %eax,%edx
}
107bcf: 8b 5d fc mov -0x4(%ebp),%ebx
107bd2: c9 leave
107bd3: c3 ret
00107c34 <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
107c34: 55 push %ebp
107c35: 89 e5 mov %esp,%ebp
107c37: 56 push %esi
107c38: 53 push %ebx
107c39: 83 ec 10 sub $0x10,%esp
107c3c: 8b 45 08 mov 0x8(%ebp),%eax
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
107c3f: 8b 70 18 mov 0x18(%eax),%esi
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
107c42: 50 push %eax
107c43: ff 75 10 pushl 0x10(%ebp)
107c46: ff 75 0c pushl 0xc(%ebp)
107c49: ff 76 50 pushl 0x50(%esi)
107c4c: e8 5c 84 00 00 call 1100ad <pipe_write>
107c51: 89 c3 mov %eax,%ebx
if (err > 0) {
107c53: 83 c4 10 add $0x10,%esp
107c56: 83 f8 00 cmp $0x0,%eax
107c59: 7e 1d jle 107c78 <IMFS_fifo_write+0x44>
IMFS_mtime_ctime_update(jnode);
107c5b: 50 push %eax
107c5c: 50 push %eax
107c5d: 6a 00 push $0x0
107c5f: 8d 45 f0 lea -0x10(%ebp),%eax
107c62: 50 push %eax
107c63: e8 ec 0d 00 00 call 108a54 <gettimeofday>
107c68: 8b 45 f0 mov -0x10(%ebp),%eax
107c6b: 89 46 44 mov %eax,0x44(%esi)
107c6e: 89 46 48 mov %eax,0x48(%esi)
107c71: 83 c4 10 add $0x10,%esp
107c74: 89 d8 mov %ebx,%eax
107c76: eb 13 jmp 107c8b <IMFS_fifo_write+0x57>
}
IMFS_FIFO_RETURN(err);
107c78: b8 00 00 00 00 mov $0x0,%eax
107c7d: 74 0c je 107c8b <IMFS_fifo_write+0x57> <== NEVER TAKEN
107c7f: e8 d0 b2 00 00 call 112f54 <__errno>
107c84: f7 db neg %ebx
107c86: 89 18 mov %ebx,(%eax)
107c88: 83 c8 ff or $0xffffffff,%eax
}
107c8b: 8d 65 f8 lea -0x8(%ebp),%esp
107c8e: 5b pop %ebx
107c8f: 5e pop %esi
107c90: c9 leave
107c91: c3 ret
0010ddac <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
10ddac: 55 push %ebp
10ddad: 89 e5 mov %esp,%ebp
10ddaf: 57 push %edi
10ddb0: 56 push %esi
10ddb1: 53 push %ebx
10ddb2: 83 ec 14 sub $0x14,%esp
10ddb5: 8b 5d 08 mov 0x8(%ebp),%ebx
10ddb8: 8b 7d 0c mov 0xc(%ebp),%edi
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
10ddbb: 68 f4 f3 11 00 push $0x11f3f4
10ddc0: 57 push %edi
10ddc1: e8 36 40 00 00 call 111dfc <strcmp>
10ddc6: 83 c4 10 add $0x10,%esp
10ddc9: 85 c0 test %eax,%eax
10ddcb: 74 40 je 10de0d <IMFS_find_match_in_dir+0x61><== NEVER TAKEN
return directory;
if ( !strcmp( name, dotdotname ) )
10ddcd: 51 push %ecx
10ddce: 51 push %ecx
10ddcf: 68 f6 f3 11 00 push $0x11f3f6
10ddd4: 57 push %edi
10ddd5: e8 22 40 00 00 call 111dfc <strcmp>
10ddda: 83 c4 10 add $0x10,%esp
10dddd: 85 c0 test %eax,%eax
10dddf: 75 05 jne 10dde6 <IMFS_find_match_in_dir+0x3a><== ALWAYS TAKEN
return directory->Parent;
10dde1: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED
10dde4: eb 27 jmp 10de0d <IMFS_find_match_in_dir+0x61><== NOT EXECUTED
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
10dde6: 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));
10dde9: 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 );
10ddec: eb 15 jmp 10de03 <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 ) )
10ddee: 8d 46 0c lea 0xc(%esi),%eax
10ddf1: 52 push %edx
10ddf2: 52 push %edx
10ddf3: 50 push %eax
10ddf4: 57 push %edi
10ddf5: e8 02 40 00 00 call 111dfc <strcmp>
10ddfa: 83 c4 10 add $0x10,%esp
10ddfd: 85 c0 test %eax,%eax
10ddff: 74 0a je 10de0b <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 ) {
10de01: 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 );
10de03: 39 de cmp %ebx,%esi
10de05: 75 e7 jne 10ddee <IMFS_find_match_in_dir+0x42>
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
10de07: 31 db xor %ebx,%ebx
10de09: eb 02 jmp 10de0d <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;
10de0b: 89 f3 mov %esi,%ebx
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
10de0d: 89 d8 mov %ebx,%eax
10de0f: 8d 65 f4 lea -0xc(%ebp),%esp
10de12: 5b pop %ebx
10de13: 5e pop %esi
10de14: 5f pop %edi
10de15: c9 leave
10de16: c3 ret
0010dd28 <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
)
{
10dd28: 55 push %ebp
10dd29: 89 e5 mov %esp,%ebp
10dd2b: 57 push %edi
10dd2c: 56 push %esi
10dd2d: 53 push %ebx
10dd2e: 83 ec 2c sub $0x2c,%esp
10dd31: 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;
10dd34: 8b 58 1c mov 0x1c(%eax),%ebx
loc = temp_mt_entry->mt_fs_root;
10dd37: 8d 7d d4 lea -0x2c(%ebp),%edi
10dd3a: 8d 70 1c lea 0x1c(%eax),%esi
10dd3d: b9 05 00 00 00 mov $0x5,%ecx
10dd42: 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;
10dd44: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
10dd4b: 8d 75 d4 lea -0x2c(%ebp),%esi
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
10dd4e: 8b 7b 08 mov 0x8(%ebx),%edi
loc.node_access = (void *)jnode;
10dd51: 89 5d d4 mov %ebx,-0x2c(%ebp)
IMFS_Set_handlers( &loc );
10dd54: 83 ec 0c sub $0xc,%esp
10dd57: 56 push %esi
10dd58: e8 db f9 ff ff call 10d738 <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
10dd5d: 83 c4 10 add $0x10,%esp
10dd60: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10dd64: 75 08 jne 10dd6e <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 );
10dd66: 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 ) ) {
10dd69: 39 43 50 cmp %eax,0x50(%ebx)
10dd6c: 75 13 jne 10dd81 <IMFS_fsunmount+0x59>
result = IMFS_unlink( NULL, &loc );
10dd6e: 50 push %eax
10dd6f: 50 push %eax
10dd70: 56 push %esi
10dd71: 6a 00 push $0x0
10dd73: e8 9c 91 ff ff call 106f14 <IMFS_unlink>
if (result != 0)
10dd78: 83 c4 10 add $0x10,%esp
10dd7b: 85 c0 test %eax,%eax
10dd7d: 75 1e jne 10dd9d <IMFS_fsunmount+0x75> <== NEVER TAKEN
return -1;
jnode = next;
10dd7f: 89 fb mov %edi,%ebx
}
if ( jnode != NULL ) {
10dd81: 85 db test %ebx,%ebx
10dd83: 74 1d je 10dda2 <IMFS_fsunmount+0x7a>
if ( jnode->type == IMFS_DIRECTORY ) {
10dd85: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10dd89: 75 c3 jne 10dd4e <IMFS_fsunmount+0x26> <== NEVER TAKEN
}
}
} while (jnode != NULL);
return 0;
}
10dd8b: 8b 43 50 mov 0x50(%ebx),%eax
10dd8e: 8d 53 54 lea 0x54(%ebx),%edx
return -1;
jnode = next;
}
if ( jnode != NULL ) {
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
10dd91: 39 d0 cmp %edx,%eax
10dd93: 74 b9 je 10dd4e <IMFS_fsunmount+0x26>
jnode = jnode_get_first_child( jnode );
10dd95: 89 c3 mov %eax,%ebx
}
}
} while (jnode != NULL);
10dd97: 85 c0 test %eax,%eax
10dd99: 75 b3 jne 10dd4e <IMFS_fsunmount+0x26> <== ALWAYS TAKEN
10dd9b: eb 05 jmp 10dda2 <IMFS_fsunmount+0x7a> <== NOT EXECUTED
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
10dd9d: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10dda0: eb 02 jmp 10dda4 <IMFS_fsunmount+0x7c> <== NOT EXECUTED
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
return 0;
10dda2: 31 c0 xor %eax,%eax
}
10dda4: 8d 65 f4 lea -0xc(%ebp),%esp
10dda7: 5b pop %ebx
10dda8: 5e pop %esi
10dda9: 5f pop %edi
10ddaa: c9 leave
10ddab: c3 ret
0010de18 <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
10de18: 55 push %ebp
10de19: 89 e5 mov %esp,%ebp
10de1b: 57 push %edi
10de1c: 56 push %esi
10de1d: 53 push %ebx
10de1e: 83 ec 1c sub $0x1c,%esp
10de21: 8b 7d 08 mov 0x8(%ebp),%edi
10de24: 8b 75 10 mov 0x10(%ebp),%esi
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
10de27: 8a 17 mov (%edi),%dl
int pathlen,
char *token,
int *token_len
)
{
register int i = 0;
10de29: 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) ) {
10de2b: eb 10 jmp 10de3d <IMFS_get_token+0x25>
token[i] = c;
10de2d: 88 14 1e mov %dl,(%esi,%ebx,1)
if ( i == IMFS_NAME_MAX )
10de30: 83 fb 20 cmp $0x20,%ebx
10de33: 0f 84 86 00 00 00 je 10debf <IMFS_get_token+0xa7>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
10de39: 43 inc %ebx
10de3a: 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) ) {
10de3d: 83 ec 0c sub $0xc,%esp
10de40: 0f be c2 movsbl %dl,%eax
10de43: 50 push %eax
10de44: 88 55 e4 mov %dl,-0x1c(%ebp)
10de47: e8 08 a2 ff ff call 108054 <rtems_filesystem_is_separator>
10de4c: 83 c4 10 add $0x10,%esp
10de4f: 85 c0 test %eax,%eax
10de51: 8a 55 e4 mov -0x1c(%ebp),%dl
10de54: 75 05 jne 10de5b <IMFS_get_token+0x43>
10de56: 3b 5d 0c cmp 0xc(%ebp),%ebx
10de59: 7c d2 jl 10de2d <IMFS_get_token+0x15>
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
10de5b: 85 db test %ebx,%ebx
10de5d: 75 10 jne 10de6f <IMFS_get_token+0x57>
token[i] = c;
10de5f: 88 16 mov %dl,(%esi)
if ( (token[i] != '\0') && pathlen ) {
10de61: 84 d2 test %dl,%dl
10de63: 74 06 je 10de6b <IMFS_get_token+0x53>
10de65: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10de69: 75 16 jne 10de81 <IMFS_get_token+0x69>
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
10de6b: 31 ff xor %edi,%edi
10de6d: eb 1c jmp 10de8b <IMFS_get_token+0x73>
char *token,
int *token_len
)
{
register int i = 0;
IMFS_token_types type = IMFS_NAME;
10de6f: 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') {
10de74: 80 7c 1e ff 00 cmpb $0x0,-0x1(%esi,%ebx,1)
10de79: 74 10 je 10de8b <IMFS_get_token+0x73> <== NEVER TAKEN
token[i] = '\0';
10de7b: c6 04 1e 00 movb $0x0,(%esi,%ebx,1)
10de7f: eb 0a jmp 10de8b <IMFS_get_token+0x73>
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
type = IMFS_CURRENT_DIR;
10de81: bf 01 00 00 00 mov $0x1,%edi
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
10de86: bb 01 00 00 00 mov $0x1,%ebx
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
10de8b: 8b 45 14 mov 0x14(%ebp),%eax
10de8e: 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 ) {
10de90: 83 ff 03 cmp $0x3,%edi
10de93: 75 3d jne 10ded2 <IMFS_get_token+0xba>
if ( strcmp( token, "..") == 0 )
10de95: 52 push %edx
10de96: 52 push %edx
10de97: 68 f9 f3 11 00 push $0x11f3f9
10de9c: 56 push %esi
10de9d: e8 5a 3f 00 00 call 111dfc <strcmp>
10dea2: 83 c4 10 add $0x10,%esp
10dea5: 85 c0 test %eax,%eax
10dea7: 74 1d je 10dec6 <IMFS_get_token+0xae>
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
10dea9: 50 push %eax
10deaa: 50 push %eax
10deab: 68 fa f3 11 00 push $0x11f3fa
10deb0: 56 push %esi
10deb1: e8 46 3f 00 00 call 111dfc <strcmp>
10deb6: 83 c4 10 add $0x10,%esp
10deb9: 85 c0 test %eax,%eax
10debb: 74 10 je 10decd <IMFS_get_token+0xb5>
10debd: eb 13 jmp 10ded2 <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;
10debf: bf 04 00 00 00 mov $0x4,%edi
10dec4: eb 0c jmp 10ded2 <IMFS_get_token+0xba>
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
10dec6: bf 02 00 00 00 mov $0x2,%edi
10decb: eb 05 jmp 10ded2 <IMFS_get_token+0xba>
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
10decd: bf 01 00 00 00 mov $0x1,%edi
}
return type;
}
10ded2: 89 f8 mov %edi,%eax
10ded4: 8d 65 f4 lea -0xc(%ebp),%esp
10ded7: 5b pop %ebx
10ded8: 5e pop %esi
10ded9: 5f pop %edi
10deda: c9 leave
10dedb: c3 ret
00106bac <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
)
{
106bac: 55 push %ebp
106bad: 89 e5 mov %esp,%ebp
106baf: 57 push %edi
106bb0: 56 push %esi
106bb1: 53 push %ebx
106bb2: 83 ec 1c sub $0x1c,%esp
106bb5: 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,
106bb8: a1 48 11 12 00 mov 0x121148,%eax
106bbd: 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) {
106bc2: ba 10 00 00 00 mov $0x10,%edx
if (bit_mask == requested_bytes_per_block) {
106bc7: 39 c2 cmp %eax,%edx
106bc9: 74 0c je 106bd7 <IMFS_initialize_support+0x2b>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
106bcb: 7f 05 jg 106bd2 <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) {
106bcd: d1 e2 shl %edx
106bcf: 49 dec %ecx
106bd0: 75 f5 jne 106bc7 <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);
106bd2: b8 80 00 00 00 mov $0x80,%eax
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
106bd7: 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();
106bdc: e8 22 6b 00 00 call 10d703 <IMFS_create_root_node>
106be1: 89 c2 mov %eax,%edx
106be3: 89 43 1c mov %eax,0x1c(%ebx)
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
106be6: 8b 45 14 mov 0x14(%ebp),%eax
106be9: 89 43 24 mov %eax,0x24(%ebx)
temp_mt_entry->mt_fs_root.ops = op_table;
106bec: 8b 45 0c mov 0xc(%ebp),%eax
106bef: 89 43 28 mov %eax,0x28(%ebx)
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
106bf2: 8d 7b 38 lea 0x38(%ebx),%edi
106bf5: be a8 f3 11 00 mov $0x11f3a8,%esi
106bfa: b9 0c 00 00 00 mov $0xc,%ecx
106bff: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
106c01: 50 push %eax
106c02: 50 push %eax
106c03: 6a 14 push $0x14
106c05: 6a 01 push $0x1
106c07: 89 55 e4 mov %edx,-0x1c(%ebp)
106c0a: e8 fd 05 00 00 call 10720c <calloc>
if ( !fs_info ) {
106c0f: 83 c4 10 add $0x10,%esp
106c12: 85 c0 test %eax,%eax
106c14: 8b 55 e4 mov -0x1c(%ebp),%edx
106c17: 75 1c jne 106c35 <IMFS_initialize_support+0x89>
free(temp_mt_entry->mt_fs_root.node_access);
106c19: 83 ec 0c sub $0xc,%esp
106c1c: 52 push %edx
106c1d: e8 56 07 00 00 call 107378 <free>
rtems_set_errno_and_return_minus_one(ENOMEM);
106c22: e8 11 a5 00 00 call 111138 <__errno>
106c27: c7 00 0c 00 00 00 movl $0xc,(%eax)
106c2d: 83 c4 10 add $0x10,%esp
106c30: 83 c8 ff or $0xffffffff,%eax
106c33: eb 34 jmp 106c69 <IMFS_initialize_support+0xbd>
}
temp_mt_entry->fs_info = fs_info;
106c35: 89 43 34 mov %eax,0x34(%ebx)
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
106c38: 8b 0d f0 4e 12 00 mov 0x124ef0,%ecx
106c3e: 89 08 mov %ecx,(%eax)
106c40: 41 inc %ecx
106c41: 89 0d f0 4e 12 00 mov %ecx,0x124ef0
fs_info->ino_count = 1;
106c47: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
fs_info->memfile_handlers = memfile_handlers;
106c4e: 8b 4d 10 mov 0x10(%ebp),%ecx
106c51: 89 48 08 mov %ecx,0x8(%eax)
fs_info->directory_handlers = directory_handlers;
106c54: 8b 4d 14 mov 0x14(%ebp),%ecx
106c57: 89 48 0c mov %ecx,0xc(%eax)
fs_info->fifo_handlers = fifo_handlers;
106c5a: 8b 4d 18 mov 0x18(%ebp),%ecx
106c5d: 89 48 10 mov %ecx,0x10(%eax)
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
106c60: c7 42 38 01 00 00 00 movl $0x1,0x38(%edx)
return 0;
106c67: 31 c0 xor %eax,%eax
}
106c69: 8d 65 f4 lea -0xc(%ebp),%esp
106c6c: 5b pop %ebx
106c6d: 5e pop %esi
106c6e: 5f pop %edi
106c6f: c9 leave
106c70: c3 ret
00110102 <IMFS_memfile_extend>:
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
110102: 55 push %ebp
110103: 89 e5 mov %esp,%ebp
110105: 57 push %edi
110106: 56 push %esi
110107: 53 push %ebx
110108: 83 ec 2c sub $0x2c,%esp
11010b: 8b 7d 08 mov 0x8(%ebp),%edi
11010e: 8b 5d 0c mov 0xc(%ebp),%ebx
110111: 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 )
110114: a1 ec 4e 12 00 mov 0x124eec,%eax
110119: 89 c1 mov %eax,%ecx
11011b: c1 e9 02 shr $0x2,%ecx
11011e: 8d 51 01 lea 0x1(%ecx),%edx
110121: 0f af d1 imul %ecx,%edx
110124: 42 inc %edx
110125: 0f af d1 imul %ecx,%edx
110128: 4a dec %edx
110129: 0f af d0 imul %eax,%edx
11012c: 83 fe 00 cmp $0x0,%esi
11012f: 7c 16 jl 110147 <IMFS_memfile_extend+0x45><== NEVER TAKEN
110131: 7f 04 jg 110137 <IMFS_memfile_extend+0x35><== NEVER TAKEN
110133: 39 d3 cmp %edx,%ebx
110135: 72 10 jb 110147 <IMFS_memfile_extend+0x45>
rtems_set_errno_and_return_minus_one( EINVAL );
110137: e8 fc 0f 00 00 call 111138 <__errno>
11013c: c7 00 16 00 00 00 movl $0x16,(%eax)
110142: e9 92 00 00 00 jmp 1101d9 <IMFS_memfile_extend+0xd7>
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
110147: 8b 57 50 mov 0x50(%edi),%edx
11014a: 8b 4f 54 mov 0x54(%edi),%ecx
11014d: 89 55 e0 mov %edx,-0x20(%ebp)
110150: 89 4d e4 mov %ecx,-0x1c(%ebp)
110153: 39 ce cmp %ecx,%esi
110155: 0f 8c 8f 00 00 00 jl 1101ea <IMFS_memfile_extend+0xe8><== NEVER TAKEN
11015b: 7f 08 jg 110165 <IMFS_memfile_extend+0x63><== NEVER TAKEN
11015d: 39 d3 cmp %edx,%ebx
11015f: 0f 86 85 00 00 00 jbe 1101ea <IMFS_memfile_extend+0xe8>
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
110165: 89 45 d8 mov %eax,-0x28(%ebp)
110168: 89 c1 mov %eax,%ecx
11016a: c1 f9 1f sar $0x1f,%ecx
11016d: 89 4d dc mov %ecx,-0x24(%ebp)
110170: ff 75 dc pushl -0x24(%ebp)
110173: ff 75 d8 pushl -0x28(%ebp)
110176: 56 push %esi
110177: 53 push %ebx
110178: e8 43 c8 00 00 call 11c9c0 <__divdi3>
11017d: 83 c4 10 add $0x10,%esp
110180: 89 45 d4 mov %eax,-0x2c(%ebp)
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
110183: ff 75 dc pushl -0x24(%ebp)
110186: ff 75 d8 pushl -0x28(%ebp)
110189: ff 75 e4 pushl -0x1c(%ebp)
11018c: ff 75 e0 pushl -0x20(%ebp)
11018f: e8 2c c8 00 00 call 11c9c0 <__divdi3>
110194: 83 c4 10 add $0x10,%esp
110197: 89 45 e0 mov %eax,-0x20(%ebp)
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
11019a: 89 c2 mov %eax,%edx
11019c: eb 41 jmp 1101df <IMFS_memfile_extend+0xdd>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
11019e: 51 push %ecx
11019f: 51 push %ecx
1101a0: 52 push %edx
1101a1: 57 push %edi
1101a2: 89 55 d0 mov %edx,-0x30(%ebp)
1101a5: e8 99 fd ff ff call 10ff43 <IMFS_memfile_addblock>
1101aa: 83 c4 10 add $0x10,%esp
1101ad: 85 c0 test %eax,%eax
1101af: 8b 55 d0 mov -0x30(%ebp),%edx
1101b2: 74 2a je 1101de <IMFS_memfile_extend+0xdc>
1101b4: eb 13 jmp 1101c9 <IMFS_memfile_extend+0xc7>
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
1101b6: 50 push %eax
1101b7: 50 push %eax
1101b8: 52 push %edx
1101b9: 57 push %edi
1101ba: 89 55 d0 mov %edx,-0x30(%ebp)
1101bd: e8 16 ff ff ff call 1100d8 <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-- ) {
1101c2: 8b 55 d0 mov -0x30(%ebp),%edx
1101c5: 4a dec %edx
1101c6: 83 c4 10 add $0x10,%esp
1101c9: 3b 55 e0 cmp -0x20(%ebp),%edx
1101cc: 73 e8 jae 1101b6 <IMFS_memfile_extend+0xb4>
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
1101ce: e8 65 0f 00 00 call 111138 <__errno>
1101d3: c7 00 1c 00 00 00 movl $0x1c,(%eax)
1101d9: 83 c8 ff or $0xffffffff,%eax
1101dc: eb 0e jmp 1101ec <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++ ) {
1101de: 42 inc %edx
1101df: 3b 55 d4 cmp -0x2c(%ebp),%edx
1101e2: 76 ba jbe 11019e <IMFS_memfile_extend+0x9c>
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
1101e4: 89 5f 50 mov %ebx,0x50(%edi)
1101e7: 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;
1101ea: 31 c0 xor %eax,%eax
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
return 0;
}
1101ec: 8d 65 f4 lea -0xc(%ebp),%esp
1101ef: 5b pop %ebx
1101f0: 5e pop %esi
1101f1: 5f pop %edi
1101f2: c9 leave
1101f3: c3 ret
0010fc48 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
10fc48: 55 push %ebp
10fc49: 89 e5 mov %esp,%ebp
10fc4b: 57 push %edi
10fc4c: 56 push %esi
10fc4d: 53 push %ebx
10fc4e: 83 ec 1c sub $0x1c,%esp
10fc51: 8b 75 08 mov 0x8(%ebp),%esi
10fc54: 8b 7d 0c mov 0xc(%ebp),%edi
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
10fc57: 8b 0d ec 4e 12 00 mov 0x124eec,%ecx
10fc5d: c1 e9 02 shr $0x2,%ecx
10fc60: 8d 41 ff lea -0x1(%ecx),%eax
10fc63: 39 c7 cmp %eax,%edi
10fc65: 77 40 ja 10fca7 <IMFS_memfile_get_block_pointer+0x5f>
p = info->indirect;
10fc67: 8b 46 58 mov 0x58(%esi),%eax
if ( malloc_it ) {
10fc6a: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10fc6e: 74 25 je 10fc95 <IMFS_memfile_get_block_pointer+0x4d>
if ( !p ) {
10fc70: 85 c0 test %eax,%eax
10fc72: 75 12 jne 10fc86 <IMFS_memfile_get_block_pointer+0x3e>
p = memfile_alloc_block();
10fc74: e8 ad ff ff ff call 10fc26 <memfile_alloc_block>
if ( !p )
return 0;
10fc79: 31 db xor %ebx,%ebx
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
10fc7b: 85 c0 test %eax,%eax
10fc7d: 0f 84 f7 00 00 00 je 10fd7a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
info->indirect = p;
10fc83: 89 46 58 mov %eax,0x58(%esi)
}
return &info->indirect[ my_block ];
10fc86: 8d 1c bd 00 00 00 00 lea 0x0(,%edi,4),%ebx
10fc8d: 03 5e 58 add 0x58(%esi),%ebx
10fc90: e9 e5 00 00 00 jmp 10fd7a <IMFS_memfile_get_block_pointer+0x132>
}
if ( !p )
return 0;
10fc95: 31 db xor %ebx,%ebx
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
10fc97: 85 c0 test %eax,%eax
10fc99: 0f 84 db 00 00 00 je 10fd7a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
return &info->indirect[ my_block ];
10fc9f: 8d 1c b8 lea (%eax,%edi,4),%ebx
10fca2: e9 d3 00 00 00 jmp 10fd7a <IMFS_memfile_get_block_pointer+0x132>
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
10fca7: 8d 41 01 lea 0x1(%ecx),%eax
10fcaa: 0f af c1 imul %ecx,%eax
10fcad: 8d 50 ff lea -0x1(%eax),%edx
10fcb0: 39 d7 cmp %edx,%edi
10fcb2: 77 40 ja 10fcf4 <IMFS_memfile_get_block_pointer+0xac>
my_block -= FIRST_DOUBLY_INDIRECT;
10fcb4: 29 cf sub %ecx,%edi
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
10fcb6: 89 f8 mov %edi,%eax
10fcb8: 31 d2 xor %edx,%edx
10fcba: f7 f1 div %ecx
10fcbc: 89 55 e4 mov %edx,-0x1c(%ebp)
10fcbf: 89 c7 mov %eax,%edi
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
10fcc1: 8b 46 5c mov 0x5c(%esi),%eax
if ( malloc_it ) {
10fcc4: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10fcc8: 74 1b je 10fce5 <IMFS_memfile_get_block_pointer+0x9d>
if ( !p ) {
10fcca: 85 c0 test %eax,%eax
10fccc: 75 12 jne 10fce0 <IMFS_memfile_get_block_pointer+0x98>
p = memfile_alloc_block();
10fcce: e8 53 ff ff ff call 10fc26 <memfile_alloc_block>
if ( !p )
return 0;
10fcd3: 31 db xor %ebx,%ebx
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
10fcd5: 85 c0 test %eax,%eax
10fcd7: 0f 84 9d 00 00 00 je 10fd7a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
info->doubly_indirect = p;
10fcdd: 89 46 5c mov %eax,0x5c(%esi)
}
p1 = (block_p *)p[ doubly ];
10fce0: 8d 34 b8 lea (%eax,%edi,4),%esi
10fce3: eb 65 jmp 10fd4a <IMFS_memfile_get_block_pointer+0x102>
return (block_p *)&p1[ singly ];
}
if ( !p )
return 0;
10fce5: 31 db xor %ebx,%ebx
}
return (block_p *)&p1[ singly ];
}
if ( !p )
10fce7: 85 c0 test %eax,%eax
10fce9: 0f 84 8b 00 00 00 je 10fd7a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p = (block_p *)p[ doubly ];
10fcef: 8b 04 b8 mov (%eax,%edi,4),%eax
10fcf2: eb 7c jmp 10fd70 <IMFS_memfile_get_block_pointer+0x128>
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
10fcf4: 8d 50 01 lea 0x1(%eax),%edx
10fcf7: 0f af d1 imul %ecx,%edx
10fcfa: 4a dec %edx
}
/*
* This means the requested block number is out of range.
*/
return 0;
10fcfb: 31 db xor %ebx,%ebx
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
10fcfd: 39 d7 cmp %edx,%edi
10fcff: 77 79 ja 10fd7a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
my_block -= FIRST_TRIPLY_INDIRECT;
10fd01: 29 c7 sub %eax,%edi
10fd03: 89 f8 mov %edi,%eax
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
10fd05: 31 d2 xor %edx,%edx
10fd07: f7 f1 div %ecx
10fd09: 89 55 e4 mov %edx,-0x1c(%ebp)
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
10fd0c: 31 d2 xor %edx,%edx
10fd0e: f7 f1 div %ecx
10fd10: 89 55 e0 mov %edx,-0x20(%ebp)
10fd13: 89 c7 mov %eax,%edi
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
p = info->triply_indirect;
10fd15: 8b 46 60 mov 0x60(%esi),%eax
if ( malloc_it ) {
10fd18: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10fd1c: 74 41 je 10fd5f <IMFS_memfile_get_block_pointer+0x117>
if ( !p ) {
10fd1e: 85 c0 test %eax,%eax
10fd20: 75 0c jne 10fd2e <IMFS_memfile_get_block_pointer+0xe6>
p = memfile_alloc_block();
10fd22: e8 ff fe ff ff call 10fc26 <memfile_alloc_block>
if ( !p )
10fd27: 85 c0 test %eax,%eax
10fd29: 74 4f je 10fd7a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
info->triply_indirect = p;
10fd2b: 89 46 60 mov %eax,0x60(%esi)
}
p1 = (block_p *) p[ triply ];
10fd2e: 8d 34 b8 lea (%eax,%edi,4),%esi
10fd31: 8b 06 mov (%esi),%eax
if ( !p1 ) {
10fd33: 85 c0 test %eax,%eax
10fd35: 75 0d jne 10fd44 <IMFS_memfile_get_block_pointer+0xfc>
p1 = memfile_alloc_block();
10fd37: e8 ea fe ff ff call 10fc26 <memfile_alloc_block>
if ( !p1 )
return 0;
10fd3c: 31 db xor %ebx,%ebx
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
10fd3e: 85 c0 test %eax,%eax
10fd40: 74 38 je 10fd7a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p[ triply ] = (block_p) p1;
10fd42: 89 06 mov %eax,(%esi)
}
p2 = (block_p *)p1[ doubly ];
10fd44: 8b 55 e0 mov -0x20(%ebp),%edx
10fd47: 8d 34 90 lea (%eax,%edx,4),%esi
10fd4a: 8b 06 mov (%esi),%eax
if ( !p2 ) {
10fd4c: 85 c0 test %eax,%eax
10fd4e: 75 24 jne 10fd74 <IMFS_memfile_get_block_pointer+0x12c>
p2 = memfile_alloc_block();
10fd50: e8 d1 fe ff ff call 10fc26 <memfile_alloc_block>
if ( !p2 )
return 0;
10fd55: 31 db xor %ebx,%ebx
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
if ( !p2 )
10fd57: 85 c0 test %eax,%eax
10fd59: 74 1f je 10fd7a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p1[ doubly ] = (block_p) p2;
10fd5b: 89 06 mov %eax,(%esi)
10fd5d: eb 15 jmp 10fd74 <IMFS_memfile_get_block_pointer+0x12c>
}
return (block_p *)&p2[ singly ];
}
if ( !p )
10fd5f: 85 c0 test %eax,%eax
10fd61: 74 17 je 10fd7a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p1 = (block_p *) p[ triply ];
10fd63: 8b 04 b8 mov (%eax,%edi,4),%eax
if ( !p1 )
10fd66: 85 c0 test %eax,%eax
10fd68: 74 10 je 10fd7a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p2 = (block_p *)p1[ doubly ];
10fd6a: 8b 55 e0 mov -0x20(%ebp),%edx
10fd6d: 8b 04 90 mov (%eax,%edx,4),%eax
if ( !p2 )
10fd70: 85 c0 test %eax,%eax
10fd72: 74 06 je 10fd7a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
return (block_p *)&p2[ singly ];
10fd74: 8b 55 e4 mov -0x1c(%ebp),%edx
10fd77: 8d 1c 90 lea (%eax,%edx,4),%ebx
/*
* This means the requested block number is out of range.
*/
return 0;
}
10fd7a: 89 d8 mov %ebx,%eax
10fd7c: 83 c4 1c add $0x1c,%esp
10fd7f: 5b pop %ebx
10fd80: 5e pop %esi
10fd81: 5f pop %edi
10fd82: c9 leave
10fd83: c3 ret
0010fd84 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
10fd84: 55 push %ebp
10fd85: 89 e5 mov %esp,%ebp
10fd87: 57 push %edi
10fd88: 56 push %esi
10fd89: 53 push %ebx
10fd8a: 83 ec 4c sub $0x4c,%esp
10fd8d: 8b 75 0c mov 0xc(%ebp),%esi
10fd90: 8b 7d 10 mov 0x10(%ebp),%edi
10fd93: 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) {
10fd96: 8b 45 08 mov 0x8(%ebp),%eax
10fd99: 83 78 4c 06 cmpl $0x6,0x4c(%eax)
10fd9d: 75 3f jne 10fdde <IMFS_memfile_read+0x5a>
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
10fd9f: 8b 48 58 mov 0x58(%eax),%ecx
if (my_length > (the_jnode->info.linearfile.size - start))
10fda2: 89 c2 mov %eax,%edx
10fda4: 8b 40 50 mov 0x50(%eax),%eax
10fda7: 8b 52 54 mov 0x54(%edx),%edx
10fdaa: 89 45 b0 mov %eax,-0x50(%ebp)
10fdad: 89 55 b4 mov %edx,-0x4c(%ebp)
10fdb0: 29 f0 sub %esi,%eax
10fdb2: 19 fa sbb %edi,%edx
10fdb4: 89 45 d0 mov %eax,-0x30(%ebp)
10fdb7: 89 55 d4 mov %edx,-0x2c(%ebp)
10fdba: 31 c0 xor %eax,%eax
10fdbc: 39 d0 cmp %edx,%eax
10fdbe: 7c 0e jl 10fdce <IMFS_memfile_read+0x4a><== NEVER TAKEN
10fdc0: 7f 05 jg 10fdc7 <IMFS_memfile_read+0x43><== NEVER TAKEN
10fdc2: 3b 5d d0 cmp -0x30(%ebp),%ebx
10fdc5: 76 07 jbe 10fdce <IMFS_memfile_read+0x4a><== NEVER TAKEN
my_length = the_jnode->info.linearfile.size - start;
10fdc7: 8b 55 b0 mov -0x50(%ebp),%edx
10fdca: 29 f2 sub %esi,%edx
10fdcc: eb 02 jmp 10fdd0 <IMFS_memfile_read+0x4c>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
10fdce: 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);
10fdd0: 01 ce add %ecx,%esi
10fdd2: 8b 7d 14 mov 0x14(%ebp),%edi
10fdd5: 89 d1 mov %edx,%ecx
10fdd7: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10fdd9: e9 1d 01 00 00 jmp 10fefb <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;
10fdde: 89 f0 mov %esi,%eax
if ( last_byte > the_jnode->info.file.size )
10fde0: 8b 55 08 mov 0x8(%ebp),%edx
10fde3: 8b 52 50 mov 0x50(%edx),%edx
10fde6: 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;
10fde9: 8d 0c 33 lea (%ebx,%esi,1),%ecx
10fdec: 89 4d d0 mov %ecx,-0x30(%ebp)
if ( last_byte > the_jnode->info.file.size )
10fdef: 31 c9 xor %ecx,%ecx
10fdf1: 8b 55 08 mov 0x8(%ebp),%edx
10fdf4: 3b 4a 54 cmp 0x54(%edx),%ecx
10fdf7: 7c 14 jl 10fe0d <IMFS_memfile_read+0x89><== NEVER TAKEN
10fdf9: 7f 08 jg 10fe03 <IMFS_memfile_read+0x7f><== NEVER TAKEN
10fdfb: 8b 4d cc mov -0x34(%ebp),%ecx
10fdfe: 39 4d d0 cmp %ecx,-0x30(%ebp)
10fe01: 76 0a jbe 10fe0d <IMFS_memfile_read+0x89>
my_length = the_jnode->info.file.size - start;
10fe03: 8b 55 cc mov -0x34(%ebp),%edx
10fe06: 29 c2 sub %eax,%edx
10fe08: 89 55 d0 mov %edx,-0x30(%ebp)
10fe0b: eb 03 jmp 10fe10 <IMFS_memfile_read+0x8c>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
10fe0d: 89 5d d0 mov %ebx,-0x30(%ebp)
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
10fe10: 8b 0d ec 4e 12 00 mov 0x124eec,%ecx
10fe16: 89 4d c4 mov %ecx,-0x3c(%ebp)
10fe19: 89 c8 mov %ecx,%eax
10fe1b: 99 cltd
10fe1c: 89 d3 mov %edx,%ebx
10fe1e: 52 push %edx
10fe1f: 51 push %ecx
10fe20: 57 push %edi
10fe21: 56 push %esi
10fe22: 89 4d c0 mov %ecx,-0x40(%ebp)
10fe25: e8 e2 cc 00 00 call 11cb0c <__moddi3>
10fe2a: 83 c4 10 add $0x10,%esp
10fe2d: 89 45 cc mov %eax,-0x34(%ebp)
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
10fe30: 8b 4d c0 mov -0x40(%ebp),%ecx
10fe33: 53 push %ebx
10fe34: 51 push %ecx
10fe35: 57 push %edi
10fe36: 56 push %esi
10fe37: e8 84 cb 00 00 call 11c9c0 <__divdi3>
10fe3c: 83 c4 10 add $0x10,%esp
10fe3f: 89 c3 mov %eax,%ebx
if ( start_offset ) {
10fe41: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
10fe45: 74 3d je 10fe84 <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 );
10fe47: 57 push %edi
10fe48: 6a 00 push $0x0
10fe4a: 50 push %eax
10fe4b: ff 75 08 pushl 0x8(%ebp)
10fe4e: e8 f5 fd ff ff call 10fc48 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
10fe53: 83 c4 10 add $0x10,%esp
return copied;
10fe56: 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 )
10fe58: 85 c0 test %eax,%eax
10fe5a: 0f 84 ba 00 00 00 je 10ff1a <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;
10fe60: 8b 4d c4 mov -0x3c(%ebp),%ecx
10fe63: 2b 4d cc sub -0x34(%ebp),%ecx
10fe66: 8b 55 d0 mov -0x30(%ebp),%edx
10fe69: 39 ca cmp %ecx,%edx
10fe6b: 76 02 jbe 10fe6f <IMFS_memfile_read+0xeb>
10fe6d: 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 );
10fe6f: 8b 75 cc mov -0x34(%ebp),%esi
10fe72: 03 30 add (%eax),%esi
dest += to_copy;
10fe74: 8b 7d 14 mov 0x14(%ebp),%edi
10fe77: 89 d1 mov %edx,%ecx
10fe79: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10fe7b: 89 7d cc mov %edi,-0x34(%ebp)
block++;
10fe7e: 43 inc %ebx
my_length -= to_copy;
10fe7f: 29 55 d0 sub %edx,-0x30(%ebp)
10fe82: eb 08 jmp 10fe8c <IMFS_memfile_read+0x108>
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
10fe84: 8b 45 14 mov 0x14(%ebp),%eax
10fe87: 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;
10fe8a: 31 d2 xor %edx,%edx
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
10fe8c: 8b 0d ec 4e 12 00 mov 0x124eec,%ecx
10fe92: 89 4d c8 mov %ecx,-0x38(%ebp)
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
10fe95: eb 2f jmp 10fec6 <IMFS_memfile_read+0x142>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
10fe97: 56 push %esi
10fe98: 6a 00 push $0x0
10fe9a: 53 push %ebx
10fe9b: ff 75 08 pushl 0x8(%ebp)
10fe9e: 89 55 c0 mov %edx,-0x40(%ebp)
10fea1: e8 a2 fd ff ff call 10fc48 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
10fea6: 83 c4 10 add $0x10,%esp
10fea9: 85 c0 test %eax,%eax
10feab: 8b 55 c0 mov -0x40(%ebp),%edx
10feae: 74 6a je 10ff1a <IMFS_memfile_read+0x196><== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
10feb0: 8b 30 mov (%eax),%esi
10feb2: 8b 7d cc mov -0x34(%ebp),%edi
10feb5: 8b 4d c8 mov -0x38(%ebp),%ecx
10feb8: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
dest += to_copy;
10feba: 89 7d cc mov %edi,-0x34(%ebp)
block++;
10febd: 43 inc %ebx
my_length -= to_copy;
10febe: 8b 7d c8 mov -0x38(%ebp),%edi
10fec1: 29 7d d0 sub %edi,-0x30(%ebp)
copied += to_copy;
10fec4: 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 ) {
10fec6: 8b 45 d0 mov -0x30(%ebp),%eax
10fec9: 3b 05 ec 4e 12 00 cmp 0x124eec,%eax
10fecf: 73 c6 jae 10fe97 <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 ) {
10fed1: 85 c0 test %eax,%eax
10fed3: 74 26 je 10fefb <IMFS_memfile_read+0x177>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
10fed5: 51 push %ecx
10fed6: 6a 00 push $0x0
10fed8: 53 push %ebx
10fed9: ff 75 08 pushl 0x8(%ebp)
10fedc: 89 55 c0 mov %edx,-0x40(%ebp)
10fedf: e8 64 fd ff ff call 10fc48 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
10fee4: 83 c4 10 add $0x10,%esp
10fee7: 85 c0 test %eax,%eax
10fee9: 8b 55 c0 mov -0x40(%ebp),%edx
10feec: 74 2c je 10ff1a <IMFS_memfile_read+0x196><== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
10feee: 8b 30 mov (%eax),%esi
10fef0: 8b 7d cc mov -0x34(%ebp),%edi
10fef3: 8b 4d d0 mov -0x30(%ebp),%ecx
10fef6: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
copied += my_length;
10fef8: 03 55 d0 add -0x30(%ebp),%edx
}
IMFS_update_atime( the_jnode );
10fefb: 50 push %eax
10fefc: 50 push %eax
10fefd: 6a 00 push $0x0
10feff: 8d 45 e0 lea -0x20(%ebp),%eax
10ff02: 50 push %eax
10ff03: 89 55 c0 mov %edx,-0x40(%ebp)
10ff06: e8 e5 74 ff ff call 1073f0 <gettimeofday>
10ff0b: 8b 45 e0 mov -0x20(%ebp),%eax
10ff0e: 8b 4d 08 mov 0x8(%ebp),%ecx
10ff11: 89 41 40 mov %eax,0x40(%ecx)
return copied;
10ff14: 8b 55 c0 mov -0x40(%ebp),%edx
10ff17: 83 c4 10 add $0x10,%esp
}
10ff1a: 89 d0 mov %edx,%eax
10ff1c: 8d 65 f4 lea -0xc(%ebp),%esp
10ff1f: 5b pop %ebx
10ff20: 5e pop %esi
10ff21: 5f pop %edi
10ff22: c9 leave
10ff23: c3 ret
0010ffe2 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
10ffe2: 55 push %ebp
10ffe3: 89 e5 mov %esp,%ebp
10ffe5: 57 push %edi
10ffe6: 56 push %esi
10ffe7: 53 push %ebx
10ffe8: 83 ec 1c sub $0x1c,%esp
10ffeb: 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;
10ffee: 8b 35 ec 4e 12 00 mov 0x124eec,%esi
10fff4: c1 ee 02 shr $0x2,%esi
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
10fff7: 83 7b 58 00 cmpl $0x0,0x58(%ebx)
10fffb: 74 0f je 11000c <IMFS_memfile_remove+0x2a>
memfile_free_blocks_in_table( &info->indirect, to_free );
10fffd: 57 push %edi
10fffe: 57 push %edi
10ffff: 56 push %esi
110000: 8d 43 58 lea 0x58(%ebx),%eax
110003: 50 push %eax
110004: e8 8c ff ff ff call 10ff95 <memfile_free_blocks_in_table>
110009: 83 c4 10 add $0x10,%esp
}
if ( info->doubly_indirect ) {
11000c: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx)
110010: 74 3e je 110050 <IMFS_memfile_remove+0x6e>
110012: 31 ff xor %edi,%edi
110014: eb 1f jmp 110035 <IMFS_memfile_remove+0x53>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
110016: 8b 43 5c mov 0x5c(%ebx),%eax
110019: 8d 14 bd 00 00 00 00 lea 0x0(,%edi,4),%edx
110020: 83 3c b8 00 cmpl $0x0,(%eax,%edi,4)
110024: 74 0e je 110034 <IMFS_memfile_remove+0x52><== NEVER TAKEN
memfile_free_blocks_in_table(
110026: 51 push %ecx
110027: 51 push %ecx
110028: 56 push %esi
110029: 01 d0 add %edx,%eax
11002b: 50 push %eax
11002c: e8 64 ff ff ff call 10ff95 <memfile_free_blocks_in_table>
110031: 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++ ) {
110034: 47 inc %edi
110035: a1 ec 4e 12 00 mov 0x124eec,%eax
11003a: c1 e8 02 shr $0x2,%eax
11003d: 39 c7 cmp %eax,%edi
11003f: 72 d5 jb 110016 <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 );
110041: 57 push %edi
110042: 57 push %edi
110043: 56 push %esi
110044: 8d 43 5c lea 0x5c(%ebx),%eax
110047: 50 push %eax
110048: e8 48 ff ff ff call 10ff95 <memfile_free_blocks_in_table>
11004d: 83 c4 10 add $0x10,%esp
}
if ( info->triply_indirect ) {
110050: 83 7b 60 00 cmpl $0x0,0x60(%ebx)
110054: 74 78 je 1100ce <IMFS_memfile_remove+0xec>
110056: 31 ff xor %edi,%edi
110058: eb 59 jmp 1100b3 <IMFS_memfile_remove+0xd1>
11005a: 8d 04 bd 00 00 00 00 lea 0x0(,%edi,4),%eax
110061: 89 45 e4 mov %eax,-0x1c(%ebp)
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
110064: 8b 43 60 mov 0x60(%ebx),%eax
110067: 8b 04 b8 mov (%eax,%edi,4),%eax
if ( !p ) /* ensure we have a valid pointer */
11006a: 85 c0 test %eax,%eax
11006c: 74 51 je 1100bf <IMFS_memfile_remove+0xdd><== NEVER TAKEN
11006e: 31 d2 xor %edx,%edx
110070: eb 21 jmp 110093 <IMFS_memfile_remove+0xb1>
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
110072: 83 38 00 cmpl $0x0,(%eax)
110075: 74 18 je 11008f <IMFS_memfile_remove+0xad><== NEVER TAKEN
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
110077: 51 push %ecx
110078: 51 push %ecx
110079: 56 push %esi
11007a: 50 push %eax
11007b: 89 45 dc mov %eax,-0x24(%ebp)
11007e: 89 55 e0 mov %edx,-0x20(%ebp)
110081: e8 0f ff ff ff call 10ff95 <memfile_free_blocks_in_table>
110086: 83 c4 10 add $0x10,%esp
110089: 8b 55 e0 mov -0x20(%ebp),%edx
11008c: 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++ ) {
11008f: 42 inc %edx
110090: 83 c0 04 add $0x4,%eax
110093: 8b 0d ec 4e 12 00 mov 0x124eec,%ecx
110099: c1 e9 02 shr $0x2,%ecx
11009c: 39 ca cmp %ecx,%edx
11009e: 72 d2 jb 110072 <IMFS_memfile_remove+0x90>
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
1100a0: 52 push %edx
1100a1: 52 push %edx
1100a2: 56 push %esi
1100a3: 8b 45 e4 mov -0x1c(%ebp),%eax
1100a6: 03 43 60 add 0x60(%ebx),%eax
1100a9: 50 push %eax
1100aa: e8 e6 fe ff ff call 10ff95 <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++ ) {
1100af: 47 inc %edi
1100b0: 83 c4 10 add $0x10,%esp
1100b3: a1 ec 4e 12 00 mov 0x124eec,%eax
1100b8: c1 e8 02 shr $0x2,%eax
1100bb: 39 c7 cmp %eax,%edi
1100bd: 72 9b jb 11005a <IMFS_memfile_remove+0x78>
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
1100bf: 50 push %eax
1100c0: 50 push %eax
1100c1: 56 push %esi
(block_p **)&info->triply_indirect, to_free );
1100c2: 83 c3 60 add $0x60,%ebx
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
1100c5: 53 push %ebx
1100c6: e8 ca fe ff ff call 10ff95 <memfile_free_blocks_in_table>
1100cb: 83 c4 10 add $0x10,%esp
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
1100ce: 31 c0 xor %eax,%eax
1100d0: 8d 65 f4 lea -0xc(%ebp),%esp
1100d3: 5b pop %ebx
1100d4: 5e pop %esi
1100d5: 5f pop %edi
1100d6: c9 leave
1100d7: c3 ret
001101f4 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
1101f4: 55 push %ebp
1101f5: 89 e5 mov %esp,%ebp
1101f7: 57 push %edi
1101f8: 56 push %esi
1101f9: 53 push %ebx
1101fa: 83 ec 2c sub $0x2c,%esp
1101fd: 8b 75 0c mov 0xc(%ebp),%esi
110200: 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;
110203: 8b 4d 18 mov 0x18(%ebp),%ecx
110206: 01 f1 add %esi,%ecx
if ( last_byte > the_jnode->info.file.size ) {
110208: 89 c8 mov %ecx,%eax
11020a: 31 d2 xor %edx,%edx
11020c: 8b 5d 08 mov 0x8(%ebp),%ebx
11020f: 3b 53 54 cmp 0x54(%ebx),%edx
110212: 7c 2c jl 110240 <IMFS_memfile_write+0x4c><== NEVER TAKEN
110214: 7f 05 jg 11021b <IMFS_memfile_write+0x27><== NEVER TAKEN
110216: 3b 4b 50 cmp 0x50(%ebx),%ecx
110219: 76 25 jbe 110240 <IMFS_memfile_write+0x4c><== NEVER TAKEN
status = IMFS_memfile_extend( the_jnode, last_byte );
11021b: 51 push %ecx
11021c: 52 push %edx
11021d: 50 push %eax
11021e: ff 75 08 pushl 0x8(%ebp)
110221: e8 dc fe ff ff call 110102 <IMFS_memfile_extend>
if ( status )
110226: 83 c4 10 add $0x10,%esp
110229: 85 c0 test %eax,%eax
11022b: 74 13 je 110240 <IMFS_memfile_write+0x4c>
rtems_set_errno_and_return_minus_one( ENOSPC );
11022d: e8 06 0f 00 00 call 111138 <__errno>
110232: c7 00 1c 00 00 00 movl $0x1c,(%eax)
110238: 83 c9 ff or $0xffffffff,%ecx
11023b: e9 0f 01 00 00 jmp 11034f <IMFS_memfile_write+0x15b>
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
110240: a1 ec 4e 12 00 mov 0x124eec,%eax
110245: 89 45 cc mov %eax,-0x34(%ebp)
110248: 99 cltd
110249: 89 d3 mov %edx,%ebx
11024b: 52 push %edx
11024c: 50 push %eax
11024d: 57 push %edi
11024e: 56 push %esi
11024f: 89 45 c8 mov %eax,-0x38(%ebp)
110252: e8 b5 c8 00 00 call 11cb0c <__moddi3>
110257: 83 c4 10 add $0x10,%esp
11025a: 89 45 d0 mov %eax,-0x30(%ebp)
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
11025d: 8b 4d c8 mov -0x38(%ebp),%ecx
110260: 53 push %ebx
110261: 51 push %ecx
110262: 57 push %edi
110263: 56 push %esi
110264: e8 57 c7 00 00 call 11c9c0 <__divdi3>
110269: 83 c4 10 add $0x10,%esp
11026c: 89 c3 mov %eax,%ebx
if ( start_offset ) {
11026e: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
110272: 74 40 je 1102b4 <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 );
110274: 52 push %edx
110275: 6a 00 push $0x0
110277: 53 push %ebx
110278: ff 75 08 pushl 0x8(%ebp)
11027b: e8 c8 f9 ff ff call 10fc48 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
110280: 83 c4 10 add $0x10,%esp
return copied;
110283: 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 )
110285: 85 c0 test %eax,%eax
110287: 0f 84 c2 00 00 00 je 11034f <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;
11028d: 8b 55 cc mov -0x34(%ebp),%edx
110290: 2b 55 d0 sub -0x30(%ebp),%edx
110293: 3b 55 18 cmp 0x18(%ebp),%edx
110296: 76 03 jbe 11029b <IMFS_memfile_write+0xa7>
110298: 8b 55 18 mov 0x18(%ebp),%edx
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
11029b: 8b 00 mov (%eax),%eax
11029d: 03 45 d0 add -0x30(%ebp),%eax
src += to_copy;
1102a0: 89 c7 mov %eax,%edi
1102a2: 8b 75 14 mov 0x14(%ebp),%esi
1102a5: 89 d1 mov %edx,%ecx
1102a7: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
1102a9: 43 inc %ebx
my_length -= to_copy;
1102aa: 8b 4d 18 mov 0x18(%ebp),%ecx
1102ad: 29 d1 sub %edx,%ecx
1102af: 89 4d d4 mov %ecx,-0x2c(%ebp)
1102b2: eb 0b jmp 1102bf <IMFS_memfile_write+0xcb>
unsigned int last_byte;
unsigned int start_offset;
int copied;
const unsigned char *src;
src = source;
1102b4: 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 ) {
1102b7: 8b 45 18 mov 0x18(%ebp),%eax
1102ba: 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;
1102bd: 31 d2 xor %edx,%edx
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
1102bf: 8b 0d ec 4e 12 00 mov 0x124eec,%ecx
1102c5: 89 4d d0 mov %ecx,-0x30(%ebp)
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
1102c8: eb 2b jmp 1102f5 <IMFS_memfile_write+0x101>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
1102ca: 50 push %eax
1102cb: 6a 00 push $0x0
1102cd: 53 push %ebx
1102ce: ff 75 08 pushl 0x8(%ebp)
1102d1: 89 55 c8 mov %edx,-0x38(%ebp)
1102d4: e8 6f f9 ff ff call 10fc48 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
1102d9: 83 c4 10 add $0x10,%esp
1102dc: 85 c0 test %eax,%eax
1102de: 8b 55 c8 mov -0x38(%ebp),%edx
1102e1: 74 6a je 11034d <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 );
1102e3: 8b 00 mov (%eax),%eax
src += to_copy;
1102e5: 89 c7 mov %eax,%edi
1102e7: 8b 4d d0 mov -0x30(%ebp),%ecx
1102ea: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
1102ec: 43 inc %ebx
my_length -= to_copy;
1102ed: 8b 45 d0 mov -0x30(%ebp),%eax
1102f0: 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(
1102f3: 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 ) {
1102f5: 8b 4d d4 mov -0x2c(%ebp),%ecx
1102f8: 3b 0d ec 4e 12 00 cmp 0x124eec,%ecx
1102fe: 73 ca jae 1102ca <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 ) {
110300: 85 c9 test %ecx,%ecx
110302: 74 27 je 11032b <IMFS_memfile_write+0x137>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
110304: 57 push %edi
110305: 6a 00 push $0x0
110307: 53 push %ebx
110308: ff 75 08 pushl 0x8(%ebp)
11030b: 89 55 c8 mov %edx,-0x38(%ebp)
11030e: e8 35 f9 ff ff call 10fc48 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
110313: 83 c4 10 add $0x10,%esp
110316: 8b 55 c8 mov -0x38(%ebp),%edx
110319: 89 d1 mov %edx,%ecx
11031b: 85 c0 test %eax,%eax
11031d: 74 30 je 11034f <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 );
11031f: 8b 00 mov (%eax),%eax
110321: 89 c7 mov %eax,%edi
110323: 8b 4d d4 mov -0x2c(%ebp),%ecx
110326: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
my_length = 0;
copied += to_copy;
110328: 03 55 d4 add -0x2c(%ebp),%edx
}
IMFS_mtime_ctime_update( the_jnode );
11032b: 53 push %ebx
11032c: 53 push %ebx
11032d: 6a 00 push $0x0
11032f: 8d 45 e0 lea -0x20(%ebp),%eax
110332: 50 push %eax
110333: 89 55 c8 mov %edx,-0x38(%ebp)
110336: e8 b5 70 ff ff call 1073f0 <gettimeofday>
11033b: 8b 45 e0 mov -0x20(%ebp),%eax
11033e: 8b 5d 08 mov 0x8(%ebp),%ebx
110341: 89 43 44 mov %eax,0x44(%ebx)
110344: 89 43 48 mov %eax,0x48(%ebx)
return copied;
110347: 83 c4 10 add $0x10,%esp
11034a: 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 )
11034d: 89 d1 mov %edx,%ecx
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
11034f: 89 c8 mov %ecx,%eax
110351: 8d 65 f4 lea -0xc(%ebp),%esp
110354: 5b pop %ebx
110355: 5e pop %esi
110356: 5f pop %edi
110357: c9 leave
110358: c3 ret
00106dc0 <IMFS_mount>:
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
106dc0: 55 push %ebp
106dc1: 89 e5 mov %esp,%ebp
106dc3: 83 ec 08 sub $0x8,%esp
106dc6: 8b 55 08 mov 0x8(%ebp),%edx
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
106dc9: 8b 42 08 mov 0x8(%edx),%eax
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
106dcc: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
106dd0: 74 10 je 106de2 <IMFS_mount+0x22> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
106dd2: e8 61 a3 00 00 call 111138 <__errno> <== NOT EXECUTED
106dd7: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
106ddd: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106de0: eb 05 jmp 106de7 <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;
106de2: 89 50 5c mov %edx,0x5c(%eax)
return 0;
106de5: 31 c0 xor %eax,%eax
}
106de7: c9 leave
106de8: c3 ret
00109558 <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
109558: 55 push %ebp
109559: 89 e5 mov %esp,%ebp
10955b: 53 push %ebx
10955c: 83 ec 0c sub $0xc,%esp
10955f: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
109562: a1 20 99 12 00 mov 0x129920,%eax
109567: ff 70 08 pushl 0x8(%eax)
10956a: 8d 43 0c lea 0xc(%ebx),%eax
10956d: 50 push %eax
10956e: e8 39 be 00 00 call 1153ac <fputs>
switch( the_jnode->type ) {
109573: 8b 43 4c mov 0x4c(%ebx),%eax
109576: 83 c4 10 add $0x10,%esp
109579: 8d 50 ff lea -0x1(%eax),%edx
10957c: 83 fa 06 cmp $0x6,%edx
10957f: 77 75 ja 1095f6 <IMFS_print_jnode+0x9e> <== NEVER TAKEN
109581: a1 20 99 12 00 mov 0x129920,%eax
109586: ff 24 95 3c 49 12 00 jmp *0x12493c(,%edx,4)
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
10958d: 51 push %ecx
10958e: 51 push %ecx
10958f: ff 70 08 pushl 0x8(%eax)
109592: 6a 2f push $0x2f
109594: e8 67 bd 00 00 call 115300 <fputc>
109599: eb 2b jmp 1095c6 <IMFS_print_jnode+0x6e>
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
10959b: ff 73 54 pushl 0x54(%ebx)
10959e: ff 73 50 pushl 0x50(%ebx)
1095a1: 68 61 48 12 00 push $0x124861
1095a6: eb 16 jmp 1095be <IMFS_print_jnode+0x66>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
1095a8: ff 73 58 pushl 0x58(%ebx)
1095ab: ff 73 50 pushl 0x50(%ebx)
1095ae: 68 74 48 12 00 push $0x124874
1095b3: eb 09 jmp 1095be <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 ")",
1095b5: 52 push %edx
1095b6: ff 73 50 pushl 0x50(%ebx)
1095b9: 68 83 48 12 00 push $0x124883
1095be: ff 70 08 pushl 0x8(%eax)
1095c1: e8 da bc 00 00 call 1152a0 <fprintf>
(uint32_t)the_jnode->info.file.size );
#endif
break;
1095c6: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
1095c9: c7 45 08 6d 4b 12 00 movl $0x124b6d,0x8(%ebp)
}
1095d0: 8b 5d fc mov -0x4(%ebp),%ebx
1095d3: c9 leave
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
1095d4: e9 8f d5 00 00 jmp 116b68 <puts>
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
1095d9: 53 push %ebx
1095da: 53 push %ebx
1095db: ff 70 08 pushl 0x8(%eax)
1095de: 68 8f 48 12 00 push $0x12488f
1095e3: eb 0a jmp 1095ef <IMFS_print_jnode+0x97>
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
1095e5: 51 push %ecx
1095e6: 51 push %ecx
1095e7: ff 70 08 pushl 0x8(%eax)
1095ea: 68 a3 48 12 00 push $0x1248a3
1095ef: e8 b8 bd 00 00 call 1153ac <fputs>
1095f4: eb 14 jmp 10960a <IMFS_print_jnode+0xb2>
return;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
1095f6: 52 push %edx <== NOT EXECUTED
1095f7: 50 push %eax <== NOT EXECUTED
1095f8: 68 b6 48 12 00 push $0x1248b6 <== NOT EXECUTED
1095fd: a1 20 99 12 00 mov 0x129920,%eax <== NOT EXECUTED
109602: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
109605: e8 96 bc 00 00 call 1152a0 <fprintf> <== NOT EXECUTED
return;
10960a: 83 c4 10 add $0x10,%esp
}
puts("");
}
10960d: 8b 5d fc mov -0x4(%ebp),%ebx
109610: c9 leave
109611: c3 ret
00106e28 <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 */
)
{
106e28: 55 push %ebp
106e29: 89 e5 mov %esp,%ebp
106e2b: 53 push %ebx
106e2c: 83 ec 18 sub $0x18,%esp
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
106e2f: 8b 45 0c mov 0xc(%ebp),%eax
106e32: 8b 18 mov (%eax),%ebx
strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
106e34: 6a 20 push $0x20
106e36: ff 75 14 pushl 0x14(%ebp)
106e39: 8d 43 0c lea 0xc(%ebx),%eax
106e3c: 50 push %eax
106e3d: e8 ca b1 00 00 call 11200c <strncpy>
if ( the_jnode->Parent != NULL )
106e42: 83 c4 10 add $0x10,%esp
106e45: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
106e49: 74 0c je 106e57 <IMFS_rename+0x2f> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
106e4b: 83 ec 0c sub $0xc,%esp
106e4e: 53 push %ebx
106e4f: e8 04 3c 00 00 call 10aa58 <_Chain_Extract>
106e54: 83 c4 10 add $0x10,%esp
rtems_chain_extract( (rtems_chain_node *) the_jnode );
new_parent = new_parent_loc->node_access;
106e57: 8b 45 10 mov 0x10(%ebp),%eax
106e5a: 8b 00 mov (%eax),%eax
the_jnode->Parent = new_parent;
106e5c: 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 );
106e5f: 51 push %ecx
106e60: 51 push %ecx
106e61: 53 push %ebx
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
106e62: 83 c0 50 add $0x50,%eax
106e65: 50 push %eax
106e66: e8 c9 3b 00 00 call 10aa34 <_Chain_Append>
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
106e6b: 58 pop %eax
106e6c: 5a pop %edx
106e6d: 6a 00 push $0x0
106e6f: 8d 45 f0 lea -0x10(%ebp),%eax
106e72: 50 push %eax
106e73: e8 78 05 00 00 call 1073f0 <gettimeofday>
106e78: 8b 45 f0 mov -0x10(%ebp),%eax
106e7b: 89 43 48 mov %eax,0x48(%ebx)
return 0;
}
106e7e: 31 c0 xor %eax,%eax
106e80: 8b 5d fc mov -0x4(%ebp),%ebx
106e83: c9 leave
106e84: c3 ret
0010dfa8 <IMFS_stat>:
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
10dfa8: 55 push %ebp
10dfa9: 89 e5 mov %esp,%ebp
10dfab: 56 push %esi
10dfac: 53 push %ebx
10dfad: 8b 4d 08 mov 0x8(%ebp),%ecx
10dfb0: 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;
10dfb3: 8b 11 mov (%ecx),%edx
switch ( the_jnode->type ) {
10dfb5: 8b 5a 4c mov 0x4c(%edx),%ebx
10dfb8: 83 eb 02 sub $0x2,%ebx
10dfbb: 83 fb 05 cmp $0x5,%ebx
10dfbe: 77 33 ja 10dff3 <IMFS_stat+0x4b> <== NEVER TAKEN
10dfc0: ff 24 9d dc f4 11 00 jmp *0x11f4dc(,%ebx,4)
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
10dfc7: 8b 5a 54 mov 0x54(%edx),%ebx
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
10dfca: 8b 72 50 mov 0x50(%edx),%esi
10dfcd: 89 70 18 mov %esi,0x18(%eax)
10dfd0: 89 58 1c mov %ebx,0x1c(%eax)
break;
10dfd3: eb 2e jmp 10e003 <IMFS_stat+0x5b>
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
10dfd5: 8b 5a 50 mov 0x50(%edx),%ebx
10dfd8: 8b 72 54 mov 0x54(%edx),%esi
10dfdb: 89 58 20 mov %ebx,0x20(%eax)
10dfde: 89 70 24 mov %esi,0x24(%eax)
break;
10dfe1: eb 20 jmp 10e003 <IMFS_stat+0x5b>
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
10dfe3: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
10dfea: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
break;
10dff1: eb 10 jmp 10e003 <IMFS_stat+0x5b>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
10dff3: e8 40 31 00 00 call 111138 <__errno>
10dff8: c7 00 86 00 00 00 movl $0x86,(%eax)
10dffe: 83 c8 ff or $0xffffffff,%eax
10e001: eb 47 jmp 10e04a <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;
10e003: 8b 49 10 mov 0x10(%ecx),%ecx
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
10e006: 8b 49 34 mov 0x34(%ecx),%ecx
10e009: 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 =
10e00b: c7 00 fe ff 00 00 movl $0xfffe,(%eax)
10e011: 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;
10e014: 8b 4a 30 mov 0x30(%edx),%ecx
10e017: 89 48 0c mov %ecx,0xc(%eax)
buf->st_nlink = the_jnode->st_nlink;
10e01a: 8b 4a 34 mov 0x34(%edx),%ecx
10e01d: 66 89 48 10 mov %cx,0x10(%eax)
buf->st_ino = the_jnode->st_ino;
10e021: 8b 4a 38 mov 0x38(%edx),%ecx
10e024: 89 48 08 mov %ecx,0x8(%eax)
buf->st_uid = the_jnode->st_uid;
10e027: 8b 4a 3c mov 0x3c(%edx),%ecx
10e02a: 66 89 48 12 mov %cx,0x12(%eax)
buf->st_gid = the_jnode->st_gid;
10e02e: 66 8b 4a 3e mov 0x3e(%edx),%cx
10e032: 66 89 48 14 mov %cx,0x14(%eax)
buf->st_atime = the_jnode->stat_atime;
10e036: 8b 4a 40 mov 0x40(%edx),%ecx
10e039: 89 48 28 mov %ecx,0x28(%eax)
buf->st_mtime = the_jnode->stat_mtime;
10e03c: 8b 4a 44 mov 0x44(%edx),%ecx
10e03f: 89 48 30 mov %ecx,0x30(%eax)
buf->st_ctime = the_jnode->stat_ctime;
10e042: 8b 52 48 mov 0x48(%edx),%edx
10e045: 89 50 38 mov %edx,0x38(%eax)
return 0;
10e048: 31 c0 xor %eax,%eax
}
10e04a: 5b pop %ebx
10e04b: 5e pop %esi
10e04c: c9 leave
10e04d: c3 ret
00106f14 <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
106f14: 55 push %ebp
106f15: 89 e5 mov %esp,%ebp
106f17: 57 push %edi
106f18: 56 push %esi
106f19: 53 push %ebx
106f1a: 83 ec 2c sub $0x2c,%esp
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
106f1d: 8b 45 0c mov 0xc(%ebp),%eax
106f20: 8b 18 mov (%eax),%ebx
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
106f22: 83 7b 4c 03 cmpl $0x3,0x4c(%ebx)
106f26: 75 7a jne 106fa2 <IMFS_unlink+0x8e>
if ( !node->info.hard_link.link_node )
106f28: 8b 43 50 mov 0x50(%ebx),%eax
106f2b: 85 c0 test %eax,%eax
106f2d: 75 10 jne 106f3f <IMFS_unlink+0x2b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
106f2f: e8 04 a2 00 00 call 111138 <__errno> <== NOT EXECUTED
106f34: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
106f3a: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106f3d: eb 75 jmp 106fb4 <IMFS_unlink+0xa0> <== NOT EXECUTED
the_link = *loc;
106f3f: 8d 7d cc lea -0x34(%ebp),%edi
106f42: b9 05 00 00 00 mov $0x5,%ecx
106f47: 8b 75 0c mov 0xc(%ebp),%esi
106f4a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_link.node_access = node->info.hard_link.link_node;
106f4c: 89 45 cc mov %eax,-0x34(%ebp)
IMFS_Set_handlers( &the_link );
106f4f: 83 ec 0c sub $0xc,%esp
106f52: 8d 75 cc lea -0x34(%ebp),%esi
106f55: 56 push %esi
106f56: e8 dd 67 00 00 call 10d738 <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)
106f5b: 8b 43 50 mov 0x50(%ebx),%eax
106f5e: 8b 50 34 mov 0x34(%eax),%edx
106f61: 83 c4 10 add $0x10,%esp
106f64: 66 83 fa 01 cmp $0x1,%dx
106f68: 75 1a jne 106f84 <IMFS_unlink+0x70>
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
106f6a: 51 push %ecx
106f6b: 51 push %ecx
106f6c: 56 push %esi
106f6d: ff 75 08 pushl 0x8(%ebp)
106f70: 8b 45 d4 mov -0x2c(%ebp),%eax
106f73: ff 50 34 call *0x34(%eax)
106f76: 89 c2 mov %eax,%edx
if ( result != 0 )
106f78: 83 c4 10 add $0x10,%esp
return -1;
106f7b: 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 )
106f7e: 85 d2 test %edx,%edx
106f80: 74 20 je 106fa2 <IMFS_unlink+0x8e>
106f82: eb 30 jmp 106fb4 <IMFS_unlink+0xa0>
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
106f84: 4a dec %edx
106f85: 66 89 50 34 mov %dx,0x34(%eax)
IMFS_update_ctime( node->info.hard_link.link_node );
106f89: 52 push %edx
106f8a: 52 push %edx
106f8b: 6a 00 push $0x0
106f8d: 8d 45 e0 lea -0x20(%ebp),%eax
106f90: 50 push %eax
106f91: e8 5a 04 00 00 call 1073f0 <gettimeofday>
106f96: 8b 43 50 mov 0x50(%ebx),%eax
106f99: 8b 55 e0 mov -0x20(%ebp),%edx
106f9c: 89 50 48 mov %edx,0x48(%eax)
106f9f: 83 c4 10 add $0x10,%esp
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
106fa2: 50 push %eax
106fa3: 50 push %eax
106fa4: 8b 55 0c mov 0xc(%ebp),%edx
106fa7: 8b 42 08 mov 0x8(%edx),%eax
106faa: 52 push %edx
106fab: ff 75 08 pushl 0x8(%ebp)
106fae: ff 50 34 call *0x34(%eax)
return result;
106fb1: 83 c4 10 add $0x10,%esp
}
106fb4: 8d 65 f4 lea -0xc(%ebp),%esp
106fb7: 5b pop %ebx
106fb8: 5e pop %esi
106fb9: 5f pop %edi
106fba: c9 leave
106fbb: c3 ret
00106fbc <IMFS_unmount>:
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
106fbc: 55 push %ebp
106fbd: 89 e5 mov %esp,%ebp
106fbf: 83 ec 08 sub $0x8,%esp
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
106fc2: 8b 45 08 mov 0x8(%ebp),%eax
106fc5: 8b 40 08 mov 0x8(%eax),%eax
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
106fc8: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
106fcc: 74 0d je 106fdb <IMFS_unmount+0x1f> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
106fce: e8 65 a1 00 00 call 111138 <__errno> <== NOT EXECUTED
106fd3: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
106fd9: eb 11 jmp 106fec <IMFS_unmount+0x30> <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
106fdb: 83 78 5c 00 cmpl $0x0,0x5c(%eax)
106fdf: 75 10 jne 106ff1 <IMFS_unmount+0x35> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
106fe1: e8 52 a1 00 00 call 111138 <__errno> <== NOT EXECUTED
106fe6: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
106fec: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106fef: eb 09 jmp 106ffa <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;
106ff1: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
return 0;
106ff8: 31 c0 xor %eax,%eax
}
106ffa: c9 leave
106ffb: c3 ret
00107148 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
107148: 55 push %ebp <== NOT EXECUTED
107149: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10714b: 57 push %edi <== NOT EXECUTED
10714c: 56 push %esi <== NOT EXECUTED
10714d: 53 push %ebx <== NOT EXECUTED
10714e: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED
107151: 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) {
107154: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED
107157: 75 1d jne 107176 <Stack_check_Dump_threads_usage+0x2e><== NOT EXECUTED
if (!Stack_check_Interrupt_stack.area)
107159: 83 3d 3c 72 12 00 00 cmpl $0x0,0x12723c <== NOT EXECUTED
107160: 0f 84 f5 00 00 00 je 10725b <Stack_check_Dump_threads_usage+0x113><== NOT EXECUTED
return;
stack = &Stack_check_Interrupt_stack;
107166: ba 38 72 12 00 mov $0x127238,%edx <== NOT EXECUTED
the_thread = 0;
current = 0;
10716b: 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;
107172: 31 db xor %ebx,%ebx <== NOT EXECUTED
107174: eb 0f jmp 107185 <Stack_check_Dump_threads_usage+0x3d><== NOT EXECUTED
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
107176: 8d 93 b8 00 00 00 lea 0xb8(%ebx),%edx <== NOT EXECUTED
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
10717c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
107182: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED
}
low = Stack_check_usable_stack_start(stack);
107185: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED
107188: 8d 48 10 lea 0x10(%eax),%ecx <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
10718b: 8b 32 mov (%edx),%esi <== NOT EXECUTED
10718d: 83 ee 10 sub $0x10,%esi <== NOT EXECUTED
107190: 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;
107193: 83 c0 20 add $0x20,%eax <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
107196: 83 e6 fc and $0xfffffffc,%esi <== NOT EXECUTED
107199: 8d 34 30 lea (%eax,%esi,1),%esi <== NOT EXECUTED
10719c: eb 0b jmp 1071a9 <Stack_check_Dump_threads_usage+0x61><== NOT EXECUTED
if (*base != U32_PATTERN)
10719e: 81 38 a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%eax) <== NOT EXECUTED
1071a4: 75 0b jne 1071b1 <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++)
1071a6: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
1071a9: 39 f0 cmp %esi,%eax <== NOT EXECUTED
1071ab: 72 f1 jb 10719e <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;
1071ad: 31 ff xor %edi,%edi <== NOT EXECUTED
1071af: eb 0e jmp 1071bf <Stack_check_Dump_threads_usage+0x77><== NOT EXECUTED
1071b1: 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 )
1071b3: 85 c0 test %eax,%eax <== NOT EXECUTED
1071b5: 74 08 je 1071bf <Stack_check_Dump_threads_usage+0x77><== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
1071b7: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED
1071ba: 8d 3c 39 lea (%ecx,%edi,1),%edi <== NOT EXECUTED
1071bd: 29 c7 sub %eax,%edi <== NOT EXECUTED
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
1071bf: 85 db test %ebx,%ebx <== NOT EXECUTED
1071c1: 8b 35 14 6f 12 00 mov 0x126f14,%esi <== NOT EXECUTED
1071c7: 74 28 je 1071f1 <Stack_check_Dump_threads_usage+0xa9><== NOT EXECUTED
#endif
{
(*print_handler)(
1071c9: 50 push %eax <== NOT EXECUTED
1071ca: 8d 45 e3 lea -0x1d(%ebp),%eax <== NOT EXECUTED
1071cd: 50 push %eax <== NOT EXECUTED
1071ce: 6a 05 push $0x5 <== NOT EXECUTED
1071d0: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
1071d3: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED
1071d6: e8 cd 53 00 00 call 10c5a8 <rtems_object_get_name> <== NOT EXECUTED
1071db: 50 push %eax <== NOT EXECUTED
1071dc: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
1071df: 68 57 16 12 00 push $0x121657 <== NOT EXECUTED
1071e4: ff 35 10 6f 12 00 pushl 0x126f10 <== NOT EXECUTED
1071ea: ff d6 call *%esi <== NOT EXECUTED
1071ec: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
1071ef: eb 16 jmp 107207 <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 );
1071f1: 53 push %ebx <== NOT EXECUTED
1071f2: 6a ff push $0xffffffff <== NOT EXECUTED
1071f4: 68 64 16 12 00 push $0x121664 <== NOT EXECUTED
1071f9: ff 35 10 6f 12 00 pushl 0x126f10 <== NOT EXECUTED
1071ff: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED
107202: ff d6 call *%esi <== NOT EXECUTED
107204: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107207: 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,
10720a: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
10720d: 51 push %ecx <== NOT EXECUTED
10720e: 51 push %ecx <== NOT EXECUTED
10720f: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED
107212: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
107215: 8b 12 mov (%edx),%edx <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
107217: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED
10721b: 52 push %edx <== NOT EXECUTED
10721c: 50 push %eax <== NOT EXECUTED
10721d: 68 72 16 12 00 push $0x121672 <== NOT EXECUTED
107222: ff 35 10 6f 12 00 pushl 0x126f10 <== NOT EXECUTED
107228: ff 15 14 6f 12 00 call *0x126f14 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
10722e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
107231: 83 3d 18 6f 12 00 00 cmpl $0x0,0x126f18 <== NOT EXECUTED
107238: 8b 35 14 6f 12 00 mov 0x126f14,%esi <== NOT EXECUTED
10723e: 75 09 jne 107249 <Stack_check_Dump_threads_usage+0x101><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
107240: 52 push %edx <== NOT EXECUTED
107241: 52 push %edx <== NOT EXECUTED
107242: 68 90 16 12 00 push $0x121690 <== NOT EXECUTED
107247: eb 07 jmp 107250 <Stack_check_Dump_threads_usage+0x108><== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
107249: 50 push %eax <== NOT EXECUTED
10724a: 57 push %edi <== NOT EXECUTED
10724b: 68 9d 16 12 00 push $0x12169d <== NOT EXECUTED
107250: ff 35 10 6f 12 00 pushl 0x126f10 <== NOT EXECUTED
107256: ff d6 call *%esi <== NOT EXECUTED
107258: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
10725b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10725e: 5b pop %ebx <== NOT EXECUTED
10725f: 5e pop %esi <== NOT EXECUTED
107260: 5f pop %edi <== NOT EXECUTED
107261: c9 leave <== NOT EXECUTED
107262: c3 ret <== NOT EXECUTED
00107263 <Stack_check_Initialize>:
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
{
107263: 55 push %ebp
107264: 89 e5 mov %esp,%ebp
107266: 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 )
107267: 83 3d 18 6f 12 00 00 cmpl $0x0,0x126f18
10726e: 75 5a jne 1072ca <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 ];
107270: c7 05 28 72 12 00 0d movl $0xfeedf00d,0x127228
107277: f0 ed fe
10727a: c7 05 2c 72 12 00 06 movl $0xbad0d06,0x12722c
107281: 0d ad 0b
107284: c7 05 30 72 12 00 0d movl $0xdeadf00d,0x127230
10728b: f0 ad de
10728e: c7 05 34 72 12 00 06 movl $0x600d0d06,0x127234
107295: 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) {
107298: 8b 15 10 79 12 00 mov 0x127910,%edx
10729e: 85 d2 test %edx,%edx
1072a0: 74 1e je 1072c0 <Stack_check_Initialize+0x5d><== NEVER TAKEN
1072a2: 8b 0d 14 79 12 00 mov 0x127914,%ecx
1072a8: 85 c9 test %ecx,%ecx
1072aa: 74 14 je 1072c0 <Stack_check_Initialize+0x5d><== NEVER TAKEN
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
1072ac: 89 15 3c 72 12 00 mov %edx,0x12723c
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
1072b2: 29 d1 sub %edx,%ecx
1072b4: 89 0d 38 72 12 00 mov %ecx,0x127238
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
1072ba: b0 a5 mov $0xa5,%al
1072bc: 89 d7 mov %edx,%edi
1072be: f3 aa rep stos %al,%es:(%edi)
}
#endif
Stack_check_Initialized = 1;
1072c0: c7 05 18 6f 12 00 01 movl $0x1,0x126f18
1072c7: 00 00 00
}
1072ca: 5f pop %edi
1072cb: c9 leave
1072cc: c3 ret
0010731b <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)
{
10731b: 55 push %ebp <== NOT EXECUTED
10731c: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10731e: 56 push %esi <== NOT EXECUTED
10731f: 53 push %ebx <== NOT EXECUTED
107320: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED
107323: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
107326: 8a 55 0c mov 0xc(%ebp),%dl <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
107329: 8b b3 bc 00 00 00 mov 0xbc(%ebx),%esi <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
10732f: 68 a3 16 12 00 push $0x1216a3 <== NOT EXECUTED
107334: 88 55 d4 mov %dl,-0x2c(%ebp) <== NOT EXECUTED
107337: e8 2c 19 00 00 call 108c68 <printk> <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
10733c: 5a pop %edx <== NOT EXECUTED
10733d: 59 pop %ecx <== NOT EXECUTED
10733e: 53 push %ebx <== NOT EXECUTED
10733f: 68 b3 16 12 00 push $0x1216b3 <== NOT EXECUTED
107344: e8 1f 19 00 00 call 108c68 <printk> <== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
107349: 59 pop %ecx <== NOT EXECUTED
10734a: 58 pop %eax <== NOT EXECUTED
10734b: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
10734e: 68 d0 16 12 00 push $0x1216d0 <== NOT EXECUTED
107353: e8 10 19 00 00 call 108c68 <printk> <== NOT EXECUTED
printk(
107358: 58 pop %eax <== NOT EXECUTED
107359: 5a pop %edx <== NOT EXECUTED
10735a: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED
10735d: 68 e2 16 12 00 push $0x1216e2 <== NOT EXECUTED
107362: e8 01 19 00 00 call 108c68 <printk> <== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
107367: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10736a: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED
10736d: 50 push %eax <== NOT EXECUTED
10736e: 6a 20 push $0x20 <== NOT EXECUTED
107370: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
107373: e8 30 52 00 00 call 10c5a8 <rtems_object_get_name> <== NOT EXECUTED
107378: 5a pop %edx <== NOT EXECUTED
107379: 59 pop %ecx <== NOT EXECUTED
10737a: 50 push %eax <== NOT EXECUTED
10737b: 68 f6 16 12 00 push $0x1216f6 <== NOT EXECUTED
107380: e8 e3 18 00 00 call 108c68 <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)
107385: 8b 8b bc 00 00 00 mov 0xbc(%ebx),%ecx <== NOT EXECUTED
10738b: 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(
107391: 8d 1c 01 lea (%ecx,%eax,1),%ebx <== NOT EXECUTED
107394: 53 push %ebx <== NOT EXECUTED
107395: 51 push %ecx <== NOT EXECUTED
107396: 50 push %eax <== NOT EXECUTED
107397: 68 0c 17 12 00 push $0x12170c <== NOT EXECUTED
10739c: e8 c7 18 00 00 call 108c68 <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) {
1073a1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
1073a4: 8a 55 d4 mov -0x2c(%ebp),%dl <== NOT EXECUTED
1073a7: 84 d2 test %dl,%dl <== NOT EXECUTED
1073a9: 75 17 jne 1073c2 <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);
1073ab: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
printk(
1073ae: 83 c6 18 add $0x18,%esi <== NOT EXECUTED
1073b1: 56 push %esi <== NOT EXECUTED
1073b2: 50 push %eax <== NOT EXECUTED
1073b3: 6a 10 push $0x10 <== NOT EXECUTED
1073b5: 68 3d 17 12 00 push $0x12173d <== NOT EXECUTED
1073ba: e8 a9 18 00 00 call 108c68 <printk> <== NOT EXECUTED
1073bf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
1073c2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1073c5: 68 81 00 00 00 push $0x81 <== NOT EXECUTED
1073ca: e8 21 59 00 00 call 10ccf0 <rtems_fatal_error_occurred><== NOT EXECUTED
0010ce60 <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
10ce60: 55 push %ebp
10ce61: 89 e5 mov %esp,%ebp
10ce63: 53 push %ebx
10ce64: 83 ec 04 sub $0x4,%esp
10ce67: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10ce6a: 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 );
10ce70: 9c pushf
10ce71: fa cli
10ce72: 58 pop %eax
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
10ce73: 8b 4b 44 mov 0x44(%ebx),%ecx
10ce76: 85 c9 test %ecx,%ecx
10ce78: 75 0b jne 10ce85 <_CORE_RWLock_Release+0x25>
_ISR_Enable( level );
10ce7a: 50 push %eax
10ce7b: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10ce7c: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx)
return CORE_RWLOCK_SUCCESSFUL;
10ce83: eb 72 jmp 10cef7 <_CORE_RWLock_Release+0x97>
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
10ce85: 49 dec %ecx
10ce86: 75 0f jne 10ce97 <_CORE_RWLock_Release+0x37>
the_rwlock->number_of_readers -= 1;
10ce88: 8b 4b 48 mov 0x48(%ebx),%ecx
10ce8b: 49 dec %ecx
10ce8c: 89 4b 48 mov %ecx,0x48(%ebx)
if ( the_rwlock->number_of_readers != 0 ) {
10ce8f: 85 c9 test %ecx,%ecx
10ce91: 74 04 je 10ce97 <_CORE_RWLock_Release+0x37>
/* must be unlocked again */
_ISR_Enable( level );
10ce93: 50 push %eax
10ce94: 9d popf
return CORE_RWLOCK_SUCCESSFUL;
10ce95: eb 60 jmp 10cef7 <_CORE_RWLock_Release+0x97>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10ce97: 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;
10ce9e: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
_ISR_Enable( level );
10cea5: 50 push %eax
10cea6: 9d popf
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
10cea7: 83 ec 0c sub $0xc,%esp
10ceaa: 53 push %ebx
10ceab: e8 f0 17 00 00 call 10e6a0 <_Thread_queue_Dequeue>
if ( next ) {
10ceb0: 83 c4 10 add $0x10,%esp
10ceb3: 85 c0 test %eax,%eax
10ceb5: 74 40 je 10cef7 <_CORE_RWLock_Release+0x97>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
10ceb7: 83 78 30 01 cmpl $0x1,0x30(%eax)
10cebb: 75 09 jne 10cec6 <_CORE_RWLock_Release+0x66>
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
10cebd: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx)
return CORE_RWLOCK_SUCCESSFUL;
10cec4: eb 31 jmp 10cef7 <_CORE_RWLock_Release+0x97>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
10cec6: ff 43 48 incl 0x48(%ebx)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10cec9: 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 );
10ced0: 83 ec 0c sub $0xc,%esp
10ced3: 53 push %ebx
10ced4: e8 bf 1b 00 00 call 10ea98 <_Thread_queue_First>
if ( !next ||
10ced9: 83 c4 10 add $0x10,%esp
10cedc: 85 c0 test %eax,%eax
10cede: 74 17 je 10cef7 <_CORE_RWLock_Release+0x97>
10cee0: 83 78 30 01 cmpl $0x1,0x30(%eax)
10cee4: 74 11 je 10cef7 <_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;
10cee6: ff 43 48 incl 0x48(%ebx)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
10cee9: 52 push %edx
10ceea: 52 push %edx
10ceeb: 50 push %eax
10ceec: 53 push %ebx
10ceed: e8 96 1a 00 00 call 10e988 <_Thread_queue_Extract>
}
10cef2: 83 c4 10 add $0x10,%esp
10cef5: eb d9 jmp 10ced0 <_CORE_RWLock_Release+0x70>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10cef7: 31 c0 xor %eax,%eax
10cef9: 8b 5d fc mov -0x4(%ebp),%ebx
10cefc: c9 leave
10cefd: c3 ret
0010cf00 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
10cf00: 55 push %ebp
10cf01: 89 e5 mov %esp,%ebp
10cf03: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10cf06: 8d 45 f4 lea -0xc(%ebp),%eax
10cf09: 50 push %eax
10cf0a: ff 75 08 pushl 0x8(%ebp)
10cf0d: e8 72 14 00 00 call 10e384 <_Thread_Get>
switch ( location ) {
10cf12: 83 c4 10 add $0x10,%esp
10cf15: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10cf19: 75 17 jne 10cf32 <_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 );
10cf1b: 83 ec 0c sub $0xc,%esp
10cf1e: 50 push %eax
10cf1f: e8 40 1c 00 00 call 10eb64 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10cf24: a1 50 83 12 00 mov 0x128350,%eax
10cf29: 48 dec %eax
10cf2a: a3 50 83 12 00 mov %eax,0x128350
10cf2f: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10cf32: c9 leave
10cf33: c3 ret
001173c0 <_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
)
{
1173c0: 55 push %ebp
1173c1: 89 e5 mov %esp,%ebp
1173c3: 57 push %edi
1173c4: 56 push %esi
1173c5: 53 push %ebx
1173c6: 83 ec 1c sub $0x1c,%esp
1173c9: 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;
1173cc: 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 ) {
1173d1: 8b 55 10 mov 0x10(%ebp),%edx
1173d4: 3b 53 4c cmp 0x4c(%ebx),%edx
1173d7: 77 4e ja 117427 <_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 ) {
1173d9: 83 7b 48 00 cmpl $0x0,0x48(%ebx)
1173dd: 75 09 jne 1173e8 <_CORE_message_queue_Broadcast+0x28>
1173df: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
1173e6: eb 23 jmp 11740b <_CORE_message_queue_Broadcast+0x4b>
*count = 0;
1173e8: 8b 45 1c mov 0x1c(%ebp),%eax
1173eb: c7 00 00 00 00 00 movl $0x0,(%eax)
1173f1: eb 32 jmp 117425 <_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;
1173f3: ff 45 e4 incl -0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
1173f6: 8b 42 2c mov 0x2c(%edx),%eax
1173f9: 89 c7 mov %eax,%edi
1173fb: 8b 75 0c mov 0xc(%ebp),%esi
1173fe: 8b 4d 10 mov 0x10(%ebp),%ecx
117401: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
117403: 8b 42 28 mov 0x28(%edx),%eax
117406: 8b 55 10 mov 0x10(%ebp),%edx
117409: 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 =
11740b: 83 ec 0c sub $0xc,%esp
11740e: 53 push %ebx
11740f: e8 28 25 00 00 call 11993c <_Thread_queue_Dequeue>
117414: 89 c2 mov %eax,%edx
117416: 83 c4 10 add $0x10,%esp
117419: 85 c0 test %eax,%eax
11741b: 75 d6 jne 1173f3 <_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;
11741d: 8b 55 e4 mov -0x1c(%ebp),%edx
117420: 8b 45 1c mov 0x1c(%ebp),%eax
117423: 89 10 mov %edx,(%eax)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
117425: 31 c0 xor %eax,%eax
}
117427: 8d 65 f4 lea -0xc(%ebp),%esp
11742a: 5b pop %ebx
11742b: 5e pop %esi
11742c: 5f pop %edi
11742d: c9 leave
11742e: c3 ret
00112274 <_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
)
{
112274: 55 push %ebp
112275: 89 e5 mov %esp,%ebp
112277: 57 push %edi
112278: 56 push %esi
112279: 53 push %ebx
11227a: 83 ec 1c sub $0x1c,%esp
11227d: 8b 5d 08 mov 0x8(%ebp),%ebx
112280: 8b 7d 10 mov 0x10(%ebp),%edi
112283: 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;
112286: 89 7b 44 mov %edi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
112289: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
112290: 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;
112293: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
the_message_queue->notify_argument = the_argument;
11229a: 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)) {
1122a1: 89 d0 mov %edx,%eax
1122a3: f6 c2 03 test $0x3,%dl
1122a6: 74 0c je 1122b4 <_CORE_message_queue_Initialize+0x40>
allocated_message_size += sizeof(uint32_t);
1122a8: 83 c0 04 add $0x4,%eax
allocated_message_size &= ~(sizeof(uint32_t) - 1);
1122ab: 83 e0 fc and $0xfffffffc,%eax
}
if (allocated_message_size < maximum_message_size)
return false;
1122ae: 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)
1122b0: 39 d0 cmp %edx,%eax
1122b2: 72 68 jb 11231c <_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));
1122b4: 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 *
1122b7: 89 d1 mov %edx,%ecx
1122b9: 0f af cf imul %edi,%ecx
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
return false;
1122bc: 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)
1122be: 39 c1 cmp %eax,%ecx
1122c0: 72 5a jb 11231c <_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 );
1122c2: 83 ec 0c sub $0xc,%esp
1122c5: 51 push %ecx
1122c6: 89 55 e4 mov %edx,-0x1c(%ebp)
1122c9: e8 b4 27 00 00 call 114a82 <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
1122ce: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
1122d1: 83 c4 10 add $0x10,%esp
1122d4: 85 c0 test %eax,%eax
1122d6: 8b 55 e4 mov -0x1c(%ebp),%edx
1122d9: 74 41 je 11231c <_CORE_message_queue_Initialize+0xa8>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
1122db: 52 push %edx
1122dc: 57 push %edi
1122dd: 50 push %eax
1122de: 8d 43 68 lea 0x68(%ebx),%eax
1122e1: 50 push %eax
1122e2: e8 f5 4a 00 00 call 116ddc <_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 );
1122e7: 8d 43 54 lea 0x54(%ebx),%eax
1122ea: 89 43 50 mov %eax,0x50(%ebx)
head->next = tail;
head->previous = NULL;
1122ed: 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 );
1122f4: 8d 43 50 lea 0x50(%ebx),%eax
1122f7: 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(
1122fa: 6a 06 push $0x6
1122fc: 68 80 00 00 00 push $0x80
112301: 8b 45 0c mov 0xc(%ebp),%eax
112304: 83 38 01 cmpl $0x1,(%eax)
112307: 0f 94 c0 sete %al
11230a: 0f b6 c0 movzbl %al,%eax
11230d: 50 push %eax
11230e: 53 push %ebx
11230f: e8 94 1f 00 00 call 1142a8 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
112314: 83 c4 20 add $0x20,%esp
112317: be 01 00 00 00 mov $0x1,%esi
}
11231c: 89 f0 mov %esi,%eax
11231e: 8d 65 f4 lea -0xc(%ebp),%esp
112321: 5b pop %ebx
112322: 5e pop %esi
112323: 5f pop %edi
112324: c9 leave
112325: c3 ret
00112328 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
112328: 55 push %ebp
112329: 89 e5 mov %esp,%ebp
11232b: 57 push %edi
11232c: 56 push %esi
11232d: 53 push %ebx
11232e: 83 ec 2c sub $0x2c,%esp
112331: 8b 55 08 mov 0x8(%ebp),%edx
112334: 8b 45 0c mov 0xc(%ebp),%eax
112337: 89 45 dc mov %eax,-0x24(%ebp)
11233a: 8b 5d 10 mov 0x10(%ebp),%ebx
11233d: 89 5d e0 mov %ebx,-0x20(%ebp)
112340: 8b 4d 14 mov 0x14(%ebp),%ecx
112343: 8b 75 1c mov 0x1c(%ebp),%esi
112346: 89 75 d4 mov %esi,-0x2c(%ebp)
112349: 8a 45 18 mov 0x18(%ebp),%al
11234c: 88 45 db mov %al,-0x25(%ebp)
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
11234f: a1 f0 d9 12 00 mov 0x12d9f0,%eax
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
112354: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_ISR_Disable( level );
11235b: 9c pushf
11235c: fa cli
11235d: 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 );
}
112360: 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 );
112363: 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))
112366: 39 f3 cmp %esi,%ebx
112368: 0f 84 8a 00 00 00 je 1123f8 <_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;
11236e: 8b 33 mov (%ebx),%esi
head->next = new_first;
112370: 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 );
112373: 8d 7a 50 lea 0x50(%edx),%edi
112376: 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 ) {
112379: 85 db test %ebx,%ebx
11237b: 74 7b je 1123f8 <_CORE_message_queue_Seize+0xd0><== NEVER TAKEN
the_message_queue->number_of_pending_messages -= 1;
11237d: ff 4a 48 decl 0x48(%edx)
_ISR_Enable( level );
112380: ff 75 e4 pushl -0x1c(%ebp)
112383: 9d popf
*size_p = the_message->Contents.size;
112384: 8b 43 0c mov 0xc(%ebx),%eax
112387: 89 01 mov %eax,(%ecx)
_Thread_Executing->Wait.count =
112389: 8b 73 08 mov 0x8(%ebx),%esi
11238c: a1 f0 d9 12 00 mov 0x12d9f0,%eax
112391: 89 70 24 mov %esi,0x24(%eax)
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
112394: 8d 73 10 lea 0x10(%ebx),%esi
112397: 89 75 e4 mov %esi,-0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
11239a: 8b 09 mov (%ecx),%ecx
11239c: 8b 7d e0 mov -0x20(%ebp),%edi
11239f: 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 );
1123a1: 83 ec 0c sub $0xc,%esp
1123a4: 52 push %edx
1123a5: 89 55 d0 mov %edx,-0x30(%ebp)
1123a8: e8 c3 1b 00 00 call 113f70 <_Thread_queue_Dequeue>
if ( !the_thread ) {
1123ad: 83 c4 10 add $0x10,%esp
1123b0: 85 c0 test %eax,%eax
1123b2: 8b 55 d0 mov -0x30(%ebp),%edx
1123b5: 75 15 jne 1123cc <_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 );
1123b7: 89 5d 0c mov %ebx,0xc(%ebp)
1123ba: 83 c2 68 add $0x68,%edx
1123bd: 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 );
}
1123c0: 8d 65 f4 lea -0xc(%ebp),%esp
1123c3: 5b pop %ebx
1123c4: 5e pop %esi
1123c5: 5f pop %edi
1123c6: c9 leave
1123c7: e9 28 fe ff ff jmp 1121f4 <_Chain_Append>
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
1123cc: 8b 48 24 mov 0x24(%eax),%ecx
1123cf: 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;
1123d2: 8b 48 30 mov 0x30(%eax),%ecx
1123d5: 89 4b 0c mov %ecx,0xc(%ebx)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
1123d8: 8b 70 2c mov 0x2c(%eax),%esi
1123db: 8b 7d e4 mov -0x1c(%ebp),%edi
1123de: 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(
1123e0: 8b 43 08 mov 0x8(%ebx),%eax
1123e3: 89 45 10 mov %eax,0x10(%ebp)
1123e6: 89 5d 0c mov %ebx,0xc(%ebp)
1123e9: 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 );
}
1123ec: 8d 65 f4 lea -0xc(%ebp),%esp
1123ef: 5b pop %ebx
1123f0: 5e pop %esi
1123f1: 5f pop %edi
1123f2: c9 leave
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
1123f3: e9 1c 4a 00 00 jmp 116e14 <_CORE_message_queue_Insert_message>
return;
}
#endif
}
if ( !wait ) {
1123f8: 80 7d db 00 cmpb $0x0,-0x25(%ebp)
1123fc: 75 13 jne 112411 <_CORE_message_queue_Seize+0xe9>
_ISR_Enable( level );
1123fe: ff 75 e4 pushl -0x1c(%ebp)
112401: 9d popf
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
112402: 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 );
}
112409: 8d 65 f4 lea -0xc(%ebp),%esp
11240c: 5b pop %ebx
11240d: 5e pop %esi
11240e: 5f pop %edi
11240f: c9 leave
112410: 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;
112411: 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;
112418: 89 50 44 mov %edx,0x44(%eax)
executing->Wait.id = id;
11241b: 8b 5d dc mov -0x24(%ebp),%ebx
11241e: 89 58 20 mov %ebx,0x20(%eax)
executing->Wait.return_argument_second.mutable_object = buffer;
112421: 8b 75 e0 mov -0x20(%ebp),%esi
112424: 89 70 2c mov %esi,0x2c(%eax)
executing->Wait.return_argument = size_p;
112427: 89 48 28 mov %ecx,0x28(%eax)
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
11242a: ff 75 e4 pushl -0x1c(%ebp)
11242d: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
11242e: c7 45 10 58 43 11 00 movl $0x114358,0x10(%ebp)
112435: 8b 45 d4 mov -0x2c(%ebp),%eax
112438: 89 45 0c mov %eax,0xc(%ebp)
11243b: 89 55 08 mov %edx,0x8(%ebp)
}
11243e: 8d 65 f4 lea -0xc(%ebp),%esp
112441: 5b pop %ebx
112442: 5e pop %esi
112443: 5f pop %edi
112444: 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 );
112445: e9 32 1c 00 00 jmp 11407c <_Thread_queue_Enqueue_with_handler>
0010ab98 <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
10ab98: 55 push %ebp
10ab99: 89 e5 mov %esp,%ebp
10ab9b: 57 push %edi
10ab9c: 56 push %esi
10ab9d: 53 push %ebx
10ab9e: 83 ec 0c sub $0xc,%esp
10aba1: 8b 55 08 mov 0x8(%ebp),%edx
10aba4: 8b 5d 0c mov 0xc(%ebp),%ebx
10aba7: 8b 45 10 mov 0x10(%ebp),%eax
/* Add this to the RTEMS environment later ?????????
rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||
initial_lock == CORE_MUTEX_UNLOCKED );
*/
the_mutex->Attributes = *the_mutex_attributes;
10abaa: 8d 7a 40 lea 0x40(%edx),%edi
10abad: b9 04 00 00 00 mov $0x4,%ecx
10abb2: 89 de mov %ebx,%esi
10abb4: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_mutex->lock = initial_lock;
10abb6: 89 42 50 mov %eax,0x50(%edx)
the_mutex->blocked_count = 0;
10abb9: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx)
if ( initial_lock == CORE_MUTEX_LOCKED ) {
10abc0: 85 c0 test %eax,%eax
10abc2: 75 35 jne 10abf9 <_CORE_mutex_Initialize+0x61>
the_mutex->nest_count = 1;
10abc4: c7 42 54 01 00 00 00 movl $0x1,0x54(%edx)
the_mutex->holder = _Thread_Executing;
10abcb: 8b 0d 68 58 12 00 mov 0x125868,%ecx
10abd1: 89 4a 5c mov %ecx,0x5c(%edx)
the_mutex->holder_id = _Thread_Executing->Object.id;
10abd4: 8b 41 08 mov 0x8(%ecx),%eax
10abd7: 89 42 60 mov %eax,0x60(%edx)
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10abda: 8b 42 48 mov 0x48(%edx),%eax
if ( initial_lock == CORE_MUTEX_LOCKED ) {
the_mutex->nest_count = 1;
the_mutex->holder = _Thread_Executing;
the_mutex->holder_id = _Thread_Executing->Object.id;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
10abdd: 83 f8 02 cmp $0x2,%eax
10abe0: 74 05 je 10abe7 <_CORE_mutex_Initialize+0x4f>
10abe2: 83 f8 03 cmp $0x3,%eax
10abe5: 75 27 jne 10ac0e <_CORE_mutex_Initialize+0x76>
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
the_mutex->Attributes.priority_ceiling )
return CORE_MUTEX_STATUS_CEILING_VIOLATED;
10abe7: b8 06 00 00 00 mov $0x6,%eax
the_mutex->holder = _Thread_Executing;
the_mutex->holder_id = _Thread_Executing->Object.id;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
10abec: 8b 72 4c mov 0x4c(%edx),%esi
10abef: 39 71 14 cmp %esi,0x14(%ecx)
10abf2: 72 36 jb 10ac2a <_CORE_mutex_Initialize+0x92><== NEVER TAKEN
_Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = _Thread_Executing->current_priority;
#endif
_Thread_Executing->resource_count++;
10abf4: ff 41 1c incl 0x1c(%ecx)
10abf7: eb 15 jmp 10ac0e <_CORE_mutex_Initialize+0x76>
}
} else {
the_mutex->nest_count = 0;
10abf9: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx)
the_mutex->holder = NULL;
10ac00: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx)
the_mutex->holder_id = 0;
10ac07: c7 42 60 00 00 00 00 movl $0x0,0x60(%edx)
}
_Thread_queue_Initialize(
10ac0e: 6a 05 push $0x5
10ac10: 68 00 04 00 00 push $0x400
10ac15: 31 c0 xor %eax,%eax
10ac17: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10ac1b: 0f 95 c0 setne %al
10ac1e: 50 push %eax
10ac1f: 52 push %edx
10ac20: e8 4b 1c 00 00 call 10c870 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY,
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
10ac25: 83 c4 10 add $0x10,%esp
10ac28: 31 c0 xor %eax,%eax
}
10ac2a: 8d 65 f4 lea -0xc(%ebp),%esp
10ac2d: 5b pop %ebx
10ac2e: 5e pop %esi
10ac2f: 5f pop %edi
10ac30: c9 leave
10ac31: c3 ret
0010ac81 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10ac81: 55 push %ebp
10ac82: 89 e5 mov %esp,%ebp
10ac84: 53 push %ebx
10ac85: 83 ec 14 sub $0x14,%esp
10ac88: 8b 5d 08 mov 0x8(%ebp),%ebx
10ac8b: 8a 55 10 mov 0x10(%ebp),%dl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10ac8e: a1 40 53 12 00 mov 0x125340,%eax
10ac93: 85 c0 test %eax,%eax
10ac95: 74 19 je 10acb0 <_CORE_mutex_Seize+0x2f>
10ac97: 84 d2 test %dl,%dl
10ac99: 74 15 je 10acb0 <_CORE_mutex_Seize+0x2f><== NEVER TAKEN
10ac9b: 83 3d 9c 54 12 00 01 cmpl $0x1,0x12549c
10aca2: 76 0c jbe 10acb0 <_CORE_mutex_Seize+0x2f>
10aca4: 53 push %ebx
10aca5: 6a 12 push $0x12
10aca7: 6a 00 push $0x0
10aca9: 6a 00 push $0x0
10acab: e8 dc 05 00 00 call 10b28c <_Internal_error_Occurred>
10acb0: 51 push %ecx
10acb1: 51 push %ecx
10acb2: 8d 45 18 lea 0x18(%ebp),%eax
10acb5: 50 push %eax
10acb6: 53 push %ebx
10acb7: 88 55 f4 mov %dl,-0xc(%ebp)
10acba: e8 d5 47 00 00 call 10f494 <_CORE_mutex_Seize_interrupt_trylock>
10acbf: 83 c4 10 add $0x10,%esp
10acc2: 85 c0 test %eax,%eax
10acc4: 8a 55 f4 mov -0xc(%ebp),%dl
10acc7: 74 48 je 10ad11 <_CORE_mutex_Seize+0x90>
10acc9: 84 d2 test %dl,%dl
10accb: 75 12 jne 10acdf <_CORE_mutex_Seize+0x5e>
10accd: ff 75 18 pushl 0x18(%ebp)
10acd0: 9d popf
10acd1: a1 68 58 12 00 mov 0x125868,%eax
10acd6: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
10acdd: eb 32 jmp 10ad11 <_CORE_mutex_Seize+0x90>
10acdf: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
10ace6: a1 68 58 12 00 mov 0x125868,%eax
10aceb: 89 58 44 mov %ebx,0x44(%eax)
10acee: 8b 55 0c mov 0xc(%ebp),%edx
10acf1: 89 50 20 mov %edx,0x20(%eax)
10acf4: a1 40 53 12 00 mov 0x125340,%eax
10acf9: 40 inc %eax
10acfa: a3 40 53 12 00 mov %eax,0x125340
10acff: ff 75 18 pushl 0x18(%ebp)
10ad02: 9d popf
10ad03: 50 push %eax
10ad04: 50 push %eax
10ad05: ff 75 14 pushl 0x14(%ebp)
10ad08: 53 push %ebx
10ad09: e8 26 ff ff ff call 10ac34 <_CORE_mutex_Seize_interrupt_blocking>
10ad0e: 83 c4 10 add $0x10,%esp
}
10ad11: 8b 5d fc mov -0x4(%ebp),%ebx
10ad14: c9 leave
10ad15: c3 ret
0010ae3c <_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
)
{
10ae3c: 55 push %ebp
10ae3d: 89 e5 mov %esp,%ebp
10ae3f: 53 push %ebx
10ae40: 83 ec 10 sub $0x10,%esp
10ae43: 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)) ) {
10ae46: 53 push %ebx
10ae47: e8 ec 16 00 00 call 10c538 <_Thread_queue_Dequeue>
10ae4c: 89 c2 mov %eax,%edx
10ae4e: 83 c4 10 add $0x10,%esp
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10ae51: 31 c0 xor %eax,%eax
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
10ae53: 85 d2 test %edx,%edx
10ae55: 75 15 jne 10ae6c <_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 );
10ae57: 9c pushf
10ae58: fa cli
10ae59: 59 pop %ecx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10ae5a: 8b 53 48 mov 0x48(%ebx),%edx
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
10ae5d: 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 )
10ae5f: 3b 53 40 cmp 0x40(%ebx),%edx
10ae62: 73 06 jae 10ae6a <_CORE_semaphore_Surrender+0x2e><== NEVER TAKEN
the_semaphore->count += 1;
10ae64: 42 inc %edx
10ae65: 89 53 48 mov %edx,0x48(%ebx)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10ae68: 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 );
10ae6a: 51 push %ecx
10ae6b: 9d popf
}
return status;
}
10ae6c: 8b 5d fc mov -0x4(%ebp),%ebx
10ae6f: c9 leave
10ae70: c3 ret
00109da0 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
109da0: 55 push %ebp
109da1: 89 e5 mov %esp,%ebp
109da3: 57 push %edi
109da4: 56 push %esi
109da5: 53 push %ebx
109da6: 83 ec 2c sub $0x2c,%esp
109da9: 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 ];
109dac: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi
option_set = (rtems_option) the_thread->Wait.option;
109db2: 8b 43 30 mov 0x30(%ebx),%eax
109db5: 89 45 e0 mov %eax,-0x20(%ebp)
_ISR_Disable( level );
109db8: 9c pushf
109db9: fa cli
109dba: 58 pop %eax
pending_events = api->pending_events;
109dbb: 8b 17 mov (%edi),%edx
109dbd: 89 55 d4 mov %edx,-0x2c(%ebp)
event_condition = (rtems_event_set) the_thread->Wait.count;
109dc0: 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 ) ) {
109dc3: 21 f2 and %esi,%edx
109dc5: 75 07 jne 109dce <_Event_Surrender+0x2e>
_ISR_Enable( level );
109dc7: 50 push %eax
109dc8: 9d popf
return;
109dc9: e9 af 00 00 00 jmp 109e7d <_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() &&
109dce: 83 3d 64 58 12 00 00 cmpl $0x0,0x125864
109dd5: 74 49 je 109e20 <_Event_Surrender+0x80>
109dd7: 3b 1d 68 58 12 00 cmp 0x125868,%ebx
109ddd: 75 41 jne 109e20 <_Event_Surrender+0x80>
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
109ddf: 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 ) &&
109de5: 83 f9 02 cmp $0x2,%ecx
109de8: 74 09 je 109df3 <_Event_Surrender+0x53> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
109dea: 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) ||
109df0: 49 dec %ecx
109df1: 75 2d jne 109e20 <_Event_Surrender+0x80>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
109df3: 39 f2 cmp %esi,%edx
109df5: 74 06 je 109dfd <_Event_Surrender+0x5d>
109df7: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109dfb: 74 1f je 109e1c <_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) );
109dfd: 89 d6 mov %edx,%esi
109dff: f7 d6 not %esi
109e01: 23 75 d4 and -0x2c(%ebp),%esi
109e04: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
109e06: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109e0d: 8b 4b 28 mov 0x28(%ebx),%ecx
109e10: 89 11 mov %edx,(%ecx)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
109e12: c7 05 3c 5c 12 00 03 movl $0x3,0x125c3c
109e19: 00 00 00
}
_ISR_Enable( level );
109e1c: 50 push %eax
109e1d: 9d popf
return;
109e1e: eb 5d jmp 109e7d <_Event_Surrender+0xdd>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
109e20: f6 43 11 01 testb $0x1,0x11(%ebx)
109e24: 74 55 je 109e7b <_Event_Surrender+0xdb>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
109e26: 39 f2 cmp %esi,%edx
109e28: 74 06 je 109e30 <_Event_Surrender+0x90>
109e2a: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109e2e: 74 4b je 109e7b <_Event_Surrender+0xdb> <== NEVER TAKEN
109e30: 89 d6 mov %edx,%esi
109e32: f7 d6 not %esi
109e34: 23 75 d4 and -0x2c(%ebp),%esi
109e37: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
109e39: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109e40: 8b 4b 28 mov 0x28(%ebx),%ecx
109e43: 89 11 mov %edx,(%ecx)
_ISR_Flash( level );
109e45: 50 push %eax
109e46: 9d popf
109e47: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
109e48: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
109e4c: 74 06 je 109e54 <_Event_Surrender+0xb4>
_ISR_Enable( level );
109e4e: 50 push %eax
109e4f: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
109e50: 51 push %ecx
109e51: 51 push %ecx
109e52: eb 17 jmp 109e6b <_Event_Surrender+0xcb>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
109e54: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
109e5b: 50 push %eax
109e5c: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
109e5d: 83 ec 0c sub $0xc,%esp
109e60: 8d 43 48 lea 0x48(%ebx),%eax
109e63: 50 push %eax
109e64: e8 c7 30 00 00 call 10cf30 <_Watchdog_Remove>
109e69: 58 pop %eax
109e6a: 5a pop %edx
109e6b: 68 f8 ff 03 10 push $0x1003fff8
109e70: 53 push %ebx
109e71: e8 6e 20 00 00 call 10bee4 <_Thread_Clear_state>
109e76: 83 c4 10 add $0x10,%esp
109e79: eb 02 jmp 109e7d <_Event_Surrender+0xdd>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
109e7b: 50 push %eax
109e7c: 9d popf
}
109e7d: 8d 65 f4 lea -0xc(%ebp),%esp
109e80: 5b pop %ebx
109e81: 5e pop %esi
109e82: 5f pop %edi
109e83: c9 leave
109e84: c3 ret
00109e88 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
109e88: 55 push %ebp
109e89: 89 e5 mov %esp,%ebp
109e8b: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
109e8e: 8d 45 f4 lea -0xc(%ebp),%eax
109e91: 50 push %eax
109e92: ff 75 08 pushl 0x8(%ebp)
109e95: e8 82 23 00 00 call 10c21c <_Thread_Get>
switch ( location ) {
109e9a: 83 c4 10 add $0x10,%esp
109e9d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
109ea1: 75 49 jne 109eec <_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 );
109ea3: 9c pushf
109ea4: fa cli
109ea5: 5a pop %edx
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
109ea6: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
109ead: 3b 05 68 58 12 00 cmp 0x125868,%eax
109eb3: 75 13 jne 109ec8 <_Event_Timeout+0x40>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
109eb5: 8b 0d 3c 5c 12 00 mov 0x125c3c,%ecx
109ebb: 49 dec %ecx
109ebc: 75 0a jne 109ec8 <_Event_Timeout+0x40>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
109ebe: c7 05 3c 5c 12 00 02 movl $0x2,0x125c3c
109ec5: 00 00 00
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
109ec8: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax)
_ISR_Enable( level );
109ecf: 52 push %edx
109ed0: 9d popf
109ed1: 52 push %edx
109ed2: 52 push %edx
109ed3: 68 f8 ff 03 10 push $0x1003fff8
109ed8: 50 push %eax
109ed9: e8 06 20 00 00 call 10bee4 <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
109ede: a1 40 53 12 00 mov 0x125340,%eax
109ee3: 48 dec %eax
109ee4: a3 40 53 12 00 mov %eax,0x125340
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
109ee9: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
109eec: c9 leave
109eed: c3 ret
0010faeb <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
10faeb: 55 push %ebp
10faec: 89 e5 mov %esp,%ebp
10faee: 57 push %edi
10faef: 56 push %esi
10faf0: 53 push %ebx
10faf1: 83 ec 4c sub $0x4c,%esp
10faf4: 8b 5d 08 mov 0x8(%ebp),%ebx
10faf7: 8b 4d 10 mov 0x10(%ebp),%ecx
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
10fafa: 8b 43 20 mov 0x20(%ebx),%eax
10fafd: 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;
10fb00: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
Heap_Block *extend_last_block = NULL;
10fb07: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
uintptr_t const page_size = heap->page_size;
10fb0e: 8b 53 10 mov 0x10(%ebx),%edx
10fb11: 89 55 c4 mov %edx,-0x3c(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10fb14: 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;
10fb17: 8b 7b 30 mov 0x30(%ebx),%edi
10fb1a: 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;
10fb1d: 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 ) {
10fb1f: 8b 7d 0c mov 0xc(%ebp),%edi
10fb22: 01 cf add %ecx,%edi
10fb24: 0f 82 d4 01 00 00 jb 10fcfe <_Heap_Extend+0x213>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
10fb2a: 52 push %edx
10fb2b: 52 push %edx
10fb2c: 8d 55 e0 lea -0x20(%ebp),%edx
10fb2f: 52 push %edx
10fb30: 8d 55 e4 lea -0x1c(%ebp),%edx
10fb33: 52 push %edx
10fb34: 50 push %eax
10fb35: ff 75 c4 pushl -0x3c(%ebp)
10fb38: 51 push %ecx
10fb39: ff 75 0c pushl 0xc(%ebp)
10fb3c: e8 6e b8 ff ff call 10b3af <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
10fb41: 83 c4 20 add $0x20,%esp
10fb44: 84 c0 test %al,%al
10fb46: 0f 84 b2 01 00 00 je 10fcfe <_Heap_Extend+0x213>
10fb4c: 8b 4d c0 mov -0x40(%ebp),%ecx
10fb4f: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp)
10fb56: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
10fb5d: 31 f6 xor %esi,%esi
10fb5f: 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;
10fb66: 8b 43 18 mov 0x18(%ebx),%eax
10fb69: 89 5d b8 mov %ebx,-0x48(%ebp)
10fb6c: eb 02 jmp 10fb70 <_Heap_Extend+0x85>
10fb6e: 89 c8 mov %ecx,%eax
uintptr_t const sub_area_end = start_block->prev_size;
10fb70: 8b 19 mov (%ecx),%ebx
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
10fb72: 39 c7 cmp %eax,%edi
10fb74: 76 09 jbe 10fb7f <_Heap_Extend+0x94>
10fb76: 39 5d 0c cmp %ebx,0xc(%ebp)
10fb79: 0f 82 7d 01 00 00 jb 10fcfc <_Heap_Extend+0x211>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10fb7f: 39 c7 cmp %eax,%edi
10fb81: 74 06 je 10fb89 <_Heap_Extend+0x9e>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10fb83: 39 df cmp %ebx,%edi
10fb85: 72 07 jb 10fb8e <_Heap_Extend+0xa3>
10fb87: eb 08 jmp 10fb91 <_Heap_Extend+0xa6>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10fb89: 89 4d d0 mov %ecx,-0x30(%ebp)
10fb8c: eb 03 jmp 10fb91 <_Heap_Extend+0xa6>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10fb8e: 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);
10fb91: 8d 43 f8 lea -0x8(%ebx),%eax
10fb94: 89 45 d4 mov %eax,-0x2c(%ebp)
10fb97: 89 d8 mov %ebx,%eax
10fb99: 31 d2 xor %edx,%edx
10fb9b: 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);
10fb9e: 29 55 d4 sub %edx,-0x2c(%ebp)
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
10fba1: 3b 5d 0c cmp 0xc(%ebp),%ebx
10fba4: 75 07 jne 10fbad <_Heap_Extend+0xc2>
start_block->prev_size = extend_area_end;
10fba6: 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 )
10fba8: 8b 75 d4 mov -0x2c(%ebp),%esi
10fbab: eb 08 jmp 10fbb5 <_Heap_Extend+0xca>
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
10fbad: 73 06 jae 10fbb5 <_Heap_Extend+0xca>
10fbaf: 8b 55 d4 mov -0x2c(%ebp),%edx
10fbb2: 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;
10fbb5: 8b 45 d4 mov -0x2c(%ebp),%eax
10fbb8: 8b 48 04 mov 0x4(%eax),%ecx
10fbbb: 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);
10fbbe: 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 );
10fbc0: 3b 4d c0 cmp -0x40(%ebp),%ecx
10fbc3: 75 a9 jne 10fb6e <_Heap_Extend+0x83>
10fbc5: 8b 5d b8 mov -0x48(%ebp),%ebx
if ( extend_area_begin < heap->area_begin ) {
10fbc8: 8b 55 0c mov 0xc(%ebp),%edx
10fbcb: 3b 53 18 cmp 0x18(%ebx),%edx
10fbce: 73 05 jae 10fbd5 <_Heap_Extend+0xea>
heap->area_begin = extend_area_begin;
10fbd0: 89 53 18 mov %edx,0x18(%ebx)
10fbd3: eb 08 jmp 10fbdd <_Heap_Extend+0xf2>
} else if ( heap->area_end < extend_area_end ) {
10fbd5: 39 7b 1c cmp %edi,0x1c(%ebx)
10fbd8: 73 03 jae 10fbdd <_Heap_Extend+0xf2>
heap->area_end = extend_area_end;
10fbda: 89 7b 1c mov %edi,0x1c(%ebx)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
10fbdd: 8b 45 e0 mov -0x20(%ebp),%eax
10fbe0: 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 =
10fbe3: 89 c1 mov %eax,%ecx
10fbe5: 29 d1 sub %edx,%ecx
10fbe7: 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;
10fbea: 89 3a mov %edi,(%edx)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
10fbec: 83 c9 01 or $0x1,%ecx
10fbef: 89 4a 04 mov %ecx,0x4(%edx)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
10fbf2: 8b 4d d4 mov -0x2c(%ebp),%ecx
10fbf5: 89 08 mov %ecx,(%eax)
extend_last_block->size_and_flag = 0;
10fbf7: 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 ) {
10fbfe: 39 53 20 cmp %edx,0x20(%ebx)
10fc01: 76 05 jbe 10fc08 <_Heap_Extend+0x11d>
heap->first_block = extend_first_block;
10fc03: 89 53 20 mov %edx,0x20(%ebx)
10fc06: eb 08 jmp 10fc10 <_Heap_Extend+0x125>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
10fc08: 39 43 24 cmp %eax,0x24(%ebx)
10fc0b: 73 03 jae 10fc10 <_Heap_Extend+0x125>
heap->last_block = extend_last_block;
10fc0d: 89 43 24 mov %eax,0x24(%ebx)
}
if ( merge_below_block != NULL ) {
10fc10: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10fc14: 74 3b je 10fc51 <_Heap_Extend+0x166>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
10fc16: 8b 43 10 mov 0x10(%ebx),%eax
10fc19: 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 );
10fc1c: 8b 4d 0c mov 0xc(%ebp),%ecx
10fc1f: 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;
10fc22: 89 c8 mov %ecx,%eax
10fc24: 31 d2 xor %edx,%edx
10fc26: f7 75 d4 divl -0x2c(%ebp)
if ( remainder != 0 ) {
10fc29: 85 d2 test %edx,%edx
10fc2b: 74 05 je 10fc32 <_Heap_Extend+0x147>
return value - remainder + alignment;
10fc2d: 03 4d d4 add -0x2c(%ebp),%ecx
10fc30: 29 d1 sub %edx,%ecx
uintptr_t const new_first_block_begin =
10fc32: 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;
10fc35: 8b 45 d0 mov -0x30(%ebp),%eax
10fc38: 8b 00 mov (%eax),%eax
10fc3a: 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 =
10fc3d: 8b 45 d0 mov -0x30(%ebp),%eax
10fc40: 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;
10fc42: 83 c8 01 or $0x1,%eax
10fc45: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, new_first_block );
10fc48: 89 d8 mov %ebx,%eax
10fc4a: e8 81 fe ff ff call 10fad0 <_Heap_Free_block>
10fc4f: eb 14 jmp 10fc65 <_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 ) {
10fc51: 83 7d c8 00 cmpl $0x0,-0x38(%ebp)
10fc55: 74 0e je 10fc65 <_Heap_Extend+0x17a>
_Heap_Link_below(
10fc57: 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;
10fc5a: 8b 45 c8 mov -0x38(%ebp),%eax
10fc5d: 29 d0 sub %edx,%eax
10fc5f: 83 c8 01 or $0x1,%eax
10fc62: 89 42 04 mov %eax,0x4(%edx)
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
10fc65: 85 f6 test %esi,%esi
10fc67: 74 30 je 10fc99 <_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,
10fc69: 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(
10fc6c: 29 f7 sub %esi,%edi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10fc6e: 89 f8 mov %edi,%eax
10fc70: 31 d2 xor %edx,%edx
10fc72: f7 73 10 divl 0x10(%ebx)
10fc75: 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)
10fc77: 8b 46 04 mov 0x4(%esi),%eax
10fc7a: 29 f8 sub %edi,%eax
| HEAP_PREV_BLOCK_USED;
10fc7c: 83 c8 01 or $0x1,%eax
10fc7f: 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;
10fc83: 8b 46 04 mov 0x4(%esi),%eax
10fc86: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
10fc89: 09 f8 or %edi,%eax
10fc8b: 89 46 04 mov %eax,0x4(%esi)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
10fc8e: 89 f2 mov %esi,%edx
10fc90: 89 d8 mov %ebx,%eax
10fc92: e8 39 fe ff ff call 10fad0 <_Heap_Free_block>
10fc97: eb 21 jmp 10fcba <_Heap_Extend+0x1cf>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
10fc99: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
10fc9d: 74 1b je 10fcba <_Heap_Extend+0x1cf>
_Heap_Link_above(
10fc9f: 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 );
10fca2: 8b 45 e4 mov -0x1c(%ebp),%eax
10fca5: 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;
10fca8: 8b 7d cc mov -0x34(%ebp),%edi
10fcab: 8b 57 04 mov 0x4(%edi),%edx
10fcae: 83 e2 01 and $0x1,%edx
block->size_and_flag = size | flag;
10fcb1: 09 d0 or %edx,%eax
10fcb3: 89 47 04 mov %eax,0x4(%edi)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
10fcb6: 83 49 04 01 orl $0x1,0x4(%ecx)
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
10fcba: 85 f6 test %esi,%esi
10fcbc: 75 10 jne 10fcce <_Heap_Extend+0x1e3>
10fcbe: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10fcc2: 75 0a jne 10fcce <_Heap_Extend+0x1e3>
_Heap_Free_block( heap, extend_first_block );
10fcc4: 8b 55 e4 mov -0x1c(%ebp),%edx
10fcc7: 89 d8 mov %ebx,%eax
10fcc9: e8 02 fe ff ff call 10fad0 <_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
10fcce: 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(
10fcd1: 8b 43 20 mov 0x20(%ebx),%eax
10fcd4: 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;
10fcd6: 8b 4a 04 mov 0x4(%edx),%ecx
10fcd9: 83 e1 01 and $0x1,%ecx
block->size_and_flag = size | flag;
10fcdc: 09 c8 or %ecx,%eax
10fcde: 89 42 04 mov %eax,0x4(%edx)
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
10fce1: 8b 43 30 mov 0x30(%ebx),%eax
10fce4: 2b 45 bc sub -0x44(%ebp),%eax
/* Statistics */
stats->size += extended_size;
10fce7: 01 43 2c add %eax,0x2c(%ebx)
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
10fcea: 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 )
10fcef: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10fcf3: 74 09 je 10fcfe <_Heap_Extend+0x213> <== NEVER TAKEN
*extended_size_ptr = extended_size;
10fcf5: 8b 55 14 mov 0x14(%ebp),%edx
10fcf8: 89 02 mov %eax,(%edx)
10fcfa: eb 02 jmp 10fcfe <_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;
10fcfc: 31 f6 xor %esi,%esi
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
10fcfe: 89 f0 mov %esi,%eax
10fd00: 8d 65 f4 lea -0xc(%ebp),%esp
10fd03: 5b pop %ebx
10fd04: 5e pop %esi
10fd05: 5f pop %edi
10fd06: c9 leave
10fd07: c3 ret
0010f730 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
10f730: 55 push %ebp
10f731: 89 e5 mov %esp,%ebp
10f733: 57 push %edi
10f734: 56 push %esi
10f735: 53 push %ebx
10f736: 83 ec 14 sub $0x14,%esp
10f739: 8b 4d 08 mov 0x8(%ebp),%ecx
10f73c: 8b 55 0c mov 0xc(%ebp),%edx
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
return true;
10f73f: b0 01 mov $0x1,%al
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
10f741: 85 d2 test %edx,%edx
10f743: 0f 84 4b 01 00 00 je 10f894 <_Heap_Free+0x164>
10f749: 8d 5a f8 lea -0x8(%edx),%ebx
10f74c: 89 d0 mov %edx,%eax
10f74e: 31 d2 xor %edx,%edx
10f750: 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);
10f753: 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
10f755: 8b 41 20 mov 0x20(%ecx),%eax
10f758: 89 45 ec mov %eax,-0x14(%ebp)
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10f75b: 31 d2 xor %edx,%edx
10f75d: 39 c3 cmp %eax,%ebx
10f75f: 72 08 jb 10f769 <_Heap_Free+0x39>
10f761: 31 d2 xor %edx,%edx
10f763: 39 59 24 cmp %ebx,0x24(%ecx)
10f766: 0f 93 c2 setae %dl
alloc_begin = (uintptr_t) alloc_begin_ptr;
block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
return false;
10f769: 31 c0 xor %eax,%eax
}
alloc_begin = (uintptr_t) alloc_begin_ptr;
block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
10f76b: 85 d2 test %edx,%edx
10f76d: 0f 84 21 01 00 00 je 10f894 <_Heap_Free+0x164>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f773: 8b 43 04 mov 0x4(%ebx),%eax
10f776: 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;
10f779: 89 c6 mov %eax,%esi
10f77b: 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);
10f77e: 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;
10f781: 31 ff xor %edi,%edi
10f783: 3b 55 ec cmp -0x14(%ebp),%edx
10f786: 72 0a jb 10f792 <_Heap_Free+0x62> <== NEVER TAKEN
10f788: 31 c0 xor %eax,%eax
10f78a: 39 51 24 cmp %edx,0x24(%ecx)
10f78d: 0f 93 c0 setae %al
10f790: 89 c7 mov %eax,%edi
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
return false;
10f792: 31 c0 xor %eax,%eax
_Heap_Protection_block_check( heap, block );
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
10f794: 85 ff test %edi,%edi
10f796: 0f 84 f8 00 00 00 je 10f894 <_Heap_Free+0x164> <== NEVER TAKEN
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f79c: 8b 7a 04 mov 0x4(%edx),%edi
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
10f79f: f7 c7 01 00 00 00 test $0x1,%edi
10f7a5: 0f 84 e9 00 00 00 je 10f894 <_Heap_Free+0x164> <== 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;
10f7ab: 83 e7 fe and $0xfffffffe,%edi
10f7ae: 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
10f7b1: 8b 41 24 mov 0x24(%ecx),%eax
10f7b4: 89 45 e4 mov %eax,-0x1c(%ebp)
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
10f7b7: 31 c0 xor %eax,%eax
10f7b9: 3b 55 e4 cmp -0x1c(%ebp),%edx
10f7bc: 74 0a je 10f7c8 <_Heap_Free+0x98>
10f7be: 31 c0 xor %eax,%eax
10f7c0: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1)
10f7c5: 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
10f7c8: 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 ) ) {
10f7cb: f6 45 f0 01 testb $0x1,-0x10(%ebp)
10f7cf: 75 62 jne 10f833 <_Heap_Free+0x103>
uintptr_t const prev_size = block->prev_size;
10f7d1: 8b 03 mov (%ebx),%eax
10f7d3: 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);
10f7d6: 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;
10f7d8: 31 ff xor %edi,%edi
10f7da: 3b 5d ec cmp -0x14(%ebp),%ebx
10f7dd: 72 0a jb 10f7e9 <_Heap_Free+0xb9> <== NEVER TAKEN
10f7df: 31 c0 xor %eax,%eax
10f7e1: 39 5d e4 cmp %ebx,-0x1c(%ebp)
10f7e4: 0f 93 c0 setae %al
10f7e7: 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 );
10f7e9: 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 ) ) {
10f7eb: 85 ff test %edi,%edi
10f7ed: 0f 84 a1 00 00 00 je 10f894 <_Heap_Free+0x164> <== 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) ) {
10f7f3: f6 43 04 01 testb $0x1,0x4(%ebx)
10f7f7: 0f 84 97 00 00 00 je 10f894 <_Heap_Free+0x164> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
10f7fd: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f801: 74 1a je 10f81d <_Heap_Free+0xed>
uintptr_t const size = block_size + prev_size + next_block_size;
10f803: 8b 45 e8 mov -0x18(%ebp),%eax
10f806: 8d 04 06 lea (%esi,%eax,1),%eax
10f809: 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;
10f80c: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = block->prev;
10f80f: 8b 52 0c mov 0xc(%edx),%edx
prev->next = next;
10f812: 89 7a 08 mov %edi,0x8(%edx)
next->prev = prev;
10f815: 89 57 0c mov %edx,0xc(%edi)
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
10f818: ff 49 38 decl 0x38(%ecx)
10f81b: eb 33 jmp 10f850 <_Heap_Free+0x120>
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;
10f81d: 8b 45 f0 mov -0x10(%ebp),%eax
10f820: 8d 04 06 lea (%esi,%eax,1),%eax
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f823: 89 c7 mov %eax,%edi
10f825: 83 cf 01 or $0x1,%edi
10f828: 89 7b 04 mov %edi,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f82b: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = size;
10f82f: 89 02 mov %eax,(%edx)
10f831: eb 56 jmp 10f889 <_Heap_Free+0x159>
}
} else if ( next_is_free ) { /* coalesce next */
10f833: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f837: 74 24 je 10f85d <_Heap_Free+0x12d>
uintptr_t const size = block_size + next_block_size;
10f839: 8b 45 e8 mov -0x18(%ebp),%eax
10f83c: 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;
10f83e: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = old_block->prev;
10f841: 8b 52 0c mov 0xc(%edx),%edx
new_block->next = next;
10f844: 89 7b 08 mov %edi,0x8(%ebx)
new_block->prev = prev;
10f847: 89 53 0c mov %edx,0xc(%ebx)
next->prev = new_block;
10f84a: 89 5f 0c mov %ebx,0xc(%edi)
prev->next = new_block;
10f84d: 89 5a 08 mov %ebx,0x8(%edx)
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f850: 89 c2 mov %eax,%edx
10f852: 83 ca 01 or $0x1,%edx
10f855: 89 53 04 mov %edx,0x4(%ebx)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
10f858: 89 04 03 mov %eax,(%ebx,%eax,1)
10f85b: eb 2c jmp 10f889 <_Heap_Free+0x159>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
10f85d: 8b 41 08 mov 0x8(%ecx),%eax
new_block->next = next;
10f860: 89 43 08 mov %eax,0x8(%ebx)
new_block->prev = block_before;
10f863: 89 4b 0c mov %ecx,0xc(%ebx)
block_before->next = new_block;
10f866: 89 59 08 mov %ebx,0x8(%ecx)
next->prev = new_block;
10f869: 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;
10f86c: 89 f0 mov %esi,%eax
10f86e: 83 c8 01 or $0x1,%eax
10f871: 89 43 04 mov %eax,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f874: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = block_size;
10f878: 89 32 mov %esi,(%edx)
/* Statistics */
++stats->free_blocks;
10f87a: 8b 41 38 mov 0x38(%ecx),%eax
10f87d: 40 inc %eax
10f87e: 89 41 38 mov %eax,0x38(%ecx)
if ( stats->max_free_blocks < stats->free_blocks ) {
10f881: 39 41 3c cmp %eax,0x3c(%ecx)
10f884: 73 03 jae 10f889 <_Heap_Free+0x159>
stats->max_free_blocks = stats->free_blocks;
10f886: 89 41 3c mov %eax,0x3c(%ecx)
}
}
/* Statistics */
--stats->used_blocks;
10f889: ff 49 40 decl 0x40(%ecx)
++stats->frees;
10f88c: ff 41 50 incl 0x50(%ecx)
stats->free_size += block_size;
10f88f: 01 71 30 add %esi,0x30(%ecx)
return( true );
10f892: b0 01 mov $0x1,%al
}
10f894: 83 c4 14 add $0x14,%esp
10f897: 5b pop %ebx
10f898: 5e pop %esi
10f899: 5f pop %edi
10f89a: c9 leave
10f89b: c3 ret
0011d4e0 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
11d4e0: 55 push %ebp
11d4e1: 89 e5 mov %esp,%ebp
11d4e3: 57 push %edi
11d4e4: 56 push %esi
11d4e5: 53 push %ebx
11d4e6: 8b 5d 08 mov 0x8(%ebp),%ebx
11d4e9: 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);
11d4ec: 8d 4e f8 lea -0x8(%esi),%ecx
11d4ef: 89 f0 mov %esi,%eax
11d4f1: 31 d2 xor %edx,%edx
11d4f3: 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);
11d4f6: 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
11d4f8: 8b 53 20 mov 0x20(%ebx),%edx
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11d4fb: 31 ff xor %edi,%edi
11d4fd: 39 d1 cmp %edx,%ecx
11d4ff: 72 0a jb 11d50b <_Heap_Size_of_alloc_area+0x2b>
11d501: 31 c0 xor %eax,%eax
11d503: 39 4b 24 cmp %ecx,0x24(%ebx)
11d506: 0f 93 c0 setae %al
11d509: 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;
11d50b: 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 ) ) {
11d50d: 85 ff test %edi,%edi
11d50f: 74 30 je 11d541 <_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;
11d511: 8b 41 04 mov 0x4(%ecx),%eax
11d514: 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);
11d517: 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;
11d519: 31 ff xor %edi,%edi
11d51b: 39 d1 cmp %edx,%ecx
11d51d: 72 0a jb 11d529 <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN
11d51f: 31 c0 xor %eax,%eax
11d521: 39 4b 24 cmp %ecx,0x24(%ebx)
11d524: 0f 93 c0 setae %al
11d527: 89 c7 mov %eax,%edi
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
11d529: 31 c0 xor %eax,%eax
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
11d52b: 85 ff test %edi,%edi
11d52d: 74 12 je 11d541 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
11d52f: f6 41 04 01 testb $0x1,0x4(%ecx)
11d533: 74 0c je 11d541 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
11d535: 29 f1 sub %esi,%ecx
11d537: 8d 51 04 lea 0x4(%ecx),%edx
11d53a: 8b 45 10 mov 0x10(%ebp),%eax
11d53d: 89 10 mov %edx,(%eax)
return true;
11d53f: b0 01 mov $0x1,%al
}
11d541: 5b pop %ebx
11d542: 5e pop %esi
11d543: 5f pop %edi
11d544: c9 leave
11d545: c3 ret
0010bc76 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
10bc76: 55 push %ebp
10bc77: 89 e5 mov %esp,%ebp
10bc79: 57 push %edi
10bc7a: 56 push %esi
10bc7b: 53 push %ebx
10bc7c: 83 ec 4c sub $0x4c,%esp
10bc7f: 8b 75 08 mov 0x8(%ebp),%esi
10bc82: 8b 5d 0c mov 0xc(%ebp),%ebx
uintptr_t const page_size = heap->page_size;
10bc85: 8b 46 10 mov 0x10(%esi),%eax
10bc88: 89 45 d8 mov %eax,-0x28(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10bc8b: 8b 4e 14 mov 0x14(%esi),%ecx
10bc8e: 89 4d d4 mov %ecx,-0x2c(%ebp)
Heap_Block *const first_block = heap->first_block;
10bc91: 8b 46 20 mov 0x20(%esi),%eax
10bc94: 89 45 d0 mov %eax,-0x30(%ebp)
Heap_Block *const last_block = heap->last_block;
10bc97: 8b 4e 24 mov 0x24(%esi),%ecx
10bc9a: 89 4d c8 mov %ecx,-0x38(%ebp)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10bc9d: c7 45 e4 38 bc 10 00 movl $0x10bc38,-0x1c(%ebp)
10bca4: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
10bca8: 74 07 je 10bcb1 <_Heap_Walk+0x3b>
10bcaa: c7 45 e4 3d bc 10 00 movl $0x10bc3d,-0x1c(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
10bcb1: 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() ) ) {
10bcb3: 83 3d 24 75 12 00 03 cmpl $0x3,0x127524
10bcba: 0f 85 e8 02 00 00 jne 10bfa8 <_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)(
10bcc0: 52 push %edx
10bcc1: ff 76 0c pushl 0xc(%esi)
10bcc4: ff 76 08 pushl 0x8(%esi)
10bcc7: ff 75 c8 pushl -0x38(%ebp)
10bcca: ff 75 d0 pushl -0x30(%ebp)
10bccd: ff 76 1c pushl 0x1c(%esi)
10bcd0: ff 76 18 pushl 0x18(%esi)
10bcd3: ff 75 d4 pushl -0x2c(%ebp)
10bcd6: ff 75 d8 pushl -0x28(%ebp)
10bcd9: 68 85 00 12 00 push $0x120085
10bcde: 6a 00 push $0x0
10bce0: 53 push %ebx
10bce1: 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 ) {
10bce4: 83 c4 30 add $0x30,%esp
10bce7: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10bceb: 75 0b jne 10bcf8 <_Heap_Walk+0x82>
(*printer)( source, true, "page size is zero\n" );
10bced: 50 push %eax
10bcee: 68 16 01 12 00 push $0x120116
10bcf3: e9 6b 02 00 00 jmp 10bf63 <_Heap_Walk+0x2ed>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
10bcf8: f6 45 d8 03 testb $0x3,-0x28(%ebp)
10bcfc: 74 0d je 10bd0b <_Heap_Walk+0x95>
(*printer)(
10bcfe: ff 75 d8 pushl -0x28(%ebp)
10bd01: 68 29 01 12 00 push $0x120129
10bd06: e9 58 02 00 00 jmp 10bf63 <_Heap_Walk+0x2ed>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bd0b: 8b 45 d4 mov -0x2c(%ebp),%eax
10bd0e: 31 d2 xor %edx,%edx
10bd10: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
10bd13: 85 d2 test %edx,%edx
10bd15: 74 0d je 10bd24 <_Heap_Walk+0xae>
(*printer)(
10bd17: ff 75 d4 pushl -0x2c(%ebp)
10bd1a: 68 47 01 12 00 push $0x120147
10bd1f: e9 3f 02 00 00 jmp 10bf63 <_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;
10bd24: 8b 45 d0 mov -0x30(%ebp),%eax
10bd27: 83 c0 08 add $0x8,%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bd2a: 31 d2 xor %edx,%edx
10bd2c: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if (
10bd2f: 85 d2 test %edx,%edx
10bd31: 74 0d je 10bd40 <_Heap_Walk+0xca>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
10bd33: ff 75 d0 pushl -0x30(%ebp)
10bd36: 68 6b 01 12 00 push $0x12016b
10bd3b: e9 23 02 00 00 jmp 10bf63 <_Heap_Walk+0x2ed>
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
10bd40: 8b 45 d0 mov -0x30(%ebp),%eax
10bd43: f6 40 04 01 testb $0x1,0x4(%eax)
10bd47: 75 0b jne 10bd54 <_Heap_Walk+0xde>
(*printer)(
10bd49: 57 push %edi
10bd4a: 68 9c 01 12 00 push $0x12019c
10bd4f: e9 0f 02 00 00 jmp 10bf63 <_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;
10bd54: 8b 4d c8 mov -0x38(%ebp),%ecx
10bd57: 8b 79 04 mov 0x4(%ecx),%edi
10bd5a: 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);
10bd5d: 01 cf add %ecx,%edi
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
10bd5f: f6 47 04 01 testb $0x1,0x4(%edi)
10bd63: 75 0b jne 10bd70 <_Heap_Walk+0xfa>
(*printer)(
10bd65: 56 push %esi
10bd66: 68 ca 01 12 00 push $0x1201ca
10bd6b: e9 f3 01 00 00 jmp 10bf63 <_Heap_Walk+0x2ed>
);
return false;
}
if (
10bd70: 3b 7d d0 cmp -0x30(%ebp),%edi
10bd73: 74 0b je 10bd80 <_Heap_Walk+0x10a> <== ALWAYS TAKEN
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
10bd75: 51 push %ecx <== NOT EXECUTED
10bd76: 68 df 01 12 00 push $0x1201df <== NOT EXECUTED
10bd7b: e9 e3 01 00 00 jmp 10bf63 <_Heap_Walk+0x2ed> <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
10bd80: 8b 46 10 mov 0x10(%esi),%eax
10bd83: 89 45 e0 mov %eax,-0x20(%ebp)
block = next_block;
} while ( block != first_block );
return true;
}
10bd86: 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 );
10bd89: 89 75 dc mov %esi,-0x24(%ebp)
10bd8c: eb 75 jmp 10be03 <_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;
10bd8e: 31 c0 xor %eax,%eax
10bd90: 39 4e 20 cmp %ecx,0x20(%esi)
10bd93: 77 08 ja 10bd9d <_Heap_Walk+0x127>
10bd95: 31 c0 xor %eax,%eax
10bd97: 39 4e 24 cmp %ecx,0x24(%esi)
10bd9a: 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 ) ) {
10bd9d: 85 c0 test %eax,%eax
10bd9f: 75 0b jne 10bdac <_Heap_Walk+0x136>
(*printer)(
10bda1: 51 push %ecx
10bda2: 68 0e 02 12 00 push $0x12020e
10bda7: e9 b7 01 00 00 jmp 10bf63 <_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;
10bdac: 8d 41 08 lea 0x8(%ecx),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bdaf: 31 d2 xor %edx,%edx
10bdb1: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if (
10bdb4: 85 d2 test %edx,%edx
10bdb6: 74 0b je 10bdc3 <_Heap_Walk+0x14d>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
10bdb8: 51 push %ecx
10bdb9: 68 2e 02 12 00 push $0x12022e
10bdbe: e9 a0 01 00 00 jmp 10bf63 <_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;
10bdc3: 8b 41 04 mov 0x4(%ecx),%eax
10bdc6: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10bdc9: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1)
10bdce: 74 0b je 10bddb <_Heap_Walk+0x165>
(*printer)(
10bdd0: 51 push %ecx
10bdd1: 68 5e 02 12 00 push $0x12025e
10bdd6: e9 88 01 00 00 jmp 10bf63 <_Heap_Walk+0x2ed>
);
return false;
}
if ( free_block->prev != prev_block ) {
10bddb: 8b 41 0c mov 0xc(%ecx),%eax
10bdde: 3b 45 dc cmp -0x24(%ebp),%eax
10bde1: 74 1a je 10bdfd <_Heap_Walk+0x187>
(*printer)(
10bde3: 83 ec 0c sub $0xc,%esp
10bde6: 50 push %eax
10bde7: 51 push %ecx
10bde8: 68 7a 02 12 00 push $0x12027a
10bded: 6a 01 push $0x1
10bdef: 53 push %ebx
10bdf0: ff 55 e4 call *-0x1c(%ebp)
10bdf3: 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;
10bdf6: 31 c0 xor %eax,%eax
10bdf8: e9 ab 01 00 00 jmp 10bfa8 <_Heap_Walk+0x332>
return false;
}
prev_block = free_block;
free_block = free_block->next;
10bdfd: 89 4d dc mov %ecx,-0x24(%ebp)
10be00: 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 ) {
10be03: 39 f1 cmp %esi,%ecx
10be05: 75 87 jne 10bd8e <_Heap_Walk+0x118>
10be07: 89 5d dc mov %ebx,-0x24(%ebp)
10be0a: eb 02 jmp 10be0e <_Heap_Walk+0x198>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10be0c: 89 df mov %ebx,%edi
return true;
}
10be0e: 8b 4f 04 mov 0x4(%edi),%ecx
10be11: 89 4d cc mov %ecx,-0x34(%ebp)
10be14: 83 e1 fe and $0xfffffffe,%ecx
10be17: 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);
10be1a: 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;
10be1d: 31 c0 xor %eax,%eax
10be1f: 39 5e 20 cmp %ebx,0x20(%esi)
10be22: 77 08 ja 10be2c <_Heap_Walk+0x1b6> <== NEVER TAKEN
10be24: 31 c0 xor %eax,%eax
10be26: 39 5e 24 cmp %ebx,0x24(%esi)
10be29: 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 ) ) {
10be2c: 85 c0 test %eax,%eax
10be2e: 75 11 jne 10be41 <_Heap_Walk+0x1cb>
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 ac 02 12 00 push $0x1202ac
10be3f: eb ac jmp 10bded <_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;
10be41: 3b 7d c8 cmp -0x38(%ebp),%edi
10be44: 0f 95 c1 setne %cl
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10be47: 8b 45 e0 mov -0x20(%ebp),%eax
10be4a: 31 d2 xor %edx,%edx
10be4c: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
10be4f: 85 d2 test %edx,%edx
10be51: 74 15 je 10be68 <_Heap_Walk+0x1f2>
10be53: 84 c9 test %cl,%cl
10be55: 74 11 je 10be68 <_Heap_Walk+0x1f2>
10be57: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be5a: 83 ec 0c sub $0xc,%esp
10be5d: ff 75 e0 pushl -0x20(%ebp)
10be60: 57 push %edi
10be61: 68 d9 02 12 00 push $0x1202d9
10be66: eb 85 jmp 10bded <_Heap_Walk+0x177>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
10be68: 8b 45 d4 mov -0x2c(%ebp),%eax
10be6b: 39 45 e0 cmp %eax,-0x20(%ebp)
10be6e: 73 18 jae 10be88 <_Heap_Walk+0x212>
10be70: 84 c9 test %cl,%cl
10be72: 74 14 je 10be88 <_Heap_Walk+0x212> <== NEVER TAKEN
10be74: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be77: 52 push %edx
10be78: 52 push %edx
10be79: 50 push %eax
10be7a: ff 75 e0 pushl -0x20(%ebp)
10be7d: 57 push %edi
10be7e: 68 07 03 12 00 push $0x120307
10be83: e9 65 ff ff ff jmp 10bded <_Heap_Walk+0x177>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
10be88: 39 fb cmp %edi,%ebx
10be8a: 77 18 ja 10bea4 <_Heap_Walk+0x22e>
10be8c: 84 c9 test %cl,%cl
10be8e: 74 14 je 10bea4 <_Heap_Walk+0x22e>
10be90: 89 d9 mov %ebx,%ecx
10be92: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be95: 83 ec 0c sub $0xc,%esp
10be98: 51 push %ecx
10be99: 57 push %edi
10be9a: 68 32 03 12 00 push $0x120332
10be9f: e9 49 ff ff ff jmp 10bded <_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;
10bea4: 8b 4d cc mov -0x34(%ebp),%ecx
10bea7: 83 e1 01 and $0x1,%ecx
10beaa: 89 4d c4 mov %ecx,-0x3c(%ebp)
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10bead: f6 43 04 01 testb $0x1,0x4(%ebx)
10beb1: 0f 85 ba 00 00 00 jne 10bf71 <_Heap_Walk+0x2fb>
block = next_block;
} while ( block != first_block );
return true;
}
10beb7: 8b 46 08 mov 0x8(%esi),%eax
10beba: 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 ?
10bebd: 8b 4f 08 mov 0x8(%edi),%ecx
10bec0: 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)(
10bec3: ba 52 00 12 00 mov $0x120052,%edx
10bec8: 3b 4e 0c cmp 0xc(%esi),%ecx
10becb: 74 0e je 10bedb <_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)" : "")
10becd: ba 99 ff 11 00 mov $0x11ff99,%edx
10bed2: 39 f1 cmp %esi,%ecx
10bed4: 75 05 jne 10bedb <_Heap_Walk+0x265>
10bed6: ba 61 00 12 00 mov $0x120061,%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 ?
10bedb: 8b 47 0c mov 0xc(%edi),%eax
10bede: 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)(
10bee1: b8 6b 00 12 00 mov $0x12006b,%eax
10bee6: 8b 4d c0 mov -0x40(%ebp),%ecx
10bee9: 39 4d cc cmp %ecx,-0x34(%ebp)
10beec: 74 0f je 10befd <_Heap_Walk+0x287>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10beee: b8 99 ff 11 00 mov $0x11ff99,%eax
10bef3: 39 75 cc cmp %esi,-0x34(%ebp)
10bef6: 75 05 jne 10befd <_Heap_Walk+0x287>
10bef8: b8 7b 00 12 00 mov $0x12007b,%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)(
10befd: 83 ec 0c sub $0xc,%esp
10bf00: 52 push %edx
10bf01: ff 75 b4 pushl -0x4c(%ebp)
10bf04: 50 push %eax
10bf05: ff 75 cc pushl -0x34(%ebp)
10bf08: ff 75 e0 pushl -0x20(%ebp)
10bf0b: 57 push %edi
10bf0c: 68 66 03 12 00 push $0x120366
10bf11: 6a 00 push $0x0
10bf13: ff 75 dc pushl -0x24(%ebp)
10bf16: 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 ) {
10bf19: 8b 03 mov (%ebx),%eax
10bf1b: 83 c4 30 add $0x30,%esp
10bf1e: 39 45 e0 cmp %eax,-0x20(%ebp)
10bf21: 74 16 je 10bf39 <_Heap_Walk+0x2c3>
10bf23: 89 d9 mov %ebx,%ecx
10bf25: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bf28: 56 push %esi
10bf29: 51 push %ecx
10bf2a: 50 push %eax
10bf2b: ff 75 e0 pushl -0x20(%ebp)
10bf2e: 57 push %edi
10bf2f: 68 9b 03 12 00 push $0x12039b
10bf34: e9 b4 fe ff ff jmp 10bded <_Heap_Walk+0x177>
);
return false;
}
if ( !prev_used ) {
10bf39: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bf3d: 75 0b jne 10bf4a <_Heap_Walk+0x2d4>
10bf3f: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bf42: 57 push %edi
10bf43: 68 d4 03 12 00 push $0x1203d4
10bf48: eb 19 jmp 10bf63 <_Heap_Walk+0x2ed>
block = next_block;
} while ( block != first_block );
return true;
}
10bf4a: 8b 46 08 mov 0x8(%esi),%eax
10bf4d: eb 07 jmp 10bf56 <_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 ) {
10bf4f: 39 f8 cmp %edi,%eax
10bf51: 74 4a je 10bf9d <_Heap_Walk+0x327>
return true;
}
free_block = free_block->next;
10bf53: 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 ) {
10bf56: 39 f0 cmp %esi,%eax
10bf58: 75 f5 jne 10bf4f <_Heap_Walk+0x2d9>
10bf5a: 8b 5d dc mov -0x24(%ebp),%ebx
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10bf5d: 57 push %edi
10bf5e: 68 3f 04 12 00 push $0x12043f
10bf63: 6a 01 push $0x1
10bf65: 53 push %ebx
10bf66: ff 55 e4 call *-0x1c(%ebp)
10bf69: 83 c4 10 add $0x10,%esp
10bf6c: e9 85 fe ff ff jmp 10bdf6 <_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) {
10bf71: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bf75: 74 0e je 10bf85 <_Heap_Walk+0x30f>
(*printer)(
10bf77: 83 ec 0c sub $0xc,%esp
10bf7a: ff 75 e0 pushl -0x20(%ebp)
10bf7d: 57 push %edi
10bf7e: 68 03 04 12 00 push $0x120403
10bf83: eb 0d jmp 10bf92 <_Heap_Walk+0x31c>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
10bf85: 51 push %ecx
10bf86: 51 push %ecx
10bf87: ff 37 pushl (%edi)
10bf89: ff 75 e0 pushl -0x20(%ebp)
10bf8c: 57 push %edi
10bf8d: 68 1a 04 12 00 push $0x12041a
10bf92: 6a 00 push $0x0
10bf94: ff 75 dc pushl -0x24(%ebp)
10bf97: ff 55 e4 call *-0x1c(%ebp)
10bf9a: 83 c4 20 add $0x20,%esp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10bf9d: 3b 5d d0 cmp -0x30(%ebp),%ebx
10bfa0: 0f 85 66 fe ff ff jne 10be0c <_Heap_Walk+0x196>
return true;
10bfa6: b0 01 mov $0x1,%al
}
10bfa8: 8d 65 f4 lea -0xc(%ebp),%esp
10bfab: 5b pop %ebx
10bfac: 5e pop %esi
10bfad: 5f pop %edi
10bfae: c9 leave
10bfaf: c3 ret
0010b28c <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10b28c: 55 push %ebp
10b28d: 89 e5 mov %esp,%ebp
10b28f: 53 push %ebx
10b290: 83 ec 08 sub $0x8,%esp
10b293: 8b 45 08 mov 0x8(%ebp),%eax
10b296: 8b 55 0c mov 0xc(%ebp),%edx
10b299: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10b29c: a3 d8 53 12 00 mov %eax,0x1253d8
_Internal_errors_What_happened.is_internal = is_internal;
10b2a1: 88 15 dc 53 12 00 mov %dl,0x1253dc
_Internal_errors_What_happened.the_error = the_error;
10b2a7: 89 1d e0 53 12 00 mov %ebx,0x1253e0
_User_extensions_Fatal( the_source, is_internal, the_error );
10b2ad: 53 push %ebx
10b2ae: 0f b6 d2 movzbl %dl,%edx
10b2b1: 52 push %edx
10b2b2: 50 push %eax
10b2b3: e8 37 1a 00 00 call 10ccef <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
10b2b8: c7 05 9c 54 12 00 05 movl $0x5,0x12549c <== NOT EXECUTED
10b2bf: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10b2c2: fa cli <== NOT EXECUTED
10b2c3: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10b2c5: f4 hlt <== NOT EXECUTED
10b2c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b2c9: eb fe jmp 10b2c9 <_Internal_error_Occurred+0x3d><== NOT EXECUTED
0010b31c <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10b31c: 55 push %ebp
10b31d: 89 e5 mov %esp,%ebp
10b31f: 56 push %esi
10b320: 53 push %ebx
10b321: 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;
10b324: 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 )
10b326: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
10b32a: 74 53 je 10b37f <_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 );
10b32c: 8d 73 20 lea 0x20(%ebx),%esi
10b32f: 83 ec 0c sub $0xc,%esp
10b332: 56 push %esi
10b333: e8 38 f7 ff ff call 10aa70 <_Chain_Get>
10b338: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10b33a: 83 c4 10 add $0x10,%esp
10b33d: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10b341: 74 3c je 10b37f <_Objects_Allocate+0x63>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10b343: 85 c0 test %eax,%eax
10b345: 75 1a jne 10b361 <_Objects_Allocate+0x45>
_Objects_Extend_information( information );
10b347: 83 ec 0c sub $0xc,%esp
10b34a: 53 push %ebx
10b34b: e8 60 00 00 00 call 10b3b0 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10b350: 89 34 24 mov %esi,(%esp)
10b353: e8 18 f7 ff ff call 10aa70 <_Chain_Get>
10b358: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10b35a: 83 c4 10 add $0x10,%esp
10b35d: 85 c0 test %eax,%eax
10b35f: 74 1e je 10b37f <_Objects_Allocate+0x63>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
10b361: 0f b7 41 08 movzwl 0x8(%ecx),%eax
10b365: 0f b7 53 08 movzwl 0x8(%ebx),%edx
10b369: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
10b36b: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10b36f: 31 d2 xor %edx,%edx
10b371: f7 f6 div %esi
information->inactive_per_block[ block ]--;
10b373: c1 e0 02 shl $0x2,%eax
10b376: 03 43 30 add 0x30(%ebx),%eax
10b379: ff 08 decl (%eax)
information->inactive--;
10b37b: 66 ff 4b 2c decw 0x2c(%ebx)
);
}
#endif
return the_object;
}
10b37f: 89 c8 mov %ecx,%eax
10b381: 8d 65 f8 lea -0x8(%ebp),%esp
10b384: 5b pop %ebx
10b385: 5e pop %esi
10b386: c9 leave
10b387: c3 ret
0010b6a0 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
10b6a0: 55 push %ebp
10b6a1: 89 e5 mov %esp,%ebp
10b6a3: 57 push %edi
10b6a4: 56 push %esi
10b6a5: 53 push %ebx
10b6a6: 83 ec 0c sub $0xc,%esp
10b6a9: 8b 75 08 mov 0x8(%ebp),%esi
10b6ac: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
10b6af: 31 db xor %ebx,%ebx
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10b6b1: 66 85 ff test %di,%di
10b6b4: 74 37 je 10b6ed <_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 );
10b6b6: 83 ec 0c sub $0xc,%esp
10b6b9: 56 push %esi
10b6ba: e8 dd 41 00 00 call 10f89c <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10b6bf: 83 c4 10 add $0x10,%esp
10b6c2: 85 c0 test %eax,%eax
10b6c4: 74 27 je 10b6ed <_Objects_Get_information+0x4d>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10b6c6: 0f b7 ff movzwl %di,%edi
10b6c9: 39 c7 cmp %eax,%edi
10b6cb: 77 20 ja 10b6ed <_Objects_Get_information+0x4d>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10b6cd: 8b 04 b5 18 53 12 00 mov 0x125318(,%esi,4),%eax
10b6d4: 85 c0 test %eax,%eax
10b6d6: 74 15 je 10b6ed <_Objects_Get_information+0x4d><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10b6d8: 8b 1c b8 mov (%eax,%edi,4),%ebx
if ( !info )
10b6db: 85 db test %ebx,%ebx
10b6dd: 74 0e je 10b6ed <_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;
10b6df: 31 c0 xor %eax,%eax
10b6e1: 66 83 7b 10 00 cmpw $0x0,0x10(%ebx)
10b6e6: 0f 95 c0 setne %al
10b6e9: f7 d8 neg %eax
10b6eb: 21 c3 and %eax,%ebx
#endif
return info;
}
10b6ed: 89 d8 mov %ebx,%eax
10b6ef: 8d 65 f4 lea -0xc(%ebp),%esp
10b6f2: 5b pop %ebx
10b6f3: 5e pop %esi
10b6f4: 5f pop %edi
10b6f5: c9 leave
10b6f6: c3 ret
00118b10 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
118b10: 55 push %ebp
118b11: 89 e5 mov %esp,%ebp
118b13: 53 push %ebx
118b14: 8b 55 08 mov 0x8(%ebp),%edx
118b17: 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;
118b1a: b8 01 00 00 00 mov $0x1,%eax
118b1f: 2b 42 08 sub 0x8(%edx),%eax
118b22: 03 45 0c add 0xc(%ebp),%eax
if ( information->maximum >= index ) {
118b25: 0f b7 5a 10 movzwl 0x10(%edx),%ebx
118b29: 39 c3 cmp %eax,%ebx
118b2b: 72 12 jb 118b3f <_Objects_Get_no_protection+0x2f>
if ( (the_object = information->local_table[ index ]) != NULL ) {
118b2d: 8b 52 1c mov 0x1c(%edx),%edx
118b30: 8b 04 82 mov (%edx,%eax,4),%eax
118b33: 85 c0 test %eax,%eax
118b35: 74 08 je 118b3f <_Objects_Get_no_protection+0x2f><== NEVER TAKEN
*location = OBJECTS_LOCAL;
118b37: c7 01 00 00 00 00 movl $0x0,(%ecx)
return the_object;
118b3d: eb 08 jmp 118b47 <_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;
118b3f: c7 01 01 00 00 00 movl $0x1,(%ecx)
return NULL;
118b45: 31 c0 xor %eax,%eax
}
118b47: 5b pop %ebx
118b48: c9 leave
118b49: c3 ret
0010c8bc <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10c8bc: 55 push %ebp
10c8bd: 89 e5 mov %esp,%ebp
10c8bf: 53 push %ebx
10c8c0: 83 ec 14 sub $0x14,%esp
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10c8c3: 8b 45 08 mov 0x8(%ebp),%eax
10c8c6: 85 c0 test %eax,%eax
10c8c8: 75 08 jne 10c8d2 <_Objects_Id_to_name+0x16>
10c8ca: a1 d4 78 12 00 mov 0x1278d4,%eax
10c8cf: 8b 40 08 mov 0x8(%eax),%eax
10c8d2: 89 c2 mov %eax,%edx
10c8d4: c1 ea 18 shr $0x18,%edx
10c8d7: 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 )
10c8da: 8d 4a ff lea -0x1(%edx),%ecx
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
10c8dd: bb 03 00 00 00 mov $0x3,%ebx
10c8e2: 83 f9 02 cmp $0x2,%ecx
10c8e5: 77 36 ja 10c91d <_Objects_Id_to_name+0x61>
10c8e7: eb 3b jmp 10c924 <_Objects_Id_to_name+0x68>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10c8e9: 89 c1 mov %eax,%ecx
10c8eb: 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 ];
10c8ee: 8b 14 8a mov (%edx,%ecx,4),%edx
if ( !information )
10c8f1: 85 d2 test %edx,%edx
10c8f3: 74 28 je 10c91d <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
10c8f5: 80 7a 38 00 cmpb $0x0,0x38(%edx)
10c8f9: 75 22 jne 10c91d <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
10c8fb: 51 push %ecx
10c8fc: 8d 4d f4 lea -0xc(%ebp),%ecx
10c8ff: 51 push %ecx
10c900: 50 push %eax
10c901: 52 push %edx
10c902: e8 5d ff ff ff call 10c864 <_Objects_Get>
if ( !the_object )
10c907: 83 c4 10 add $0x10,%esp
10c90a: 85 c0 test %eax,%eax
10c90c: 74 0f je 10c91d <_Objects_Id_to_name+0x61>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10c90e: 8b 50 0c mov 0xc(%eax),%edx
10c911: 8b 45 0c mov 0xc(%ebp),%eax
10c914: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10c916: e8 73 0a 00 00 call 10d38e <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10c91b: 31 db xor %ebx,%ebx
}
10c91d: 89 d8 mov %ebx,%eax
10c91f: 8b 5d fc mov -0x4(%ebp),%ebx
10c922: c9 leave
10c923: 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 ] )
10c924: 8b 14 95 84 73 12 00 mov 0x127384(,%edx,4),%edx
10c92b: 85 d2 test %edx,%edx
10c92d: 75 ba jne 10c8e9 <_Objects_Id_to_name+0x2d>
10c92f: eb ec jmp 10c91d <_Objects_Id_to_name+0x61>
0010e310 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10e310: 55 push %ebp
10e311: 89 e5 mov %esp,%ebp
10e313: 57 push %edi
10e314: 56 push %esi
10e315: 53 push %ebx
10e316: 83 ec 30 sub $0x30,%esp
10e319: 8b 75 08 mov 0x8(%ebp),%esi
10e31c: 8b 5d 14 mov 0x14(%ebp),%ebx
10e31f: 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 );
10e322: 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(
10e325: 50 push %eax
10e326: 56 push %esi
10e327: 68 30 e3 12 00 push $0x12e330
10e32c: 88 55 d4 mov %dl,-0x2c(%ebp)
10e32f: e8 f0 2a 00 00 call 110e24 <_Objects_Get>
switch ( location ) {
10e334: 83 c4 10 add $0x10,%esp
10e337: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10e33b: 8a 55 d4 mov -0x2c(%ebp),%dl
10e33e: 0f 85 aa 00 00 00 jne 10e3ee <_POSIX_Message_queue_Receive_support+0xde>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
10e344: 8b 78 14 mov 0x14(%eax),%edi
10e347: 89 f9 mov %edi,%ecx
10e349: 83 e1 03 and $0x3,%ecx
10e34c: 49 dec %ecx
10e34d: 75 0a jne 10e359 <_POSIX_Message_queue_Receive_support+0x49>
_Thread_Enable_dispatch();
10e34f: e8 f6 35 00 00 call 11194a <_Thread_Enable_dispatch>
10e354: e9 95 00 00 00 jmp 10e3ee <_POSIX_Message_queue_Receive_support+0xde>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10e359: 8b 40 10 mov 0x10(%eax),%eax
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
10e35c: 8b 48 68 mov 0x68(%eax),%ecx
10e35f: 39 4d 10 cmp %ecx,0x10(%ebp)
10e362: 73 15 jae 10e379 <_POSIX_Message_queue_Receive_support+0x69>
_Thread_Enable_dispatch();
10e364: e8 e1 35 00 00 call 11194a <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
10e369: e8 ee 8a 00 00 call 116e5c <__errno>
10e36e: c7 00 7a 00 00 00 movl $0x7a,(%eax)
10e374: e9 80 00 00 00 jmp 10e3f9 <_POSIX_Message_queue_Receive_support+0xe9>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
10e379: 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 )
10e380: 31 c9 xor %ecx,%ecx
10e382: 84 d2 test %dl,%dl
10e384: 74 09 je 10e38f <_POSIX_Message_queue_Receive_support+0x7f><== NEVER TAKEN
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
10e386: 81 e7 00 40 00 00 and $0x4000,%edi
10e38c: 0f 94 c1 sete %cl
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
10e38f: 52 push %edx
10e390: 52 push %edx
10e391: ff 75 1c pushl 0x1c(%ebp)
10e394: 0f b6 c9 movzbl %cl,%ecx
10e397: 51 push %ecx
10e398: 8d 55 e0 lea -0x20(%ebp),%edx
10e39b: 52 push %edx
10e39c: ff 75 0c pushl 0xc(%ebp)
10e39f: 56 push %esi
10e3a0: 83 c0 1c add $0x1c,%eax
10e3a3: 50 push %eax
10e3a4: e8 7f 1c 00 00 call 110028 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
10e3a9: 83 c4 20 add $0x20,%esp
10e3ac: e8 99 35 00 00 call 11194a <_Thread_Enable_dispatch>
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
10e3b1: a1 a8 e3 12 00 mov 0x12e3a8,%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);
10e3b6: 8b 50 24 mov 0x24(%eax),%edx
10e3b9: c1 fa 1f sar $0x1f,%edx
10e3bc: 8b 48 24 mov 0x24(%eax),%ecx
10e3bf: 31 d1 xor %edx,%ecx
10e3c1: 89 0b mov %ecx,(%ebx)
10e3c3: 29 13 sub %edx,(%ebx)
if ( !_Thread_Executing->Wait.return_code )
10e3c5: 83 78 34 00 cmpl $0x0,0x34(%eax)
10e3c9: 75 05 jne 10e3d0 <_POSIX_Message_queue_Receive_support+0xc0>
return length_out;
10e3cb: 8b 45 e0 mov -0x20(%ebp),%eax
10e3ce: eb 2c jmp 10e3fc <_POSIX_Message_queue_Receive_support+0xec>
rtems_set_errno_and_return_minus_one(
10e3d0: e8 87 8a 00 00 call 116e5c <__errno>
10e3d5: 89 c3 mov %eax,%ebx
10e3d7: 83 ec 0c sub $0xc,%esp
10e3da: a1 a8 e3 12 00 mov 0x12e3a8,%eax
10e3df: ff 70 34 pushl 0x34(%eax)
10e3e2: e8 ed 01 00 00 call 10e5d4 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
10e3e7: 89 03 mov %eax,(%ebx)
10e3e9: 83 c4 10 add $0x10,%esp
10e3ec: eb 0b jmp 10e3f9 <_POSIX_Message_queue_Receive_support+0xe9>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10e3ee: e8 69 8a 00 00 call 116e5c <__errno>
10e3f3: c7 00 09 00 00 00 movl $0x9,(%eax)
10e3f9: 83 c8 ff or $0xffffffff,%eax
}
10e3fc: 8d 65 f4 lea -0xc(%ebp),%esp
10e3ff: 5b pop %ebx
10e400: 5e pop %esi
10e401: 5f pop %edi
10e402: c9 leave
10e403: c3 ret
0010bccb <_POSIX_Mutex_Get_interrupt_disable>:
POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable (
pthread_mutex_t *mutex,
Objects_Locations *location,
ISR_Level *level
)
{
10bccb: 55 push %ebp
10bccc: 89 e5 mov %esp,%ebp
10bcce: 56 push %esi
10bccf: 53 push %ebx
10bcd0: 8b 5d 08 mov 0x8(%ebp),%ebx
10bcd3: 8b 75 0c mov 0xc(%ebp),%esi
___POSIX_Mutex_Get_support_error_check( mutex, location );
10bcd6: 85 db test %ebx,%ebx
10bcd8: 74 16 je 10bcf0 <_POSIX_Mutex_Get_interrupt_disable+0x25>
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
10bcda: 83 3b ff cmpl $0xffffffff,(%ebx)
10bcdd: 75 1b jne 10bcfa <_POSIX_Mutex_Get_interrupt_disable+0x2f>
10bcdf: 51 push %ecx
10bce0: 51 push %ecx
10bce1: 6a 00 push $0x0
10bce3: 53 push %ebx
10bce4: e8 73 00 00 00 call 10bd5c <pthread_mutex_init>
10bce9: 83 c4 10 add $0x10,%esp
10bcec: 85 c0 test %eax,%eax
10bcee: 74 0a je 10bcfa <_POSIX_Mutex_Get_interrupt_disable+0x2f><== NEVER TAKEN
10bcf0: c7 06 01 00 00 00 movl $0x1,(%esi)
10bcf6: 31 c0 xor %eax,%eax
10bcf8: eb 13 jmp 10bd0d <_POSIX_Mutex_Get_interrupt_disable+0x42>
return (POSIX_Mutex_Control *) _Objects_Get_isr_disable(
10bcfa: ff 75 10 pushl 0x10(%ebp)
10bcfd: 56 push %esi
10bcfe: ff 33 pushl (%ebx)
10bd00: 68 54 a7 12 00 push $0x12a754
10bd05: e8 06 27 00 00 call 10e410 <_Objects_Get_isr_disable>
10bd0a: 83 c4 10 add $0x10,%esp
&_POSIX_Mutex_Information,
(Objects_Id) *mutex,
location,
level
);
}
10bd0d: 8d 65 f8 lea -0x8(%ebp),%esp
10bd10: 5b pop %ebx
10bd11: 5e pop %esi
10bd12: c9 leave
10bd13: c3 ret
0010e9dc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
10e9dc: 55 push %ebp
10e9dd: 89 e5 mov %esp,%ebp
10e9df: 83 ec 08 sub $0x8,%esp
10e9e2: 8b 55 08 mov 0x8(%ebp),%edx
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
10e9e5: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
10e9eb: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax)
10e9f2: 75 2c jne 10ea20 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NEVER TAKEN
10e9f4: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax)
10e9fb: 75 23 jne 10ea20 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44>
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
10e9fd: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax)
10ea04: 74 1a je 10ea20 <_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;
10ea06: a1 50 63 12 00 mov 0x126350,%eax
10ea0b: 48 dec %eax
10ea0c: a3 50 63 12 00 mov %eax,0x126350
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
10ea11: 50 push %eax
10ea12: 50 push %eax
10ea13: 6a ff push $0xffffffff
10ea15: 52 push %edx
10ea16: e8 51 08 00 00 call 10f26c <_POSIX_Thread_Exit>
10ea1b: 83 c4 10 add $0x10,%esp
} else
_Thread_Enable_dispatch();
}
10ea1e: c9 leave
10ea1f: c3 ret
10ea20: 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();
10ea21: e9 78 db ff ff jmp 10c59e <_Thread_Enable_dispatch>
0010fc74 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
10fc74: 55 push %ebp
10fc75: 89 e5 mov %esp,%ebp
10fc77: 57 push %edi
10fc78: 56 push %esi
10fc79: 53 push %ebx
10fc7a: 83 ec 28 sub $0x28,%esp
10fc7d: 8b 55 08 mov 0x8(%ebp),%edx
10fc80: 8b 5d 0c mov 0xc(%ebp),%ebx
10fc83: 8b 7d 10 mov 0x10(%ebp),%edi
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
10fc86: ff 33 pushl (%ebx)
10fc88: 89 55 e0 mov %edx,-0x20(%ebp)
10fc8b: e8 c4 ff ff ff call 10fc54 <_POSIX_Priority_Is_valid>
10fc90: 83 c4 10 add $0x10,%esp
return EINVAL;
10fc93: 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 ) )
10fc98: 84 c0 test %al,%al
10fc9a: 8b 55 e0 mov -0x20(%ebp),%edx
10fc9d: 0f 84 a4 00 00 00 je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
10fca3: c7 07 00 00 00 00 movl $0x0,(%edi)
*budget_callout = NULL;
10fca9: 8b 45 14 mov 0x14(%ebp),%eax
10fcac: c7 00 00 00 00 00 movl $0x0,(%eax)
if ( policy == SCHED_OTHER ) {
10fcb2: 85 d2 test %edx,%edx
10fcb4: 75 0b jne 10fcc1 <_POSIX_Thread_Translate_sched_param+0x4d>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
10fcb6: c7 07 01 00 00 00 movl $0x1,(%edi)
10fcbc: e9 83 00 00 00 jmp 10fd44 <_POSIX_Thread_Translate_sched_param+0xd0>
return 0;
}
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
10fcc1: 31 f6 xor %esi,%esi
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
10fcc3: 83 fa 01 cmp $0x1,%edx
10fcc6: 74 7f je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
10fcc8: 83 fa 02 cmp $0x2,%edx
10fccb: 75 08 jne 10fcd5 <_POSIX_Thread_Translate_sched_param+0x61>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
10fccd: c7 07 02 00 00 00 movl $0x2,(%edi)
return 0;
10fcd3: eb 72 jmp 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
10fcd5: 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 ) {
10fcda: 83 fa 04 cmp $0x4,%edx
10fcdd: 75 68 jne 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3>
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
10fcdf: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10fce3: 75 06 jne 10fceb <_POSIX_Thread_Translate_sched_param+0x77>
10fce5: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10fce9: 74 5c je 10fd47 <_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) &&
10fceb: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10fcef: 75 0b jne 10fcfc <_POSIX_Thread_Translate_sched_param+0x88>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
10fcf1: 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) &&
10fcf6: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fcfa: 74 4b je 10fd47 <_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 ) <
10fcfc: 83 ec 0c sub $0xc,%esp
10fcff: 8d 43 08 lea 0x8(%ebx),%eax
10fd02: 50 push %eax
10fd03: e8 00 de ff ff call 10db08 <_Timespec_To_ticks>
10fd08: 89 45 e4 mov %eax,-0x1c(%ebp)
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
10fd0b: 8d 43 10 lea 0x10(%ebx),%eax
10fd0e: 89 04 24 mov %eax,(%esp)
10fd11: e8 f2 dd ff ff call 10db08 <_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 ) <
10fd16: 83 c4 10 add $0x10,%esp
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
10fd19: 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 ) <
10fd1e: 39 45 e4 cmp %eax,-0x1c(%ebp)
10fd21: 72 24 jb 10fd47 <_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 ) )
10fd23: 83 ec 0c sub $0xc,%esp
10fd26: ff 73 04 pushl 0x4(%ebx)
10fd29: e8 26 ff ff ff call 10fc54 <_POSIX_Priority_Is_valid>
10fd2e: 83 c4 10 add $0x10,%esp
10fd31: 84 c0 test %al,%al
10fd33: 74 12 je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
10fd35: c7 07 03 00 00 00 movl $0x3,(%edi)
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
10fd3b: 8b 45 14 mov 0x14(%ebp),%eax
10fd3e: c7 00 41 a8 10 00 movl $0x10a841,(%eax)
return 0;
10fd44: 66 31 f6 xor %si,%si
}
return EINVAL;
}
10fd47: 89 f0 mov %esi,%eax
10fd49: 8d 65 f4 lea -0xc(%ebp),%esp
10fd4c: 5b pop %ebx
10fd4d: 5e pop %esi
10fd4e: 5f pop %edi
10fd4f: c9 leave
10fd50: c3 ret
0010a544 <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
10a544: 55 push %ebp
10a545: 89 e5 mov %esp,%ebp
10a547: 57 push %edi
10a548: 56 push %esi
10a549: 53 push %ebx
10a54a: 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;
10a54d: 8b 3d 40 22 12 00 mov 0x122240,%edi
maximum = Configuration_POSIX_API.number_of_initialization_threads;
10a553: 8b 15 3c 22 12 00 mov 0x12223c,%edx
if ( !user_threads || maximum == 0 )
10a559: 85 d2 test %edx,%edx
10a55b: 74 54 je 10a5b1 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a55d: 85 ff test %edi,%edi
10a55f: 74 50 je 10a5b1 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a561: 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 );
10a563: 8d 75 a4 lea -0x5c(%ebp),%esi
10a566: 83 ec 0c sub $0xc,%esp
10a569: 56 push %esi
10a56a: 89 55 94 mov %edx,-0x6c(%ebp)
10a56d: e8 e2 57 00 00 call 10fd54 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
10a572: 5a pop %edx
10a573: 59 pop %ecx
10a574: 6a 02 push $0x2
10a576: 56 push %esi
10a577: e8 00 58 00 00 call 10fd7c <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
10a57c: 59 pop %ecx
10a57d: 58 pop %eax
10a57e: ff 74 df 04 pushl 0x4(%edi,%ebx,8)
10a582: 56 push %esi
10a583: e8 20 58 00 00 call 10fda8 <pthread_attr_setstacksize>
status = pthread_create(
10a588: 6a 00 push $0x0
10a58a: ff 34 df pushl (%edi,%ebx,8)
10a58d: 56 push %esi
10a58e: 8d 45 e4 lea -0x1c(%ebp),%eax
10a591: 50 push %eax
10a592: e8 e5 fc ff ff call 10a27c <pthread_create>
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
10a597: 83 c4 20 add $0x20,%esp
10a59a: 85 c0 test %eax,%eax
10a59c: 8b 55 94 mov -0x6c(%ebp),%edx
10a59f: 74 0b je 10a5ac <_POSIX_Threads_Initialize_user_threads_body+0x68>
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
10a5a1: 52 push %edx
10a5a2: 50 push %eax
10a5a3: 6a 01 push $0x1
10a5a5: 6a 02 push $0x2
10a5a7: e8 e8 1b 00 00 call 10c194 <_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++ ) {
10a5ac: 43 inc %ebx
10a5ad: 39 d3 cmp %edx,%ebx
10a5af: 72 b5 jb 10a566 <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
10a5b1: 8d 65 f4 lea -0xc(%ebp),%esp
10a5b4: 5b pop %ebx
10a5b5: 5e pop %esi
10a5b6: 5f pop %edi
10a5b7: c9 leave
10a5b8: c3 ret
0010edcf <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
10edcf: 55 push %ebp
10edd0: 89 e5 mov %esp,%ebp
10edd2: 56 push %esi
10edd3: 53 push %ebx
10edd4: 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 ];
10edd7: 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 );
10eddd: 83 ec 0c sub $0xc,%esp
10ede0: 8d 86 98 00 00 00 lea 0x98(%esi),%eax
10ede6: 50 push %eax
10ede7: e8 88 0d 00 00 call 10fb74 <_Timespec_To_ticks>
the_thread->cpu_time_budget = ticks;
10edec: 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);
10edef: 0f b6 05 24 12 12 00 movzbl 0x121224,%eax
10edf6: 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;
10edfc: 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 ) {
10edff: 83 c4 10 add $0x10,%esp
10ee02: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx)
10ee06: 75 12 jne 10ee1a <_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 ) {
10ee08: 39 43 14 cmp %eax,0x14(%ebx)
10ee0b: 76 0d jbe 10ee1a <_POSIX_Threads_Sporadic_budget_TSR+0x4b>
_Thread_Change_priority( the_thread, new_priority, true );
10ee0d: 52 push %edx
10ee0e: 6a 01 push $0x1
10ee10: 50 push %eax
10ee11: 53 push %ebx
10ee12: e8 0d d0 ff ff call 10be24 <_Thread_Change_priority>
10ee17: 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 );
10ee1a: 83 ec 0c sub $0xc,%esp
10ee1d: 8d 86 90 00 00 00 lea 0x90(%esi),%eax
10ee23: 50 push %eax
10ee24: e8 4b 0d 00 00 call 10fb74 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10ee29: 89 86 b4 00 00 00 mov %eax,0xb4(%esi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10ee2f: 83 c4 10 add $0x10,%esp
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
10ee32: 81 c6 a8 00 00 00 add $0xa8,%esi
10ee38: 89 75 0c mov %esi,0xc(%ebp)
10ee3b: c7 45 08 04 54 12 00 movl $0x125404,0x8(%ebp)
}
10ee42: 8d 65 f8 lea -0x8(%ebp),%esp
10ee45: 5b pop %ebx
10ee46: 5e pop %esi
10ee47: c9 leave
10ee48: e9 c3 df ff ff jmp 10ce10 <_Watchdog_Insert>
0010ee4d <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
10ee4d: 55 push %ebp
10ee4e: 89 e5 mov %esp,%ebp
10ee50: 83 ec 08 sub $0x8,%esp
10ee53: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10ee56: 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 */
10ee5c: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax)
10ee63: 0f b6 15 24 12 12 00 movzbl 0x121224,%edx
10ee6a: 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;
10ee70: 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 ) {
10ee73: 83 78 1c 00 cmpl $0x0,0x1c(%eax)
10ee77: 75 12 jne 10ee8b <_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 ) {
10ee79: 39 50 14 cmp %edx,0x14(%eax)
10ee7c: 73 0d jae 10ee8b <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN
_Thread_Change_priority( the_thread, new_priority, true );
10ee7e: 51 push %ecx
10ee7f: 6a 01 push $0x1
10ee81: 52 push %edx
10ee82: 50 push %eax
10ee83: e8 9c cf ff ff call 10be24 <_Thread_Change_priority>
10ee88: 83 c4 10 add $0x10,%esp
#if 0
printk( "lower priority\n" );
#endif
}
}
}
10ee8b: c9 leave
10ee8c: c3 ret
0010a304 <_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)
{
10a304: 55 push %ebp
10a305: 89 e5 mov %esp,%ebp
10a307: 53 push %ebx
10a308: 83 ec 04 sub $0x4,%esp
10a30b: 8b 5d 0c mov 0xc(%ebp),%ebx
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
10a30e: ff 43 68 incl 0x68(%ebx)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
10a311: 83 7b 54 00 cmpl $0x0,0x54(%ebx)
10a315: 75 06 jne 10a31d <_POSIX_Timer_TSR+0x19>
10a317: 83 7b 58 00 cmpl $0x0,0x58(%ebx)
10a31b: 74 34 je 10a351 <_POSIX_Timer_TSR+0x4d> <== NEVER TAKEN
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
10a31d: 83 ec 0c sub $0xc,%esp
10a320: 53 push %ebx
10a321: 68 04 a3 10 00 push $0x10a304
10a326: ff 73 08 pushl 0x8(%ebx)
10a329: ff 73 64 pushl 0x64(%ebx)
10a32c: 8d 43 10 lea 0x10(%ebx),%eax
10a32f: 50 push %eax
10a330: e8 e7 56 00 00 call 10fa1c <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
10a335: 83 c4 20 add $0x20,%esp
10a338: 84 c0 test %al,%al
10a33a: 74 30 je 10a36c <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
10a33c: 83 ec 0c sub $0xc,%esp
10a33f: 8d 43 6c lea 0x6c(%ebx),%eax
10a342: 50 push %eax
10a343: e8 5c 14 00 00 call 10b7a4 <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a348: c6 43 3c 03 movb $0x3,0x3c(%ebx)
10a34c: 83 c4 10 add $0x10,%esp
10a34f: eb 04 jmp 10a355 <_POSIX_Timer_TSR+0x51>
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a351: 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 ) ) {
10a355: 50 push %eax
10a356: 50 push %eax
10a357: ff 73 44 pushl 0x44(%ebx)
10a35a: ff 73 38 pushl 0x38(%ebx)
10a35d: e8 92 52 00 00 call 10f5f4 <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
10a362: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
10a369: 83 c4 10 add $0x10,%esp
}
10a36c: 8b 5d fc mov -0x4(%ebp),%ebx
10a36f: c9 leave
10a370: c3 ret
00110b54 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
110b54: 55 push %ebp
110b55: 89 e5 mov %esp,%ebp
110b57: 57 push %edi
110b58: 56 push %esi
110b59: 53 push %ebx
110b5a: 83 ec 68 sub $0x68,%esp
110b5d: 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,
110b60: 6a 01 push $0x1
110b62: 0f b6 45 10 movzbl 0x10(%ebp),%eax
110b66: 50 push %eax
110b67: 8d 45 dc lea -0x24(%ebp),%eax
110b6a: 50 push %eax
110b6b: 53 push %ebx
110b6c: ff 75 08 pushl 0x8(%ebp)
110b6f: e8 8c 00 00 00 call 110c00 <_POSIX_signals_Clear_signals>
110b74: 83 c4 20 add $0x20,%esp
is_global, true ) )
return false;
110b77: 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,
110b79: 84 c0 test %al,%al
110b7b: 74 78 je 110bf5 <_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 )
110b7d: 6b d3 0c imul $0xc,%ebx,%edx
110b80: 8b 82 a4 58 12 00 mov 0x1258a4(%edx),%eax
110b86: 83 f8 01 cmp $0x1,%eax
110b89: 74 6a je 110bf5 <_POSIX_signals_Check_signal+0xa1><== NEVER TAKEN
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
110b8b: 8b 4d 08 mov 0x8(%ebp),%ecx
110b8e: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx
110b94: 89 4d a4 mov %ecx,-0x5c(%ebp)
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
110b97: 0b 8a a0 58 12 00 or 0x1258a0(%edx),%ecx
110b9d: 8b 75 08 mov 0x8(%ebp),%esi
110ba0: 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,
110ba6: 8d 7d b4 lea -0x4c(%ebp),%edi
110ba9: 8b 35 68 58 12 00 mov 0x125868,%esi
110baf: 83 c6 20 add $0x20,%esi
110bb2: b9 0a 00 00 00 mov $0xa,%ecx
110bb7: 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 ) {
110bb9: 83 ba 9c 58 12 00 02 cmpl $0x2,0x12589c(%edx)
110bc0: 75 09 jne 110bcb <_POSIX_signals_Check_signal+0x77>
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
110bc2: 52 push %edx
110bc3: 6a 00 push $0x0
110bc5: 8d 55 dc lea -0x24(%ebp),%edx
110bc8: 52 push %edx
110bc9: eb 03 jmp 110bce <_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 );
110bcb: 83 ec 0c sub $0xc,%esp
110bce: 53 push %ebx
110bcf: ff d0 call *%eax
break;
110bd1: 83 c4 10 add $0x10,%esp
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
110bd4: 8b 3d 68 58 12 00 mov 0x125868,%edi
110bda: 83 c7 20 add $0x20,%edi
110bdd: 8d 75 b4 lea -0x4c(%ebp),%esi
110be0: b9 0a 00 00 00 mov $0xa,%ecx
110be5: 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;
110be7: 8b 75 a4 mov -0x5c(%ebp),%esi
110bea: 8b 4d 08 mov 0x8(%ebp),%ecx
110bed: 89 b1 d0 00 00 00 mov %esi,0xd0(%ecx)
return true;
110bf3: b1 01 mov $0x1,%cl
}
110bf5: 88 c8 mov %cl,%al
110bf7: 8d 65 f4 lea -0xc(%ebp),%esp
110bfa: 5b pop %ebx
110bfb: 5e pop %esi
110bfc: 5f pop %edi
110bfd: c9 leave
110bfe: c3 ret
001110e8 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
1110e8: 55 push %ebp
1110e9: 89 e5 mov %esp,%ebp
1110eb: 53 push %ebx
1110ec: 8b 4d 08 mov 0x8(%ebp),%ecx
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
1110ef: 9c pushf
1110f0: fa cli
1110f1: 5a pop %edx
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
1110f2: 6b c1 0c imul $0xc,%ecx,%eax
1110f5: 83 b8 9c 58 12 00 02 cmpl $0x2,0x12589c(%eax)
1110fc: 75 0e jne 11110c <_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 );
1110fe: 8d 98 98 5a 12 00 lea 0x125a98(%eax),%ebx
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
111104: 39 98 94 5a 12 00 cmp %ebx,0x125a94(%eax)
11110a: 75 0e jne 11111a <_POSIX_signals_Clear_process_signals+0x32><== NEVER TAKEN
11110c: 49 dec %ecx
11110d: b8 fe ff ff ff mov $0xfffffffe,%eax
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
111112: d3 c0 rol %cl,%eax
111114: 21 05 90 5a 12 00 and %eax,0x125a90
}
_ISR_Enable( level );
11111a: 52 push %edx
11111b: 9d popf
}
11111c: 5b pop %ebx
11111d: c9 leave
11111e: c3 ret
0010aba8 <_POSIX_signals_Get_lowest>:
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
10aba8: 55 push %ebp
10aba9: 89 e5 mov %esp,%ebp
10abab: 56 push %esi
10abac: 53 push %ebx
10abad: 8b 55 08 mov 0x8(%ebp),%edx
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10abb0: b8 1b 00 00 00 mov $0x1b,%eax
10abb5: 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(
10abba: 8d 48 ff lea -0x1(%eax),%ecx
10abbd: 89 de mov %ebx,%esi
10abbf: d3 e6 shl %cl,%esi
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
10abc1: 85 d6 test %edx,%esi
10abc3: 75 1e jne 10abe3 <_POSIX_signals_Get_lowest+0x3b><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10abc5: 40 inc %eax
10abc6: 83 f8 20 cmp $0x20,%eax
10abc9: 75 ef jne 10abba <_POSIX_signals_Get_lowest+0x12>
10abcb: b0 01 mov $0x1,%al
10abcd: 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(
10abd2: 8d 48 ff lea -0x1(%eax),%ecx
10abd5: 89 de mov %ebx,%esi
10abd7: 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 ) ) {
10abd9: 85 d6 test %edx,%esi
10abdb: 75 06 jne 10abe3 <_POSIX_signals_Get_lowest+0x3b>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
10abdd: 40 inc %eax
10abde: 83 f8 1b cmp $0x1b,%eax
10abe1: 75 ef jne 10abd2 <_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;
}
10abe3: 5b pop %ebx
10abe4: 5e pop %esi
10abe5: c9 leave
10abe6: c3 ret
001221a0 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
1221a0: 55 push %ebp
1221a1: 89 e5 mov %esp,%ebp
1221a3: 57 push %edi
1221a4: 56 push %esi
1221a5: 53 push %ebx
1221a6: 83 ec 0c sub $0xc,%esp
1221a9: 8b 5d 08 mov 0x8(%ebp),%ebx
1221ac: 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 ];
1221af: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax
1221b5: 8d 4e ff lea -0x1(%esi),%ecx
1221b8: ba 01 00 00 00 mov $0x1,%edx
1221bd: d3 e2 shl %cl,%edx
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
1221bf: 8b 4b 10 mov 0x10(%ebx),%ecx
1221c2: 89 cf mov %ecx,%edi
1221c4: 81 e7 00 80 00 10 and $0x10008000,%edi
1221ca: 81 ff 00 80 00 10 cmp $0x10008000,%edi
1221d0: 75 58 jne 12222a <_POSIX_signals_Unblock_thread+0x8a>
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
1221d2: 85 53 30 test %edx,0x30(%ebx)
1221d5: 75 12 jne 1221e9 <_POSIX_signals_Unblock_thread+0x49>
1221d7: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
1221dd: f7 d0 not %eax
/*
* This should only be reached via pthread_kill().
*/
return false;
1221df: 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) ) {
1221e1: 85 c2 test %eax,%edx
1221e3: 0f 84 b0 00 00 00 je 122299 <_POSIX_signals_Unblock_thread+0xf9>
the_thread->Wait.return_code = EINTR;
1221e9: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
1221f0: 8b 43 28 mov 0x28(%ebx),%eax
if ( !info ) {
1221f3: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
1221f7: 75 12 jne 12220b <_POSIX_signals_Unblock_thread+0x6b>
the_info->si_signo = signo;
1221f9: 89 30 mov %esi,(%eax)
the_info->si_code = SI_USER;
1221fb: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_info->si_value.sival_int = 0;
122202: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
122209: eb 0c jmp 122217 <_POSIX_signals_Unblock_thread+0x77>
} else {
*the_info = *info;
12220b: b9 03 00 00 00 mov $0x3,%ecx
122210: 89 c7 mov %eax,%edi
122212: 8b 75 10 mov 0x10(%ebp),%esi
122215: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
_Thread_queue_Extract_with_proxy( the_thread );
122217: 83 ec 0c sub $0xc,%esp
12221a: 53 push %ebx
12221b: e8 c0 ed fe ff call 110fe0 <_Thread_queue_Extract_with_proxy>
return true;
122220: 83 c4 10 add $0x10,%esp
122223: bf 01 00 00 00 mov $0x1,%edi
122228: eb 6f jmp 122299 <_POSIX_signals_Unblock_thread+0xf9>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
12222a: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
122230: 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;
122232: 31 ff xor %edi,%edi
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
122234: 85 c2 test %eax,%edx
122236: 74 61 je 122299 <_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 ) ) {
122238: f7 c1 00 00 00 10 test $0x10000000,%ecx
12223e: 74 3d je 12227d <_POSIX_signals_Unblock_thread+0xdd>
the_thread->Wait.return_code = EINTR;
122240: 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) )
122247: f7 c1 e0 be 03 00 test $0x3bee0,%ecx
12224d: 74 0b je 12225a <_POSIX_signals_Unblock_thread+0xba>
_Thread_queue_Extract_with_proxy( the_thread );
12224f: 83 ec 0c sub $0xc,%esp
122252: 53 push %ebx
122253: e8 88 ed fe ff call 110fe0 <_Thread_queue_Extract_with_proxy>
122258: eb 1e jmp 122278 <_POSIX_signals_Unblock_thread+0xd8>
else if ( _States_Is_delaying(the_thread->current_state) ) {
12225a: 80 e1 08 and $0x8,%cl
12225d: 74 3a je 122299 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
12225f: 83 ec 0c sub $0xc,%esp
122262: 8d 43 48 lea 0x48(%ebx),%eax
122265: 50 push %eax
122266: e8 85 f4 fe ff call 1116f0 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
12226b: 58 pop %eax
12226c: 5a pop %edx
12226d: 68 f8 ff 03 10 push $0x1003fff8
122272: 53 push %ebx
122273: e8 2c e4 fe ff call 1106a4 <_Thread_Clear_state>
122278: 83 c4 10 add $0x10,%esp
12227b: eb 1c jmp 122299 <_POSIX_signals_Unblock_thread+0xf9>
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
12227d: 85 c9 test %ecx,%ecx
12227f: 75 18 jne 122299 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
122281: 83 3d d8 b9 12 00 00 cmpl $0x0,0x12b9d8
122288: 74 0f je 122299 <_POSIX_signals_Unblock_thread+0xf9>
12228a: 3b 1d dc b9 12 00 cmp 0x12b9dc,%ebx
122290: 75 07 jne 122299 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
122292: c6 05 e8 b9 12 00 01 movb $0x1,0x12b9e8
}
}
return false;
}
122299: 89 f8 mov %edi,%eax
12229b: 8d 65 f4 lea -0xc(%ebp),%esp
12229e: 5b pop %ebx
12229f: 5e pop %esi
1222a0: 5f pop %edi
1222a1: c9 leave
1222a2: c3 ret
0010efb0 <_Protected_heap_Walk>:
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
10efb0: 55 push %ebp
10efb1: 89 e5 mov %esp,%ebp
10efb3: 57 push %edi
10efb4: 56 push %esi
10efb5: 53 push %ebx
10efb6: 83 ec 1c sub $0x1c,%esp
10efb9: 8b 5d 08 mov 0x8(%ebp),%ebx
10efbc: 8b 75 0c mov 0xc(%ebp),%esi
10efbf: 8b 7d 10 mov 0x10(%ebp),%edi
* then it is forbidden to lock a mutex. But since we are inside
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( !_Thread_Dispatch_disable_level ) {
10efc2: a1 6c bc 12 00 mov 0x12bc6c,%eax
10efc7: 85 c0 test %eax,%eax
10efc9: 75 3c jne 10f007 <_Protected_heap_Walk+0x57><== NEVER TAKEN
_RTEMS_Lock_allocator();
10efcb: 83 ec 0c sub $0xc,%esp
10efce: ff 35 10 bd 12 00 pushl 0x12bd10
10efd4: e8 93 e6 ff ff call 10d66c <_API_Mutex_Lock>
status = _Heap_Walk( the_heap, source, do_dump );
10efd9: 83 c4 0c add $0xc,%esp
10efdc: 81 e7 ff 00 00 00 and $0xff,%edi
10efe2: 57 push %edi
10efe3: 56 push %esi
10efe4: 53 push %ebx
10efe5: e8 a4 f3 ff ff call 10e38e <_Heap_Walk>
_RTEMS_Unlock_allocator();
10efea: 5a pop %edx
10efeb: ff 35 10 bd 12 00 pushl 0x12bd10
10eff1: 88 45 e4 mov %al,-0x1c(%ebp)
10eff4: e8 bb e6 ff ff call 10d6b4 <_API_Mutex_Unlock>
10eff9: 83 c4 10 add $0x10,%esp
} else {
status = _Heap_Walk( the_heap, source, do_dump );
}
return status;
}
10effc: 8a 45 e4 mov -0x1c(%ebp),%al
10efff: 8d 65 f4 lea -0xc(%ebp),%esp
10f002: 5b pop %ebx
10f003: 5e pop %esi
10f004: 5f pop %edi
10f005: c9 leave
10f006: c3 ret
if ( !_Thread_Dispatch_disable_level ) {
_RTEMS_Lock_allocator();
status = _Heap_Walk( the_heap, source, do_dump );
_RTEMS_Unlock_allocator();
} else {
status = _Heap_Walk( the_heap, source, do_dump );
10f007: 81 e7 ff 00 00 00 and $0xff,%edi
10f00d: 89 7d 10 mov %edi,0x10(%ebp)
10f010: 89 75 0c mov %esi,0xc(%ebp)
10f013: 89 5d 08 mov %ebx,0x8(%ebp)
}
return status;
}
10f016: 8d 65 f4 lea -0xc(%ebp),%esp
10f019: 5b pop %ebx
10f01a: 5e pop %esi
10f01b: 5f pop %edi
10f01c: c9 leave
if ( !_Thread_Dispatch_disable_level ) {
_RTEMS_Lock_allocator();
status = _Heap_Walk( the_heap, source, do_dump );
_RTEMS_Unlock_allocator();
} else {
status = _Heap_Walk( the_heap, source, do_dump );
10f01d: e9 6c f3 ff ff jmp 10e38e <_Heap_Walk>
0010b3fc <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10b3fc: 55 push %ebp
10b3fd: 89 e5 mov %esp,%ebp
10b3ff: 53 push %ebx
10b400: 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 );
10b403: 8d 45 f4 lea -0xc(%ebp),%eax
10b406: 50 push %eax
10b407: ff 75 08 pushl 0x8(%ebp)
10b40a: 68 74 83 12 00 push $0x128374
10b40f: e8 c8 1a 00 00 call 10cedc <_Objects_Get>
10b414: 89 c3 mov %eax,%ebx
switch ( location ) {
10b416: 83 c4 10 add $0x10,%esp
10b419: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10b41d: 75 64 jne 10b483 <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10b41f: 8b 40 40 mov 0x40(%eax),%eax
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10b422: f6 40 11 40 testb $0x40,0x11(%eax)
10b426: 74 18 je 10b440 <_Rate_monotonic_Timeout+0x44>
10b428: 8b 53 08 mov 0x8(%ebx),%edx
10b42b: 39 50 20 cmp %edx,0x20(%eax)
10b42e: 75 10 jne 10b440 <_Rate_monotonic_Timeout+0x44>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10b430: 52 push %edx
10b431: 52 push %edx
10b432: 68 f8 ff 03 10 push $0x1003fff8
10b437: 50 push %eax
10b438: e8 3b 22 00 00 call 10d678 <_Thread_Clear_state>
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
10b43d: 59 pop %ecx
10b43e: eb 10 jmp 10b450 <_Rate_monotonic_Timeout+0x54>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
10b440: 83 7b 38 01 cmpl $0x1,0x38(%ebx)
10b444: 75 2b jne 10b471 <_Rate_monotonic_Timeout+0x75>
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
10b446: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx)
_Rate_monotonic_Initiate_statistics( the_period );
10b44d: 83 ec 0c sub $0xc,%esp
10b450: 53 push %ebx
10b451: e8 ec fa ff ff call 10af42 <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b456: 8b 43 3c mov 0x3c(%ebx),%eax
10b459: 89 43 1c mov %eax,0x1c(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b45c: 58 pop %eax
10b45d: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
10b45e: 83 c3 10 add $0x10,%ebx
10b461: 53 push %ebx
10b462: 68 28 85 12 00 push $0x128528
10b467: e8 34 32 00 00 call 10e6a0 <_Watchdog_Insert>
10b46c: 83 c4 10 add $0x10,%esp
10b46f: eb 07 jmp 10b478 <_Rate_monotonic_Timeout+0x7c>
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
10b471: 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;
10b478: a1 64 84 12 00 mov 0x128464,%eax
10b47d: 48 dec %eax
10b47e: a3 64 84 12 00 mov %eax,0x128464
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10b483: 8b 5d fc mov -0x4(%ebp),%ebx
10b486: c9 leave
10b487: c3 ret
0010ba6c <_Scheduler_priority_Block>:
#include <rtems/score/thread.h>
void _Scheduler_priority_Block(
Thread_Control *the_thread
)
{
10ba6c: 55 push %ebp
10ba6d: 89 e5 mov %esp,%ebp
10ba6f: 56 push %esi
10ba70: 53 push %ebx
10ba71: 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;
10ba74: 8b 8a 8c 00 00 00 mov 0x8c(%edx),%ecx
ready = sched_info->ready_chain;
10ba7a: 8b 01 mov (%ecx),%eax
if ( _Chain_Has_only_one_node( ready ) ) {
10ba7c: 8b 58 08 mov 0x8(%eax),%ebx
10ba7f: 39 18 cmp %ebx,(%eax)
10ba81: 75 32 jne 10bab5 <_Scheduler_priority_Block+0x49>
Chain_Node *tail = _Chain_Tail( the_chain );
10ba83: 8d 58 04 lea 0x4(%eax),%ebx
10ba86: 89 18 mov %ebx,(%eax)
head->next = tail;
head->previous = NULL;
10ba88: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
tail->previous = head;
10ba8f: 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;
10ba92: 8b 59 04 mov 0x4(%ecx),%ebx
10ba95: 66 8b 03 mov (%ebx),%ax
10ba98: 66 23 41 0e and 0xe(%ecx),%ax
10ba9c: 66 89 03 mov %ax,(%ebx)
if ( *the_priority_map->minor == 0 )
10ba9f: 66 85 c0 test %ax,%ax
10baa2: 75 1b jne 10babf <_Scheduler_priority_Block+0x53>
_Priority_Major_bit_map &= the_priority_map->block_major;
10baa4: 66 a1 78 58 12 00 mov 0x125878,%ax
10baaa: 23 41 0c and 0xc(%ecx),%eax
10baad: 66 a3 78 58 12 00 mov %ax,0x125878
10bab3: eb 0a jmp 10babf <_Scheduler_priority_Block+0x53>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10bab5: 8b 0a mov (%edx),%ecx
previous = the_node->previous;
10bab7: 8b 42 04 mov 0x4(%edx),%eax
next->previous = previous;
10baba: 89 41 04 mov %eax,0x4(%ecx)
previous->next = next;
10babd: 89 08 mov %ecx,(%eax)
_Scheduler_priority_Ready_queue_extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
10babf: 3b 15 6c 58 12 00 cmp 0x12586c,%edx
10bac5: 75 43 jne 10bb0a <_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 );
10bac7: 66 8b 35 78 58 12 00 mov 0x125878,%si
10bace: 31 c9 xor %ecx,%ecx
10bad0: 89 cb mov %ecx,%ebx
10bad2: 66 0f bc de bsf %si,%bx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10bad6: 0f b7 db movzwl %bx,%ebx
10bad9: 66 8b b4 1b 7c 58 12 mov 0x12587c(%ebx,%ebx,1),%si
10bae0: 00
10bae1: 66 0f bc ce bsf %si,%cx
return (_Priority_Bits_index( major ) << 4) +
10bae5: c1 e3 04 shl $0x4,%ebx
10bae8: 0f b7 c9 movzwl %cx,%ecx
10baeb: 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 ] ) )
10baee: 6b c0 0c imul $0xc,%eax,%eax
10baf1: 03 05 50 11 12 00 add 0x121150,%eax
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
10baf7: 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 );
10baf9: 83 c0 04 add $0x4,%eax
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
10bafc: 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 ] ) )
10bafe: 39 c3 cmp %eax,%ebx
10bb00: 74 02 je 10bb04 <_Scheduler_priority_Block+0x98><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
10bb02: 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(
10bb04: 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 ) )
10bb0a: 3b 15 68 58 12 00 cmp 0x125868,%edx
10bb10: 75 07 jne 10bb19 <_Scheduler_priority_Block+0xad>
_Thread_Dispatch_necessary = true;
10bb12: c6 05 74 58 12 00 01 movb $0x1,0x125874
}
10bb19: 5b pop %ebx
10bb1a: 5e pop %esi
10bb1b: c9 leave
10bb1c: c3 ret
0010bc6c <_Scheduler_priority_Schedule>:
#include <rtems/system.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Schedule(void)
{
10bc6c: 55 push %ebp
10bc6d: 89 e5 mov %esp,%ebp
10bc6f: 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 );
10bc70: 66 8b 1d 78 58 12 00 mov 0x125878,%bx
10bc77: 31 d2 xor %edx,%edx
10bc79: 89 d1 mov %edx,%ecx
10bc7b: 66 0f bc cb bsf %bx,%cx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10bc7f: 0f b7 c9 movzwl %cx,%ecx
10bc82: 66 8b 9c 09 7c 58 12 mov 0x12587c(%ecx,%ecx,1),%bx
10bc89: 00
10bc8a: 66 0f bc d3 bsf %bx,%dx
return (_Priority_Bits_index( major ) << 4) +
10bc8e: c1 e1 04 shl $0x4,%ecx
10bc91: 0f b7 d2 movzwl %dx,%edx
10bc94: 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 ] ) )
10bc97: 6b c0 0c imul $0xc,%eax,%eax
10bc9a: 03 05 50 11 12 00 add 0x121150,%eax
_Scheduler_priority_Schedule_body();
}
10bca0: 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 );
10bca2: 83 c0 04 add $0x4,%eax
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
10bca5: 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 ] ) )
10bca7: 39 c1 cmp %eax,%ecx
10bca9: 74 02 je 10bcad <_Scheduler_priority_Schedule+0x41><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
10bcab: 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(
10bcad: 89 15 6c 58 12 00 mov %edx,0x12586c
10bcb3: 5b pop %ebx
10bcb4: c9 leave
10bcb5: c3 ret
0010ad28 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
10ad28: 55 push %ebp
10ad29: 89 e5 mov %esp,%ebp
10ad2b: 56 push %esi
10ad2c: 53 push %ebx
10ad2d: 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();
10ad30: 8b 35 94 4b 12 00 mov 0x124b94,%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;
10ad36: 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) ||
10ad38: 85 c9 test %ecx,%ecx
10ad3a: 74 57 je 10ad93 <_TOD_Validate+0x6b> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
10ad3c: b8 40 42 0f 00 mov $0xf4240,%eax
10ad41: 31 d2 xor %edx,%edx
10ad43: f7 f6 div %esi
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
10ad45: 39 41 18 cmp %eax,0x18(%ecx)
10ad48: 73 49 jae 10ad93 <_TOD_Validate+0x6b>
(the_tod->ticks >= ticks_per_second) ||
10ad4a: 83 79 14 3b cmpl $0x3b,0x14(%ecx)
10ad4e: 77 43 ja 10ad93 <_TOD_Validate+0x6b>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
10ad50: 83 79 10 3b cmpl $0x3b,0x10(%ecx)
10ad54: 77 3d ja 10ad93 <_TOD_Validate+0x6b>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
10ad56: 83 79 0c 17 cmpl $0x17,0xc(%ecx)
10ad5a: 77 37 ja 10ad93 <_TOD_Validate+0x6b>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
10ad5c: 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) ||
10ad5f: 85 c0 test %eax,%eax
10ad61: 74 30 je 10ad93 <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->month == 0) ||
10ad63: 83 f8 0c cmp $0xc,%eax
10ad66: 77 2b ja 10ad93 <_TOD_Validate+0x6b>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10ad68: 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) ||
10ad6a: 81 fe c3 07 00 00 cmp $0x7c3,%esi
10ad70: 76 21 jbe 10ad93 <_TOD_Validate+0x6b>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
10ad72: 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) ||
10ad75: 85 d2 test %edx,%edx
10ad77: 74 1a je 10ad93 <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
10ad79: 83 e6 03 and $0x3,%esi
10ad7c: 75 09 jne 10ad87 <_TOD_Validate+0x5f>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
10ad7e: 8b 04 85 90 1d 12 00 mov 0x121d90(,%eax,4),%eax
10ad85: eb 07 jmp 10ad8e <_TOD_Validate+0x66>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
10ad87: 8b 04 85 5c 1d 12 00 mov 0x121d5c(,%eax,4),%eax
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
10ad8e: 39 c2 cmp %eax,%edx
10ad90: 0f 96 c3 setbe %bl
if ( the_tod->day > days_in_month )
return false;
return true;
}
10ad93: 88 d8 mov %bl,%al
10ad95: 5b pop %ebx
10ad96: 5e pop %esi
10ad97: c9 leave
10ad98: c3 ret
0010be24 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10be24: 55 push %ebp
10be25: 89 e5 mov %esp,%ebp
10be27: 57 push %edi
10be28: 56 push %esi
10be29: 53 push %ebx
10be2a: 83 ec 28 sub $0x28,%esp
10be2d: 8b 5d 08 mov 0x8(%ebp),%ebx
10be30: 8b 75 0c mov 0xc(%ebp),%esi
10be33: 8a 45 10 mov 0x10(%ebp),%al
10be36: 88 45 e7 mov %al,-0x19(%ebp)
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
10be39: 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 );
10be3c: 53 push %ebx
10be3d: e8 62 0b 00 00 call 10c9a4 <_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 )
10be42: 83 c4 10 add $0x10,%esp
10be45: 39 73 14 cmp %esi,0x14(%ebx)
10be48: 74 0c je 10be56 <_Thread_Change_priority+0x32>
_Thread_Set_priority( the_thread, new_priority );
10be4a: 50 push %eax
10be4b: 50 push %eax
10be4c: 56 push %esi
10be4d: 53 push %ebx
10be4e: e8 01 0b 00 00 call 10c954 <_Thread_Set_priority>
10be53: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10be56: 9c pushf
10be57: fa cli
10be58: 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;
10be59: 8b 43 10 mov 0x10(%ebx),%eax
if ( state != STATES_TRANSIENT ) {
10be5c: 83 f8 04 cmp $0x4,%eax
10be5f: 74 2b je 10be8c <_Thread_Change_priority+0x68>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10be61: 83 e7 04 and $0x4,%edi
10be64: 75 08 jne 10be6e <_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);
10be66: 89 c2 mov %eax,%edx
10be68: 83 e2 fb and $0xfffffffb,%edx
10be6b: 89 53 10 mov %edx,0x10(%ebx)
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
10be6e: 56 push %esi
10be6f: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10be70: a9 e0 be 03 00 test $0x3bee0,%eax
10be75: 74 65 je 10bedc <_Thread_Change_priority+0xb8>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
10be77: 89 5d 0c mov %ebx,0xc(%ebp)
10be7a: 8b 43 44 mov 0x44(%ebx),%eax
10be7d: 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 );
}
10be80: 8d 65 f4 lea -0xc(%ebp),%esp
10be83: 5b pop %ebx
10be84: 5e pop %esi
10be85: 5f pop %edi
10be86: 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 );
10be87: e9 40 0a 00 00 jmp 10c8cc <_Thread_queue_Requeue>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10be8c: 83 e7 04 and $0x4,%edi
10be8f: 75 26 jne 10beb7 <_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 );
10be91: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
if ( prepend_it )
10be98: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10be9c: 74 0c je 10beaa <_Thread_Change_priority+0x86>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
10be9e: 83 ec 0c sub $0xc,%esp
10bea1: 53 push %ebx
10bea2: ff 15 78 11 12 00 call *0x121178
10bea8: eb 0a jmp 10beb4 <_Thread_Change_priority+0x90>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
10beaa: 83 ec 0c sub $0xc,%esp
10bead: 53 push %ebx
10beae: ff 15 74 11 12 00 call *0x121174
10beb4: 83 c4 10 add $0x10,%esp
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
10beb7: 56 push %esi
10beb8: 9d popf
10beb9: 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();
10beba: 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 );
10bec0: 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() &&
10bec5: 3b 05 6c 58 12 00 cmp 0x12586c,%eax
10becb: 74 0d je 10beda <_Thread_Change_priority+0xb6>
10becd: 80 78 74 00 cmpb $0x0,0x74(%eax)
10bed1: 74 07 je 10beda <_Thread_Change_priority+0xb6>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
10bed3: c6 05 74 58 12 00 01 movb $0x1,0x125874
_ISR_Enable( level );
10beda: 56 push %esi
10bedb: 9d popf
}
10bedc: 8d 65 f4 lea -0xc(%ebp),%esp
10bedf: 5b pop %ebx
10bee0: 5e pop %esi
10bee1: 5f pop %edi
10bee2: c9 leave
10bee3: c3 ret
0010c088 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10c088: 55 push %ebp
10c089: 89 e5 mov %esp,%ebp
10c08b: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10c08e: 8d 45 f4 lea -0xc(%ebp),%eax
10c091: 50 push %eax
10c092: ff 75 08 pushl 0x8(%ebp)
10c095: e8 82 01 00 00 call 10c21c <_Thread_Get>
switch ( location ) {
10c09a: 83 c4 10 add $0x10,%esp
10c09d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10c0a1: 75 1b jne 10c0be <_Thread_Delay_ended+0x36><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
10c0a3: 52 push %edx
10c0a4: 52 push %edx
10c0a5: 68 18 00 00 10 push $0x10000018
10c0aa: 50 push %eax
10c0ab: e8 34 fe ff ff call 10bee4 <_Thread_Clear_state>
10c0b0: a1 40 53 12 00 mov 0x125340,%eax
10c0b5: 48 dec %eax
10c0b6: a3 40 53 12 00 mov %eax,0x125340
10c0bb: 83 c4 10 add $0x10,%esp
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
10c0be: c9 leave
10c0bf: c3 ret
0010c0c0 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10c0c0: 55 push %ebp
10c0c1: 89 e5 mov %esp,%ebp
10c0c3: 57 push %edi
10c0c4: 56 push %esi
10c0c5: 53 push %ebx
10c0c6: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10c0c9: 8b 1d 68 58 12 00 mov 0x125868,%ebx
_ISR_Disable( level );
10c0cf: 9c pushf
10c0d0: fa cli
10c0d1: 58 pop %eax
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
10c0d2: 8d 7d d8 lea -0x28(%ebp),%edi
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10c0d5: e9 f9 00 00 00 jmp 10c1d3 <_Thread_Dispatch+0x113>
heir = _Thread_Heir;
10c0da: 8b 35 6c 58 12 00 mov 0x12586c,%esi
_Thread_Dispatch_disable_level = 1;
10c0e0: c7 05 40 53 12 00 01 movl $0x1,0x125340
10c0e7: 00 00 00
_Thread_Dispatch_necessary = false;
10c0ea: c6 05 74 58 12 00 00 movb $0x0,0x125874
_Thread_Executing = heir;
10c0f1: 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 )
10c0f7: 39 de cmp %ebx,%esi
10c0f9: 0f 84 e2 00 00 00 je 10c1e1 <_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 )
10c0ff: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10c103: 75 09 jne 10c10e <_Thread_Dispatch+0x4e>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c105: 8b 15 10 53 12 00 mov 0x125310,%edx
10c10b: 89 56 78 mov %edx,0x78(%esi)
_ISR_Enable( level );
10c10e: 50 push %eax
10c10f: 9d popf
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
10c110: 83 ec 0c sub $0xc,%esp
10c113: 8d 45 e0 lea -0x20(%ebp),%eax
10c116: 50 push %eax
10c117: e8 5c 34 00 00 call 10f578 <_TOD_Get_uptime>
_Timestamp_Subtract(
10c11c: 83 c4 0c add $0xc,%esp
10c11f: 57 push %edi
10c120: 8d 45 e0 lea -0x20(%ebp),%eax
10c123: 50 push %eax
10c124: 68 f0 53 12 00 push $0x1253f0
10c129: e8 76 0a 00 00 call 10cba4 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
10c12e: 58 pop %eax
10c12f: 5a pop %edx
10c130: 57 push %edi
10c131: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax
10c137: 50 push %eax
10c138: e8 37 0a 00 00 call 10cb74 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10c13d: 8b 45 e0 mov -0x20(%ebp),%eax
10c140: 8b 55 e4 mov -0x1c(%ebp),%edx
10c143: a3 f0 53 12 00 mov %eax,0x1253f0
10c148: 89 15 f4 53 12 00 mov %edx,0x1253f4
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10c14e: a1 c8 53 12 00 mov 0x1253c8,%eax
10c153: 83 c4 10 add $0x10,%esp
10c156: 85 c0 test %eax,%eax
10c158: 74 10 je 10c16a <_Thread_Dispatch+0xaa> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10c15a: 8b 10 mov (%eax),%edx
10c15c: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10c162: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx
10c168: 89 10 mov %edx,(%eax)
}
_User_extensions_Thread_switch( executing, heir );
10c16a: 51 push %ecx
10c16b: 51 push %ecx
10c16c: 56 push %esi
10c16d: 53 push %ebx
10c16e: e8 69 0c 00 00 call 10cddc <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10c173: 58 pop %eax
10c174: 5a pop %edx
10c175: 81 c6 c8 00 00 00 add $0xc8,%esi
10c17b: 56 push %esi
10c17c: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax
10c182: 50 push %eax
10c183: e8 28 0f 00 00 call 10d0b0 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10c188: 83 c4 10 add $0x10,%esp
10c18b: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx)
10c192: 74 36 je 10c1ca <_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 );
10c194: a1 c4 53 12 00 mov 0x1253c4,%eax
10c199: 39 c3 cmp %eax,%ebx
10c19b: 74 2d je 10c1ca <_Thread_Dispatch+0x10a>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10c19d: 85 c0 test %eax,%eax
10c19f: 74 11 je 10c1b2 <_Thread_Dispatch+0xf2>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10c1a1: 83 ec 0c sub $0xc,%esp
10c1a4: 05 e0 00 00 00 add $0xe0,%eax
10c1a9: 50 push %eax
10c1aa: e8 35 0f 00 00 call 10d0e4 <_CPU_Context_save_fp>
10c1af: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10c1b2: 83 ec 0c sub $0xc,%esp
10c1b5: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax
10c1bb: 50 push %eax
10c1bc: e8 2d 0f 00 00 call 10d0ee <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10c1c1: 89 1d c4 53 12 00 mov %ebx,0x1253c4
10c1c7: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10c1ca: 8b 1d 68 58 12 00 mov 0x125868,%ebx
_ISR_Disable( level );
10c1d0: 9c pushf
10c1d1: fa cli
10c1d2: 58 pop %eax
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10c1d3: 8a 15 74 58 12 00 mov 0x125874,%dl
10c1d9: 84 d2 test %dl,%dl
10c1db: 0f 85 f9 fe ff ff jne 10c0da <_Thread_Dispatch+0x1a>
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
10c1e1: c7 05 40 53 12 00 00 movl $0x0,0x125340
10c1e8: 00 00 00
_ISR_Enable( level );
10c1eb: 50 push %eax
10c1ec: 9d popf
_API_extensions_Run_postswitch();
10c1ed: e8 3d e7 ff ff call 10a92f <_API_extensions_Run_postswitch>
}
10c1f2: 8d 65 f4 lea -0xc(%ebp),%esp
10c1f5: 5b pop %ebx
10c1f6: 5e pop %esi
10c1f7: 5f pop %edi
10c1f8: c9 leave
10c1f9: c3 ret
00110f9c <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
110f9c: 55 push %ebp
110f9d: 89 e5 mov %esp,%ebp
110f9f: 53 push %ebx
110fa0: 83 ec 14 sub $0x14,%esp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
110fa3: 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;
110fa9: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax
_ISR_Set_level(level);
110faf: 85 c0 test %eax,%eax
110fb1: 74 03 je 110fb6 <_Thread_Handler+0x1a>
110fb3: fa cli
110fb4: eb 01 jmp 110fb7 <_Thread_Handler+0x1b>
110fb6: fb sti
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
110fb7: a0 00 50 12 00 mov 0x125000,%al
110fbc: 88 45 f7 mov %al,-0x9(%ebp)
doneConstructors = 1;
110fbf: 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) &&
110fc6: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx)
110fcd: 74 24 je 110ff3 <_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 );
110fcf: a1 c4 53 12 00 mov 0x1253c4,%eax
110fd4: 39 c3 cmp %eax,%ebx
110fd6: 74 1b je 110ff3 <_Thread_Handler+0x57>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
110fd8: 85 c0 test %eax,%eax
110fda: 74 11 je 110fed <_Thread_Handler+0x51>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
110fdc: 83 ec 0c sub $0xc,%esp
110fdf: 05 e0 00 00 00 add $0xe0,%eax
110fe4: 50 push %eax
110fe5: e8 fa c0 ff ff call 10d0e4 <_CPU_Context_save_fp>
110fea: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
110fed: 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 );
110ff3: 83 ec 0c sub $0xc,%esp
110ff6: 53 push %ebx
110ff7: e8 90 bc ff ff call 10cc8c <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
110ffc: e8 f9 b1 ff ff call 10c1fa <_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) */ {
111001: 83 c4 10 add $0x10,%esp
111004: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
111008: 75 05 jne 11100f <_Thread_Handler+0x73>
INIT_NAME ();
11100a: e8 31 c7 00 00 call 11d740 <__start_set_sysctl_set>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
11100f: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax
111015: 85 c0 test %eax,%eax
111017: 75 0b jne 111024 <_Thread_Handler+0x88>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
111019: 83 ec 0c sub $0xc,%esp
11101c: ff b3 9c 00 00 00 pushl 0x9c(%ebx)
111022: eb 0c jmp 111030 <_Thread_Handler+0x94>
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
111024: 48 dec %eax
111025: 75 15 jne 11103c <_Thread_Handler+0xa0> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
111027: 83 ec 0c sub $0xc,%esp
11102a: ff b3 98 00 00 00 pushl 0x98(%ebx)
111030: 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 =
111036: 89 43 28 mov %eax,0x28(%ebx)
111039: 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 );
11103c: 83 ec 0c sub $0xc,%esp
11103f: 53 push %ebx
111040: e8 78 bc ff ff call 10ccbd <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
111045: 83 c4 0c add $0xc,%esp
111048: 6a 05 push $0x5
11104a: 6a 01 push $0x1
11104c: 6a 00 push $0x0
11104e: e8 39 a2 ff ff call 10b28c <_Internal_error_Occurred>
0010c290 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10c290: 55 push %ebp
10c291: 89 e5 mov %esp,%ebp
10c293: 57 push %edi
10c294: 56 push %esi
10c295: 53 push %ebx
10c296: 83 ec 1c sub $0x1c,%esp
10c299: 8b 5d 0c mov 0xc(%ebp),%ebx
10c29c: 8b 4d 10 mov 0x10(%ebp),%ecx
10c29f: 8b 75 14 mov 0x14(%ebp),%esi
10c2a2: 8a 55 18 mov 0x18(%ebp),%dl
10c2a5: 8a 45 20 mov 0x20(%ebp),%al
10c2a8: 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;
10c2ab: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
10c2b2: 00 00 00
10c2b5: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx)
10c2bc: 00 00 00
extensions_area = NULL;
the_thread->libc_reent = NULL;
10c2bf: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10c2c6: 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 ) {
10c2c9: 85 c9 test %ecx,%ecx
10c2cb: 75 31 jne 10c2fe <_Thread_Initialize+0x6e>
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10c2cd: 57 push %edi
10c2ce: 57 push %edi
10c2cf: 56 push %esi
10c2d0: 53 push %ebx
10c2d1: 88 55 e0 mov %dl,-0x20(%ebp)
10c2d4: e8 fb 06 00 00 call 10c9d4 <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10c2d9: 83 c4 10 add $0x10,%esp
10c2dc: 39 f0 cmp %esi,%eax
10c2de: 8a 55 e0 mov -0x20(%ebp),%dl
10c2e1: 0f 82 bf 01 00 00 jb 10c4a6 <_Thread_Initialize+0x216>
10c2e7: 85 c0 test %eax,%eax
10c2e9: 0f 84 b7 01 00 00 je 10c4a6 <_Thread_Initialize+0x216><== NEVER TAKEN
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
10c2ef: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx
the_thread->Start.core_allocated_stack = true;
10c2f5: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx)
10c2fc: eb 09 jmp 10c307 <_Thread_Initialize+0x77>
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
10c2fe: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx)
10c305: 89 f0 mov %esi,%eax
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
10c307: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx)
the_stack->size = size;
10c30d: 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;
10c313: 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 ) {
10c315: 84 d2 test %dl,%dl
10c317: 74 17 je 10c330 <_Thread_Initialize+0xa0>
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
10c319: 83 ec 0c sub $0xc,%esp
10c31c: 6a 6c push $0x6c
10c31e: e8 27 0d 00 00 call 10d04a <_Workspace_Allocate>
10c323: 89 c7 mov %eax,%edi
if ( !fp_area )
10c325: 83 c4 10 add $0x10,%esp
10c328: 85 c0 test %eax,%eax
10c32a: 0f 84 23 01 00 00 je 10c453 <_Thread_Initialize+0x1c3>
goto failed;
fp_area = _Context_Fp_start( fp_area, 0 );
}
the_thread->fp_context = fp_area;
10c330: 89 bb e0 00 00 00 mov %edi,0xe0(%ebx)
the_thread->Start.fp_context = fp_area;
10c336: 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;
10c33c: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10c343: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
the_watchdog->id = id;
10c34a: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
the_watchdog->user_data = user_data;
10c351: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c358: 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;
10c35d: 31 f6 xor %esi,%esi
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c35f: 85 c0 test %eax,%eax
10c361: 74 1d je 10c380 <_Thread_Initialize+0xf0>
extensions_area = _Workspace_Allocate(
10c363: 83 ec 0c sub $0xc,%esp
10c366: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax
10c36d: 50 push %eax
10c36e: e8 d7 0c 00 00 call 10d04a <_Workspace_Allocate>
10c373: 89 c6 mov %eax,%esi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
10c375: 83 c4 10 add $0x10,%esp
10c378: 85 c0 test %eax,%eax
10c37a: 0f 84 d5 00 00 00 je 10c455 <_Thread_Initialize+0x1c5>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10c380: 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 ) {
10c386: 85 f6 test %esi,%esi
10c388: 74 16 je 10c3a0 <_Thread_Initialize+0x110>
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
10c38a: 8b 15 d4 53 12 00 mov 0x1253d4,%edx
10c390: 31 c0 xor %eax,%eax
10c392: eb 08 jmp 10c39c <_Thread_Initialize+0x10c>
the_thread->extensions[i] = NULL;
10c394: 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++ )
10c39b: 40 inc %eax
10c39c: 39 d0 cmp %edx,%eax
10c39e: 76 f4 jbe 10c394 <_Thread_Initialize+0x104>
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10c3a0: 8a 45 e7 mov -0x19(%ebp),%al
10c3a3: 88 83 a0 00 00 00 mov %al,0xa0(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10c3a9: 8b 45 24 mov 0x24(%ebp),%eax
10c3ac: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
the_thread->Start.budget_callout = budget_callout;
10c3b2: 8b 45 28 mov 0x28(%ebp),%eax
10c3b5: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
switch ( budget_algorithm ) {
10c3bb: 83 7d 24 02 cmpl $0x2,0x24(%ebp)
10c3bf: 75 08 jne 10c3c9 <_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;
10c3c1: a1 10 53 12 00 mov 0x125310,%eax
10c3c6: 89 43 78 mov %eax,0x78(%ebx)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
10c3c9: 8b 45 2c mov 0x2c(%ebp),%eax
10c3cc: 89 83 ac 00 00 00 mov %eax,0xac(%ebx)
the_thread->current_state = STATES_DORMANT;
10c3d2: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10c3d9: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10c3e0: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->real_priority = priority;
10c3e7: 8b 45 1c mov 0x1c(%ebp),%eax
10c3ea: 89 43 18 mov %eax,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10c3ed: 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 );
10c3f3: 83 ec 0c sub $0xc,%esp
10c3f6: 53 push %ebx
10c3f7: ff 15 68 11 12 00 call *0x121168
10c3fd: 89 c2 mov %eax,%edx
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
10c3ff: 83 c4 10 add $0x10,%esp
10c402: 85 c0 test %eax,%eax
10c404: 74 51 je 10c457 <_Thread_Initialize+0x1c7>
goto failed;
_Thread_Set_priority( the_thread, priority );
10c406: 51 push %ecx
10c407: 51 push %ecx
10c408: ff 75 1c pushl 0x1c(%ebp)
10c40b: 53 push %ebx
10c40c: 89 45 e0 mov %eax,-0x20(%ebp)
10c40f: e8 40 05 00 00 call 10c954 <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
10c414: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10c41b: 00 00 00
10c41e: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10c425: 00 00 00
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
10c428: 8b 45 08 mov 0x8(%ebp),%eax
10c42b: 8b 40 1c mov 0x1c(%eax),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c42e: 0f b7 4b 08 movzwl 0x8(%ebx),%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c432: 89 1c 88 mov %ebx,(%eax,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c435: 8b 45 30 mov 0x30(%ebp),%eax
10c438: 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 );
10c43b: 89 1c 24 mov %ebx,(%esp)
10c43e: e8 e9 08 00 00 call 10cd2c <_User_extensions_Thread_create>
10c443: 88 c1 mov %al,%cl
if ( extension_status )
10c445: 83 c4 10 add $0x10,%esp
return true;
10c448: 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 )
10c44a: 84 c9 test %cl,%cl
10c44c: 8b 55 e0 mov -0x20(%ebp),%edx
10c44f: 74 06 je 10c457 <_Thread_Initialize+0x1c7>
10c451: eb 55 jmp 10c4a8 <_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;
10c453: 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;
10c455: 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 );
10c457: 83 ec 0c sub $0xc,%esp
10c45a: ff b3 e4 00 00 00 pushl 0xe4(%ebx)
10c460: 89 55 e0 mov %edx,-0x20(%ebp)
10c463: e8 fb 0b 00 00 call 10d063 <_Workspace_Free>
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
10c468: 5a pop %edx
10c469: ff b3 e8 00 00 00 pushl 0xe8(%ebx)
10c46f: e8 ef 0b 00 00 call 10d063 <_Workspace_Free>
10c474: 58 pop %eax
10c475: ff b3 ec 00 00 00 pushl 0xec(%ebx)
10c47b: e8 e3 0b 00 00 call 10d063 <_Workspace_Free>
_Workspace_Free( extensions_area );
10c480: 89 34 24 mov %esi,(%esp)
10c483: e8 db 0b 00 00 call 10d063 <_Workspace_Free>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
10c488: 89 3c 24 mov %edi,(%esp)
10c48b: e8 d3 0b 00 00 call 10d063 <_Workspace_Free>
#endif
_Workspace_Free( sched );
10c490: 8b 55 e0 mov -0x20(%ebp),%edx
10c493: 89 14 24 mov %edx,(%esp)
10c496: e8 c8 0b 00 00 call 10d063 <_Workspace_Free>
_Thread_Stack_Free( the_thread );
10c49b: 89 1c 24 mov %ebx,(%esp)
10c49e: e8 81 05 00 00 call 10ca24 <_Thread_Stack_Free>
return false;
10c4a3: 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 */
10c4a6: 31 c0 xor %eax,%eax
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
10c4a8: 8d 65 f4 lea -0xc(%ebp),%esp
10c4ab: 5b pop %ebx
10c4ac: 5e pop %esi
10c4ad: 5f pop %edi
10c4ae: c9 leave
10c4af: c3 ret
0010f6dc <_Thread_Resume>:
*/
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
10f6dc: 55 push %ebp
10f6dd: 89 e5 mov %esp,%ebp
10f6df: 53 push %ebx
10f6e0: 83 ec 04 sub $0x4,%esp
10f6e3: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10f6e6: 9c pushf
10f6e7: fa cli
10f6e8: 5b pop %ebx
current_state = the_thread->current_state;
10f6e9: 8b 50 10 mov 0x10(%eax),%edx
if ( current_state & STATES_SUSPENDED ) {
10f6ec: f6 c2 02 test $0x2,%dl
10f6ef: 74 17 je 10f708 <_Thread_Resume+0x2c> <== NEVER TAKEN
10f6f1: 83 e2 fd and $0xfffffffd,%edx
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
10f6f4: 89 50 10 mov %edx,0x10(%eax)
if ( _States_Is_ready( current_state ) ) {
10f6f7: 85 d2 test %edx,%edx
10f6f9: 75 0d jne 10f708 <_Thread_Resume+0x2c>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Thread_Control *the_thread
)
{
_Scheduler.Operations.unblock( the_thread );
10f6fb: 83 ec 0c sub $0xc,%esp
10f6fe: 50 push %eax
10f6ff: ff 15 64 41 12 00 call *0x124164
10f705: 83 c4 10 add $0x10,%esp
_Scheduler_Unblock( the_thread );
}
}
_ISR_Enable( level );
10f708: 53 push %ebx
10f709: 9d popf
}
10f70a: 8b 5d fc mov -0x4(%ebp),%ebx
10f70d: c9 leave
10f70e: c3 ret
0010cb0c <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10cb0c: 55 push %ebp
10cb0d: 89 e5 mov %esp,%ebp
10cb0f: 53 push %ebx
10cb10: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10cb13: 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 )
10cb19: 80 7b 74 00 cmpb $0x0,0x74(%ebx)
10cb1d: 74 4d je 10cb6c <_Thread_Tickle_timeslice+0x60>
return;
if ( !_States_Is_ready( executing->current_state ) )
10cb1f: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10cb23: 75 47 jne 10cb6c <_Thread_Tickle_timeslice+0x60>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10cb25: 8b 43 7c mov 0x7c(%ebx),%eax
10cb28: 83 f8 01 cmp $0x1,%eax
10cb2b: 72 3f jb 10cb6c <_Thread_Tickle_timeslice+0x60>
10cb2d: 83 f8 02 cmp $0x2,%eax
10cb30: 76 07 jbe 10cb39 <_Thread_Tickle_timeslice+0x2d>
10cb32: 83 f8 03 cmp $0x3,%eax
10cb35: 75 35 jne 10cb6c <_Thread_Tickle_timeslice+0x60><== NEVER TAKEN
10cb37: eb 1b jmp 10cb54 <_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 ) {
10cb39: 8b 43 78 mov 0x78(%ebx),%eax
10cb3c: 48 dec %eax
10cb3d: 89 43 78 mov %eax,0x78(%ebx)
10cb40: 85 c0 test %eax,%eax
10cb42: 7f 28 jg 10cb6c <_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();
10cb44: 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;
10cb4a: a1 10 53 12 00 mov 0x125310,%eax
10cb4f: 89 43 78 mov %eax,0x78(%ebx)
10cb52: eb 18 jmp 10cb6c <_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 )
10cb54: 8b 43 78 mov 0x78(%ebx),%eax
10cb57: 48 dec %eax
10cb58: 89 43 78 mov %eax,0x78(%ebx)
10cb5b: 85 c0 test %eax,%eax
10cb5d: 75 0d jne 10cb6c <_Thread_Tickle_timeslice+0x60>
(*executing->budget_callout)( executing );
10cb5f: 83 ec 0c sub $0xc,%esp
10cb62: 53 push %ebx
10cb63: ff 93 80 00 00 00 call *0x80(%ebx)
10cb69: 83 c4 10 add $0x10,%esp
break;
#endif
}
}
10cb6c: 8b 5d fc mov -0x4(%ebp),%ebx
10cb6f: c9 leave
10cb70: c3 ret
0010c6d0 <_Thread_queue_Enqueue_priority>:
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
10c6d0: 55 push %ebp
10c6d1: 89 e5 mov %esp,%ebp
10c6d3: 57 push %edi
10c6d4: 56 push %esi
10c6d5: 53 push %ebx
10c6d6: 83 ec 14 sub $0x14,%esp
10c6d9: 8b 4d 08 mov 0x8(%ebp),%ecx
10c6dc: 8b 45 0c mov 0xc(%ebp),%eax
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10c6df: 8d 50 3c lea 0x3c(%eax),%edx
10c6e2: 89 50 38 mov %edx,0x38(%eax)
head->next = tail;
head->previous = NULL;
10c6e5: c7 40 3c 00 00 00 00 movl $0x0,0x3c(%eax)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10c6ec: 8d 50 38 lea 0x38(%eax),%edx
10c6ef: 89 50 40 mov %edx,0x40(%eax)
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
10c6f2: 8b 58 14 mov 0x14(%eax),%ebx
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
10c6f5: 89 da mov %ebx,%edx
10c6f7: c1 ea 06 shr $0x6,%edx
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
10c6fa: 8b 71 38 mov 0x38(%ecx),%esi
10c6fd: 89 75 e8 mov %esi,-0x18(%ebp)
if ( _Thread_queue_Is_reverse_search( priority ) )
10c700: f6 c3 20 test $0x20,%bl
10c703: 75 77 jne 10c77c <_Thread_queue_Enqueue_priority+0xac>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10c705: 6b d2 0c imul $0xc,%edx,%edx
10c708: 8d 14 11 lea (%ecx,%edx,1),%edx
10c70b: 89 55 ec mov %edx,-0x14(%ebp)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
10c70e: 83 c2 04 add $0x4,%edx
10c711: 89 55 e4 mov %edx,-0x1c(%ebp)
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
10c714: 9c pushf
10c715: fa cli
10c716: 8f 45 f0 popl -0x10(%ebp)
10c719: 8b 75 f0 mov -0x10(%ebp),%esi
search_thread = (Thread_Control *) _Chain_First( header );
10c71c: 8b 7d ec mov -0x14(%ebp),%edi
10c71f: 8b 17 mov (%edi),%edx
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
10c721: 83 cf ff or $0xffffffff,%edi
10c724: 89 75 e0 mov %esi,-0x20(%ebp)
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
10c727: eb 1c jmp 10c745 <_Thread_queue_Enqueue_priority+0x75>
search_priority = search_thread->current_priority;
10c729: 8b 7a 14 mov 0x14(%edx),%edi
if ( priority <= search_priority )
10c72c: 39 fb cmp %edi,%ebx
10c72e: 76 1a jbe 10c74a <_Thread_queue_Enqueue_priority+0x7a>
break;
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
10c730: ff 75 f0 pushl -0x10(%ebp)
10c733: 9d popf
10c734: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10c735: 8b 75 e8 mov -0x18(%ebp),%esi
10c738: 85 72 10 test %esi,0x10(%edx)
10c73b: 75 06 jne 10c743 <_Thread_queue_Enqueue_priority+0x73>
_ISR_Enable( level );
10c73d: ff 75 f0 pushl -0x10(%ebp)
10c740: 9d popf
goto restart_forward_search;
10c741: eb d1 jmp 10c714 <_Thread_queue_Enqueue_priority+0x44>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
10c743: 8b 12 mov (%edx),%edx
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
10c745: 3b 55 e4 cmp -0x1c(%ebp),%edx
10c748: 75 df jne 10c729 <_Thread_queue_Enqueue_priority+0x59>
10c74a: 8b 75 e0 mov -0x20(%ebp),%esi
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
10c74d: 83 79 30 01 cmpl $0x1,0x30(%ecx)
10c751: 0f 85 b6 00 00 00 jne 10c80d <_Thread_queue_Enqueue_priority+0x13d>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10c757: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx)
if ( priority == search_priority )
10c75e: 39 fb cmp %edi,%ebx
10c760: 0f 84 90 00 00 00 je 10c7f6 <_Thread_queue_Enqueue_priority+0x126>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
10c766: 8b 5a 04 mov 0x4(%edx),%ebx
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10c769: 89 10 mov %edx,(%eax)
the_node->previous = previous_node;
10c76b: 89 58 04 mov %ebx,0x4(%eax)
previous_node->next = the_node;
10c76e: 89 03 mov %eax,(%ebx)
search_node->previous = the_node;
10c770: 89 42 04 mov %eax,0x4(%edx)
the_thread->Wait.queue = the_thread_queue;
10c773: 89 48 44 mov %ecx,0x44(%eax)
_ISR_Enable( level );
10c776: ff 75 f0 pushl -0x10(%ebp)
10c779: 9d popf
10c77a: eb 73 jmp 10c7ef <_Thread_queue_Enqueue_priority+0x11f>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10c77c: 6b d2 0c imul $0xc,%edx,%edx
10c77f: 8d 14 11 lea (%ecx,%edx,1),%edx
10c782: 89 55 ec mov %edx,-0x14(%ebp)
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
10c785: 0f b6 3d 24 12 12 00 movzbl 0x121224,%edi
10c78c: 47 inc %edi
10c78d: 89 7d e4 mov %edi,-0x1c(%ebp)
_ISR_Disable( level );
10c790: 9c pushf
10c791: fa cli
10c792: 8f 45 f0 popl -0x10(%ebp)
10c795: 8b 75 f0 mov -0x10(%ebp),%esi
search_thread = (Thread_Control *) _Chain_Last( header );
10c798: 8b 7d ec mov -0x14(%ebp),%edi
10c79b: 8b 57 08 mov 0x8(%edi),%edx
10c79e: 8b 7d e4 mov -0x1c(%ebp),%edi
10c7a1: 89 75 e4 mov %esi,-0x1c(%ebp)
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
10c7a4: eb 1d jmp 10c7c3 <_Thread_queue_Enqueue_priority+0xf3>
search_priority = search_thread->current_priority;
10c7a6: 8b 7a 14 mov 0x14(%edx),%edi
if ( priority >= search_priority )
10c7a9: 39 fb cmp %edi,%ebx
10c7ab: 73 1b jae 10c7c8 <_Thread_queue_Enqueue_priority+0xf8>
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
10c7ad: ff 75 f0 pushl -0x10(%ebp)
10c7b0: 9d popf
10c7b1: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10c7b2: 8b 75 e8 mov -0x18(%ebp),%esi
10c7b5: 85 72 10 test %esi,0x10(%edx)
10c7b8: 75 06 jne 10c7c0 <_Thread_queue_Enqueue_priority+0xf0><== ALWAYS TAKEN
_ISR_Enable( level );
10c7ba: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED
10c7bd: 9d popf <== NOT EXECUTED
goto restart_reverse_search;
10c7be: eb c5 jmp 10c785 <_Thread_queue_Enqueue_priority+0xb5><== NOT EXECUTED
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
10c7c0: 8b 52 04 mov 0x4(%edx),%edx
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
10c7c3: 3b 55 ec cmp -0x14(%ebp),%edx
10c7c6: 75 de jne 10c7a6 <_Thread_queue_Enqueue_priority+0xd6>
10c7c8: 8b 75 e4 mov -0x1c(%ebp),%esi
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
10c7cb: 83 79 30 01 cmpl $0x1,0x30(%ecx)
10c7cf: 75 3c jne 10c80d <_Thread_queue_Enqueue_priority+0x13d>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10c7d1: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx)
if ( priority == search_priority )
10c7d8: 39 fb cmp %edi,%ebx
10c7da: 74 1a je 10c7f6 <_Thread_queue_Enqueue_priority+0x126>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
10c7dc: 8b 1a mov (%edx),%ebx
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
10c7de: 89 18 mov %ebx,(%eax)
the_node->previous = search_node;
10c7e0: 89 50 04 mov %edx,0x4(%eax)
search_node->next = the_node;
10c7e3: 89 02 mov %eax,(%edx)
next_node->previous = the_node;
10c7e5: 89 43 04 mov %eax,0x4(%ebx)
the_thread->Wait.queue = the_thread_queue;
10c7e8: 89 48 44 mov %ecx,0x44(%eax)
_ISR_Enable( level );
10c7eb: ff 75 f0 pushl -0x10(%ebp)
10c7ee: 9d popf
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10c7ef: b8 01 00 00 00 mov $0x1,%eax
10c7f4: eb 1f jmp 10c815 <_Thread_queue_Enqueue_priority+0x145>
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
10c7f6: 8b 5a 40 mov 0x40(%edx),%ebx
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
10c7f9: 8d 7a 3c lea 0x3c(%edx),%edi
10c7fc: 89 38 mov %edi,(%eax)
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
10c7fe: 89 58 04 mov %ebx,0x4(%eax)
previous_node->next = the_node;
10c801: 89 03 mov %eax,(%ebx)
search_node->previous = the_node;
10c803: 89 42 40 mov %eax,0x40(%edx)
the_thread->Wait.queue = the_thread_queue;
10c806: 89 48 44 mov %ecx,0x44(%eax)
_ISR_Enable( level );
10c809: 56 push %esi
10c80a: 9d popf
10c80b: eb e2 jmp 10c7ef <_Thread_queue_Enqueue_priority+0x11f>
* For example, the blocking thread could have been given
* the mutex by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
10c80d: 8b 45 10 mov 0x10(%ebp),%eax
10c810: 89 30 mov %esi,(%eax)
return the_thread_queue->sync_state;
10c812: 8b 41 30 mov 0x30(%ecx),%eax
}
10c815: 83 c4 14 add $0x14,%esp
10c818: 5b pop %ebx
10c819: 5e pop %esi
10c81a: 5f pop %edi
10c81b: c9 leave
10c81c: c3 ret
0010c8cc <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10c8cc: 55 push %ebp
10c8cd: 89 e5 mov %esp,%ebp
10c8cf: 57 push %edi
10c8d0: 56 push %esi
10c8d1: 53 push %ebx
10c8d2: 83 ec 1c sub $0x1c,%esp
10c8d5: 8b 75 08 mov 0x8(%ebp),%esi
10c8d8: 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 )
10c8db: 85 f6 test %esi,%esi
10c8dd: 74 36 je 10c915 <_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 ) {
10c8df: 83 7e 34 01 cmpl $0x1,0x34(%esi)
10c8e3: 75 30 jne 10c915 <_Thread_queue_Requeue+0x49><== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
10c8e5: 9c pushf
10c8e6: fa cli
10c8e7: 5b pop %ebx
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10c8e8: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi)
10c8ef: 74 22 je 10c913 <_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;
10c8f1: 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 );
10c8f8: 50 push %eax
10c8f9: 6a 01 push $0x1
10c8fb: 57 push %edi
10c8fc: 56 push %esi
10c8fd: e8 12 31 00 00 call 10fa14 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10c902: 83 c4 0c add $0xc,%esp
10c905: 8d 45 e4 lea -0x1c(%ebp),%eax
10c908: 50 push %eax
10c909: 57 push %edi
10c90a: 56 push %esi
10c90b: e8 c0 fd ff ff call 10c6d0 <_Thread_queue_Enqueue_priority>
10c910: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10c913: 53 push %ebx
10c914: 9d popf
}
}
10c915: 8d 65 f4 lea -0xc(%ebp),%esp
10c918: 5b pop %ebx
10c919: 5e pop %esi
10c91a: 5f pop %edi
10c91b: c9 leave
10c91c: c3 ret
0010c920 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10c920: 55 push %ebp
10c921: 89 e5 mov %esp,%ebp
10c923: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10c926: 8d 45 f4 lea -0xc(%ebp),%eax
10c929: 50 push %eax
10c92a: ff 75 08 pushl 0x8(%ebp)
10c92d: e8 ea f8 ff ff call 10c21c <_Thread_Get>
switch ( location ) {
10c932: 83 c4 10 add $0x10,%esp
10c935: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10c939: 75 17 jne 10c952 <_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 );
10c93b: 83 ec 0c sub $0xc,%esp
10c93e: 50 push %eax
10c93f: e8 88 31 00 00 call 10facc <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10c944: a1 40 53 12 00 mov 0x125340,%eax
10c949: 48 dec %eax
10c94a: a3 40 53 12 00 mov %eax,0x125340
10c94f: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10c952: c9 leave
10c953: c3 ret
001169c4 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
1169c4: 55 push %ebp
1169c5: 89 e5 mov %esp,%ebp
1169c7: 57 push %edi
1169c8: 56 push %esi
1169c9: 53 push %ebx
1169ca: 83 ec 4c sub $0x4c,%esp
1169cd: 8b 5d 08 mov 0x8(%ebp),%ebx
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
1169d0: 8d 55 dc lea -0x24(%ebp),%edx
1169d3: 8d 45 e0 lea -0x20(%ebp),%eax
1169d6: 89 45 dc mov %eax,-0x24(%ebp)
head->previous = NULL;
1169d9: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
tail->previous = head;
1169e0: 89 55 e4 mov %edx,-0x1c(%ebp)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
1169e3: 8d 7d d0 lea -0x30(%ebp),%edi
1169e6: 8d 4d d4 lea -0x2c(%ebp),%ecx
1169e9: 89 4d d0 mov %ecx,-0x30(%ebp)
head->previous = NULL;
1169ec: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
tail->previous = head;
1169f3: 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 );
1169f6: 8d 53 30 lea 0x30(%ebx),%edx
1169f9: 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 );
1169fc: 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;
1169ff: 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;
116a02: 8d 4d dc lea -0x24(%ebp),%ecx
116a05: 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;
116a08: a1 e8 f0 13 00 mov 0x13f0e8,%eax
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
116a0d: 8b 53 3c mov 0x3c(%ebx),%edx
watchdogs->last_snapshot = snapshot;
116a10: 89 43 3c mov %eax,0x3c(%ebx)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
116a13: 51 push %ecx
116a14: 57 push %edi
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
116a15: 29 d0 sub %edx,%eax
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
116a17: 50 push %eax
116a18: ff 75 c0 pushl -0x40(%ebp)
116a1b: e8 d4 39 00 00 call 11a3f4 <_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();
116a20: a1 60 f0 13 00 mov 0x13f060,%eax
116a25: 89 45 c4 mov %eax,-0x3c(%ebp)
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
116a28: 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 ) {
116a2b: 83 c4 10 add $0x10,%esp
116a2e: 39 45 c4 cmp %eax,-0x3c(%ebp)
116a31: 76 10 jbe 116a43 <_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 );
116a33: 52 push %edx
116a34: 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;
116a35: 8b 55 c4 mov -0x3c(%ebp),%edx
116a38: 29 c2 sub %eax,%edx
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
116a3a: 52 push %edx
116a3b: 56 push %esi
116a3c: e8 b3 39 00 00 call 11a3f4 <_Watchdog_Adjust_to_chain>
116a41: eb 0f jmp 116a52 <_Timer_server_Body+0x8e>
} else if ( snapshot < last_snapshot ) {
116a43: 73 10 jae 116a55 <_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 );
116a45: 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;
116a46: 2b 45 c4 sub -0x3c(%ebp),%eax
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
116a49: 50 push %eax
116a4a: 6a 01 push $0x1
116a4c: 56 push %esi
116a4d: e8 36 39 00 00 call 11a388 <_Watchdog_Adjust>
116a52: 83 c4 10 add $0x10,%esp
}
watchdogs->last_snapshot = snapshot;
116a55: 8b 4d c4 mov -0x3c(%ebp),%ecx
116a58: 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 );
116a5b: 8b 43 78 mov 0x78(%ebx),%eax
116a5e: 83 ec 0c sub $0xc,%esp
116a61: 50 push %eax
116a62: e8 fd 08 00 00 call 117364 <_Chain_Get>
if ( timer == NULL ) {
116a67: 83 c4 10 add $0x10,%esp
116a6a: 85 c0 test %eax,%eax
116a6c: 74 29 je 116a97 <_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 ) {
116a6e: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED
116a71: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED
116a74: 75 0b jne 116a81 <_Timer_server_Body+0xbd><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116a76: 52 push %edx <== NOT EXECUTED
116a77: 52 push %edx <== NOT EXECUTED
116a78: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
116a7b: 50 push %eax <== NOT EXECUTED
116a7c: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED
116a7f: eb 0c jmp 116a8d <_Timer_server_Body+0xc9><== NOT EXECUTED
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116a81: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
116a84: 75 d5 jne 116a5b <_Timer_server_Body+0x97><== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116a86: 51 push %ecx <== NOT EXECUTED
116a87: 51 push %ecx <== NOT EXECUTED
116a88: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
116a8b: 50 push %eax <== NOT EXECUTED
116a8c: 56 push %esi <== NOT EXECUTED
116a8d: e8 ea 39 00 00 call 11a47c <_Watchdog_Insert> <== NOT EXECUTED
116a92: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
116a95: eb c4 jmp 116a5b <_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 );
116a97: 9c pushf
116a98: fa cli
116a99: 5a pop %edx
tmp = ts->insert_chain;
116a9a: 8b 43 78 mov 0x78(%ebx),%eax
if ( _Chain_Is_empty( insert_chain ) ) {
116a9d: b0 01 mov $0x1,%al
116a9f: 8b 4d b4 mov -0x4c(%ebp),%ecx
116aa2: 39 4d dc cmp %ecx,-0x24(%ebp)
116aa5: 75 09 jne 116ab0 <_Timer_server_Body+0xec><== NEVER TAKEN
ts->insert_chain = NULL;
116aa7: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx)
do_loop = false;
116aae: 31 c0 xor %eax,%eax
}
_ISR_Enable( level );
116ab0: 52 push %edx
116ab1: 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 ) {
116ab2: 84 c0 test %al,%al
116ab4: 0f 85 4e ff ff ff jne 116a08 <_Timer_server_Body+0x44><== NEVER TAKEN
116aba: 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 ) ) {
116abd: 39 45 d0 cmp %eax,-0x30(%ebp)
116ac0: 74 3a je 116afc <_Timer_server_Body+0x138>
116ac2: 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 );
116ac5: 9c pushf
116ac6: fa cli
116ac7: 59 pop %ecx
initialized = false;
}
#endif
return status;
}
116ac8: 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))
116acb: 3b 45 b0 cmp -0x50(%ebp),%eax
116ace: 74 25 je 116af5 <_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;
116ad0: 8b 10 mov (%eax),%edx
head->next = new_first;
116ad2: 89 55 d0 mov %edx,-0x30(%ebp)
new_first->previous = head;
116ad5: 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 ) {
116ad8: 85 c0 test %eax,%eax
116ada: 74 19 je 116af5 <_Timer_server_Body+0x131><== NEVER TAKEN
watchdog->state = WATCHDOG_INACTIVE;
116adc: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
_ISR_Enable( level );
116ae3: 51 push %ecx
116ae4: 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 );
116ae5: 52 push %edx
116ae6: 52 push %edx
116ae7: ff 70 24 pushl 0x24(%eax)
116aea: ff 70 20 pushl 0x20(%eax)
116aed: ff 50 1c call *0x1c(%eax)
}
116af0: 83 c4 10 add $0x10,%esp
116af3: eb d0 jmp 116ac5 <_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 );
116af5: 51 push %ecx
116af6: 9d popf
116af7: e9 06 ff ff ff jmp 116a02 <_Timer_server_Body+0x3e>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
116afc: c6 43 7c 00 movb $0x0,0x7c(%ebx)
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
116b00: e8 23 fe ff ff call 116928 <_Thread_Disable_dispatch>
_Thread_Set_state( ts->thread, STATES_DELAYING );
116b05: 51 push %ecx
116b06: 51 push %ecx
116b07: 6a 08 push $0x8
116b09: ff 33 pushl (%ebx)
116b0b: e8 18 33 00 00 call 119e28 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
116b10: 89 d8 mov %ebx,%eax
116b12: e8 21 fe ff ff call 116938 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
116b17: 89 d8 mov %ebx,%eax
116b19: e8 60 fe ff ff call 11697e <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
116b1e: e8 db 2a 00 00 call 1195fe <_Thread_Enable_dispatch>
ts->active = true;
116b23: 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 );
116b27: 8d 43 08 lea 0x8(%ebx),%eax
116b2a: 89 04 24 mov %eax,(%esp)
116b2d: e8 6a 3a 00 00 call 11a59c <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
116b32: 8d 43 40 lea 0x40(%ebx),%eax
116b35: 89 04 24 mov %eax,(%esp)
116b38: e8 5f 3a 00 00 call 11a59c <_Watchdog_Remove>
116b3d: 83 c4 10 add $0x10,%esp
116b40: e9 bd fe ff ff jmp 116a02 <_Timer_server_Body+0x3e>
00116b45 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
116b45: 55 push %ebp
116b46: 89 e5 mov %esp,%ebp
116b48: 57 push %edi
116b49: 56 push %esi
116b4a: 53 push %ebx
116b4b: 83 ec 2c sub $0x2c,%esp
116b4e: 8b 5d 08 mov 0x8(%ebp),%ebx
116b51: 8b 75 0c mov 0xc(%ebp),%esi
if ( ts->insert_chain == NULL ) {
116b54: 8b 43 78 mov 0x78(%ebx),%eax
116b57: 85 c0 test %eax,%eax
116b59: 0f 85 de 00 00 00 jne 116c3d <_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();
116b5f: e8 c4 fd ff ff call 116928 <_Thread_Disable_dispatch>
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
116b64: 8b 46 38 mov 0x38(%esi),%eax
116b67: 83 f8 01 cmp $0x1,%eax
116b6a: 75 5a jne 116bc6 <_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 );
116b6c: 9c pushf
116b6d: fa cli
116b6e: 8f 45 e0 popl -0x20(%ebp)
snapshot = _Watchdog_Ticks_since_boot;
116b71: 8b 15 e8 f0 13 00 mov 0x13f0e8,%edx
last_snapshot = ts->Interval_watchdogs.last_snapshot;
116b77: 8b 4b 3c mov 0x3c(%ebx),%ecx
initialized = false;
}
#endif
return status;
}
116b7a: 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 );
116b7d: 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 ) ) {
116b80: 39 f8 cmp %edi,%eax
116b82: 74 19 je 116b9d <_Timer_server_Schedule_operation_method+0x58>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
116b84: 89 d7 mov %edx,%edi
116b86: 29 cf sub %ecx,%edi
116b88: 89 7d e4 mov %edi,-0x1c(%ebp)
delta_interval = first_watchdog->delta_interval;
116b8b: 8b 78 10 mov 0x10(%eax),%edi
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116b8e: 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) {
116b90: 3b 7d e4 cmp -0x1c(%ebp),%edi
116b93: 76 05 jbe 116b9a <_Timer_server_Schedule_operation_method+0x55>
delta_interval -= delta;
116b95: 89 f9 mov %edi,%ecx
116b97: 2b 4d e4 sub -0x1c(%ebp),%ecx
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
116b9a: 89 48 10 mov %ecx,0x10(%eax)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
116b9d: 89 53 3c mov %edx,0x3c(%ebx)
_ISR_Enable( level );
116ba0: ff 75 e0 pushl -0x20(%ebp)
116ba3: 9d popf
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116ba4: 50 push %eax
116ba5: 50 push %eax
116ba6: 83 c6 10 add $0x10,%esi
116ba9: 56 push %esi
116baa: 8d 43 30 lea 0x30(%ebx),%eax
116bad: 50 push %eax
116bae: e8 c9 38 00 00 call 11a47c <_Watchdog_Insert>
if ( !ts->active ) {
116bb3: 8a 43 7c mov 0x7c(%ebx),%al
116bb6: 83 c4 10 add $0x10,%esp
116bb9: 84 c0 test %al,%al
116bbb: 75 74 jne 116c31 <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_interval_system_watchdog( ts );
116bbd: 89 d8 mov %ebx,%eax
116bbf: e8 74 fd ff ff call 116938 <_Timer_server_Reset_interval_system_watchdog>
116bc4: eb 6b jmp 116c31 <_Timer_server_Schedule_operation_method+0xec>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116bc6: 83 f8 03 cmp $0x3,%eax
116bc9: 75 66 jne 116c31 <_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 );
116bcb: 9c pushf
116bcc: fa cli
116bcd: 8f 45 e0 popl -0x20(%ebp)
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
116bd0: 8b 15 60 f0 13 00 mov 0x13f060,%edx
last_snapshot = ts->TOD_watchdogs.last_snapshot;
116bd6: 8b 43 74 mov 0x74(%ebx),%eax
initialized = false;
}
#endif
return status;
}
116bd9: 8b 4b 68 mov 0x68(%ebx),%ecx
116bdc: 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 ) ) {
116bdf: 39 f9 cmp %edi,%ecx
116be1: 74 27 je 116c0a <_Timer_server_Schedule_operation_method+0xc5>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
116be3: 8b 79 10 mov 0x10(%ecx),%edi
116be6: 89 7d d4 mov %edi,-0x2c(%ebp)
if ( snapshot > last_snapshot ) {
116be9: 39 c2 cmp %eax,%edx
116beb: 76 15 jbe 116c02 <_Timer_server_Schedule_operation_method+0xbd>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
116bed: 89 d7 mov %edx,%edi
116bef: 29 c7 sub %eax,%edi
116bf1: 89 7d e4 mov %edi,-0x1c(%ebp)
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116bf4: 31 c0 xor %eax,%eax
if ( snapshot > last_snapshot ) {
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
116bf6: 39 7d d4 cmp %edi,-0x2c(%ebp)
116bf9: 76 0c jbe 116c07 <_Timer_server_Schedule_operation_method+0xc2><== NEVER TAKEN
delta_interval -= delta;
116bfb: 8b 45 d4 mov -0x2c(%ebp),%eax
116bfe: 29 f8 sub %edi,%eax
116c00: eb 05 jmp 116c07 <_Timer_server_Schedule_operation_method+0xc2>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
116c02: 03 45 d4 add -0x2c(%ebp),%eax
delta_interval += delta;
116c05: 29 d0 sub %edx,%eax
}
first_watchdog->delta_interval = delta_interval;
116c07: 89 41 10 mov %eax,0x10(%ecx)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
116c0a: 89 53 74 mov %edx,0x74(%ebx)
_ISR_Enable( level );
116c0d: ff 75 e0 pushl -0x20(%ebp)
116c10: 9d popf
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116c11: 57 push %edi
116c12: 57 push %edi
116c13: 83 c6 10 add $0x10,%esi
116c16: 56 push %esi
116c17: 8d 43 68 lea 0x68(%ebx),%eax
116c1a: 50 push %eax
116c1b: e8 5c 38 00 00 call 11a47c <_Watchdog_Insert>
if ( !ts->active ) {
116c20: 8a 43 7c mov 0x7c(%ebx),%al
116c23: 83 c4 10 add $0x10,%esp
116c26: 84 c0 test %al,%al
116c28: 75 07 jne 116c31 <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_tod_system_watchdog( ts );
116c2a: 89 d8 mov %ebx,%eax
116c2c: e8 4d fd ff ff call 11697e <_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 );
}
}
116c31: 8d 65 f4 lea -0xc(%ebp),%esp
116c34: 5b pop %ebx
116c35: 5e pop %esi
116c36: 5f pop %edi
116c37: c9 leave
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
116c38: e9 c1 29 00 00 jmp 1195fe <_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 );
116c3d: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED
116c40: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED
116c43: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
}
116c46: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
116c49: 5b pop %ebx <== NOT EXECUTED
116c4a: 5e pop %esi <== NOT EXECUTED
116c4b: 5f pop %edi <== NOT EXECUTED
116c4c: 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 );
116c4d: e9 d6 06 00 00 jmp 117328 <_Chain_Append> <== NOT EXECUTED
0010ccef <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10ccef: 55 push %ebp
10ccf0: 89 e5 mov %esp,%ebp
10ccf2: 57 push %edi
10ccf3: 56 push %esi
10ccf4: 53 push %ebx
10ccf5: 83 ec 0c sub $0xc,%esp
10ccf8: 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 );
}
}
10ccfb: 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 );
10cd01: 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 );
10cd05: eb 15 jmp 10cd1c <_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 )
10cd07: 8b 43 30 mov 0x30(%ebx),%eax
10cd0a: 85 c0 test %eax,%eax
10cd0c: 74 0b je 10cd19 <_User_extensions_Fatal+0x2a>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10cd0e: 52 push %edx
10cd0f: 57 push %edi
10cd10: 56 push %esi
10cd11: ff 75 08 pushl 0x8(%ebp)
10cd14: ff d0 call *%eax
10cd16: 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 ) {
10cd19: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10cd1c: 81 fb 0c 55 12 00 cmp $0x12550c,%ebx
10cd22: 75 e3 jne 10cd07 <_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 );
}
}
10cd24: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10cd27: 5b pop %ebx <== NOT EXECUTED
10cd28: 5e pop %esi <== NOT EXECUTED
10cd29: 5f pop %edi <== NOT EXECUTED
10cd2a: c9 leave <== NOT EXECUTED
10cd2b: c3 ret <== NOT EXECUTED
0010cbd8 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
10cbd8: 55 push %ebp
10cbd9: 89 e5 mov %esp,%ebp
10cbdb: 57 push %edi
10cbdc: 56 push %esi
10cbdd: 53 push %ebx
10cbde: 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;
10cbe1: a1 60 12 12 00 mov 0x121260,%eax
10cbe6: 89 45 e4 mov %eax,-0x1c(%ebp)
initial_extensions = Configuration.User_extension_table;
10cbe9: 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;
10cbef: c7 05 0c 55 12 00 10 movl $0x125510,0x12550c
10cbf6: 55 12 00
head->previous = NULL;
10cbf9: c7 05 10 55 12 00 00 movl $0x0,0x125510
10cc00: 00 00 00
tail->previous = head;
10cc03: c7 05 14 55 12 00 0c movl $0x12550c,0x125514
10cc0a: 55 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10cc0d: c7 05 44 53 12 00 48 movl $0x125348,0x125344
10cc14: 53 12 00
head->previous = NULL;
10cc17: c7 05 48 53 12 00 00 movl $0x0,0x125348
10cc1e: 00 00 00
tail->previous = head;
10cc21: c7 05 4c 53 12 00 44 movl $0x125344,0x12534c
10cc28: 53 12 00
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10cc2b: 85 f6 test %esi,%esi
10cc2d: 74 53 je 10cc82 <_User_extensions_Handler_initialization+0xaa><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
10cc2f: 6b c8 34 imul $0x34,%eax,%ecx
10cc32: 83 ec 0c sub $0xc,%esp
10cc35: 51 push %ecx
10cc36: 89 4d e0 mov %ecx,-0x20(%ebp)
10cc39: e8 3d 04 00 00 call 10d07b <_Workspace_Allocate_or_fatal_error>
10cc3e: 89 c3 mov %eax,%ebx
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10cc40: 31 c0 xor %eax,%eax
10cc42: 8b 4d e0 mov -0x20(%ebp),%ecx
10cc45: 89 df mov %ebx,%edi
10cc47: f3 aa rep stos %al,%es:(%edi)
10cc49: 89 f0 mov %esi,%eax
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cc4b: 83 c4 10 add $0x10,%esp
10cc4e: 31 d2 xor %edx,%edx
10cc50: eb 2b jmp 10cc7d <_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;
10cc52: 8d 7b 14 lea 0x14(%ebx),%edi
10cc55: 89 c6 mov %eax,%esi
10cc57: b9 08 00 00 00 mov $0x8,%ecx
10cc5c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10cc5e: 83 ec 0c sub $0xc,%esp
10cc61: 53 push %ebx
10cc62: 89 45 dc mov %eax,-0x24(%ebp)
10cc65: 89 55 e0 mov %edx,-0x20(%ebp)
10cc68: e8 47 2f 00 00 call 10fbb4 <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
10cc6d: 83 c3 34 add $0x34,%ebx
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cc70: 8b 55 e0 mov -0x20(%ebp),%edx
10cc73: 42 inc %edx
10cc74: 8b 45 dc mov -0x24(%ebp),%eax
10cc77: 83 c0 20 add $0x20,%eax
10cc7a: 83 c4 10 add $0x10,%esp
10cc7d: 3b 55 e4 cmp -0x1c(%ebp),%edx
10cc80: 72 d0 jb 10cc52 <_User_extensions_Handler_initialization+0x7a>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
10cc82: 8d 65 f4 lea -0xc(%ebp),%esp
10cc85: 5b pop %ebx
10cc86: 5e pop %esi
10cc87: 5f pop %edi
10cc88: c9 leave
10cc89: c3 ret
0010e54c <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
10e54c: 55 push %ebp
10e54d: 89 e5 mov %esp,%ebp
10e54f: 57 push %edi
10e550: 56 push %esi
10e551: 53 push %ebx
10e552: 83 ec 1c sub $0x1c,%esp
10e555: 8b 75 08 mov 0x8(%ebp),%esi
10e558: 8b 7d 0c mov 0xc(%ebp),%edi
10e55b: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
10e55e: 9c pushf
10e55f: fa cli
10e560: 58 pop %eax
}
}
_ISR_Enable( level );
}
10e561: 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 );
10e563: 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 ) ) {
10e566: 39 ca cmp %ecx,%edx
10e568: 74 44 je 10e5ae <_Watchdog_Adjust+0x62>
switch ( direction ) {
10e56a: 85 ff test %edi,%edi
10e56c: 74 3c je 10e5aa <_Watchdog_Adjust+0x5e>
10e56e: 4f dec %edi
10e56f: 75 3d jne 10e5ae <_Watchdog_Adjust+0x62> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
10e571: 01 5a 10 add %ebx,0x10(%edx)
break;
10e574: eb 38 jmp 10e5ae <_Watchdog_Adjust+0x62>
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
10e576: 8b 16 mov (%esi),%edx
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
10e578: 8b 7a 10 mov 0x10(%edx),%edi
10e57b: 39 fb cmp %edi,%ebx
10e57d: 73 07 jae 10e586 <_Watchdog_Adjust+0x3a>
_Watchdog_First( header )->delta_interval -= units;
10e57f: 29 df sub %ebx,%edi
10e581: 89 7a 10 mov %edi,0x10(%edx)
break;
10e584: eb 28 jmp 10e5ae <_Watchdog_Adjust+0x62>
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
10e586: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx)
_ISR_Enable( level );
10e58d: 50 push %eax
10e58e: 9d popf
_Watchdog_Tickle( header );
10e58f: 83 ec 0c sub $0xc,%esp
10e592: 56 push %esi
10e593: 89 4d e4 mov %ecx,-0x1c(%ebp)
10e596: e8 a5 01 00 00 call 10e740 <_Watchdog_Tickle>
_ISR_Disable( level );
10e59b: 9c pushf
10e59c: fa cli
10e59d: 58 pop %eax
if ( _Chain_Is_empty( header ) )
10e59e: 83 c4 10 add $0x10,%esp
10e5a1: 8b 4d e4 mov -0x1c(%ebp),%ecx
10e5a4: 39 0e cmp %ecx,(%esi)
10e5a6: 74 06 je 10e5ae <_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;
10e5a8: 29 fb sub %edi,%ebx
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10e5aa: 85 db test %ebx,%ebx
10e5ac: 75 c8 jne 10e576 <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
10e5ae: 50 push %eax
10e5af: 9d popf
}
10e5b0: 8d 65 f4 lea -0xc(%ebp),%esp
10e5b3: 5b pop %ebx
10e5b4: 5e pop %esi
10e5b5: 5f pop %edi
10e5b6: c9 leave
10e5b7: c3 ret
0010cf30 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10cf30: 55 push %ebp
10cf31: 89 e5 mov %esp,%ebp
10cf33: 56 push %esi
10cf34: 53 push %ebx
10cf35: 8b 55 08 mov 0x8(%ebp),%edx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10cf38: 9c pushf
10cf39: fa cli
10cf3a: 5e pop %esi
previous_state = the_watchdog->state;
10cf3b: 8b 42 08 mov 0x8(%edx),%eax
switch ( previous_state ) {
10cf3e: 83 f8 01 cmp $0x1,%eax
10cf41: 74 09 je 10cf4c <_Watchdog_Remove+0x1c>
10cf43: 72 42 jb 10cf87 <_Watchdog_Remove+0x57>
10cf45: 83 f8 03 cmp $0x3,%eax
10cf48: 77 3d ja 10cf87 <_Watchdog_Remove+0x57> <== NEVER TAKEN
10cf4a: eb 09 jmp 10cf55 <_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;
10cf4c: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
break;
10cf53: eb 32 jmp 10cf87 <_Watchdog_Remove+0x57>
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10cf55: 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 );
}
10cf5c: 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) )
10cf5e: 83 39 00 cmpl $0x0,(%ecx)
10cf61: 74 06 je 10cf69 <_Watchdog_Remove+0x39>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10cf63: 8b 5a 10 mov 0x10(%edx),%ebx
10cf66: 01 59 10 add %ebx,0x10(%ecx)
if ( _Watchdog_Sync_count )
10cf69: 8b 1d 50 54 12 00 mov 0x125450,%ebx
10cf6f: 85 db test %ebx,%ebx
10cf71: 74 0c je 10cf7f <_Watchdog_Remove+0x4f>
_Watchdog_Sync_level = _ISR_Nest_level;
10cf73: 8b 1d 64 58 12 00 mov 0x125864,%ebx
10cf79: 89 1d e8 53 12 00 mov %ebx,0x1253e8
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10cf7f: 8b 5a 04 mov 0x4(%edx),%ebx
next->previous = previous;
10cf82: 89 59 04 mov %ebx,0x4(%ecx)
previous->next = next;
10cf85: 89 0b mov %ecx,(%ebx)
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10cf87: 8b 0d 54 54 12 00 mov 0x125454,%ecx
10cf8d: 89 4a 18 mov %ecx,0x18(%edx)
_ISR_Enable( level );
10cf90: 56 push %esi
10cf91: 9d popf
return( previous_state );
}
10cf92: 5b pop %ebx
10cf93: 5e pop %esi
10cf94: c9 leave
10cf95: c3 ret
0010e0bc <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
10e0bc: 55 push %ebp
10e0bd: 89 e5 mov %esp,%ebp
10e0bf: 57 push %edi
10e0c0: 56 push %esi
10e0c1: 53 push %ebx
10e0c2: 83 ec 20 sub $0x20,%esp
10e0c5: 8b 7d 08 mov 0x8(%ebp),%edi
10e0c8: 8b 75 0c mov 0xc(%ebp),%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
10e0cb: 9c pushf
10e0cc: fa cli
10e0cd: 8f 45 e4 popl -0x1c(%ebp)
printk( "Watchdog Chain: %s %p\n", name, header );
10e0d0: 56 push %esi
10e0d1: 57 push %edi
10e0d2: 68 9c 18 12 00 push $0x12189c
10e0d7: e8 50 aa ff ff call 108b2c <printk>
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
10e0dc: 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 );
10e0de: 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 ) ) {
10e0e1: 83 c4 10 add $0x10,%esp
10e0e4: 39 f3 cmp %esi,%ebx
10e0e6: 74 1d je 10e105 <_Watchdog_Report_chain+0x49>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
10e0e8: 52 push %edx
10e0e9: 52 push %edx
10e0ea: 53 push %ebx
10e0eb: 6a 00 push $0x0
10e0ed: e8 32 00 00 00 call 10e124 <_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 )
10e0f2: 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 ) ;
10e0f4: 83 c4 10 add $0x10,%esp
10e0f7: 39 f3 cmp %esi,%ebx
10e0f9: 75 ed jne 10e0e8 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
10e0fb: 50 push %eax
10e0fc: 50 push %eax
10e0fd: 57 push %edi
10e0fe: 68 b3 18 12 00 push $0x1218b3
10e103: eb 08 jmp 10e10d <_Watchdog_Report_chain+0x51>
} else {
printk( "Chain is empty\n" );
10e105: 83 ec 0c sub $0xc,%esp
10e108: 68 c2 18 12 00 push $0x1218c2
10e10d: e8 1a aa ff ff call 108b2c <printk>
10e112: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10e115: ff 75 e4 pushl -0x1c(%ebp)
10e118: 9d popf
}
10e119: 8d 65 f4 lea -0xc(%ebp),%esp
10e11c: 5b pop %ebx
10e11d: 5e pop %esi
10e11e: 5f pop %edi
10e11f: c9 leave
10e120: c3 ret
0010cf98 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
10cf98: 55 push %ebp
10cf99: 89 e5 mov %esp,%ebp
10cf9b: 57 push %edi
10cf9c: 56 push %esi
10cf9d: 53 push %ebx
10cf9e: 83 ec 1c sub $0x1c,%esp
10cfa1: 8b 7d 08 mov 0x8(%ebp),%edi
* See the comment in watchdoginsert.c and watchdogadjust.c
* about why it's safe not to declare header a pointer to
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
10cfa4: 9c pushf
10cfa5: fa cli
10cfa6: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10cfa7: 8b 1f mov (%edi),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10cfa9: 8d 47 04 lea 0x4(%edi),%eax
10cfac: 89 45 e4 mov %eax,-0x1c(%ebp)
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
10cfaf: 39 c3 cmp %eax,%ebx
10cfb1: 74 40 je 10cff3 <_Watchdog_Tickle+0x5b>
* to be inserted has already had its delta_interval adjusted to 0, and
* so is added to the head of the chain with a delta_interval of 0.
*
* Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)
*/
if (the_watchdog->delta_interval != 0) {
10cfb3: 8b 43 10 mov 0x10(%ebx),%eax
10cfb6: 85 c0 test %eax,%eax
10cfb8: 74 08 je 10cfc2 <_Watchdog_Tickle+0x2a>
the_watchdog->delta_interval--;
10cfba: 48 dec %eax
10cfbb: 89 43 10 mov %eax,0x10(%ebx)
if ( the_watchdog->delta_interval != 0 )
10cfbe: 85 c0 test %eax,%eax
10cfc0: 75 31 jne 10cff3 <_Watchdog_Tickle+0x5b>
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
10cfc2: 83 ec 0c sub $0xc,%esp
10cfc5: 53 push %ebx
10cfc6: e8 65 ff ff ff call 10cf30 <_Watchdog_Remove>
_ISR_Enable( level );
10cfcb: 56 push %esi
10cfcc: 9d popf
switch( watchdog_state ) {
10cfcd: 83 c4 10 add $0x10,%esp
10cfd0: 83 f8 02 cmp $0x2,%eax
10cfd3: 75 0e jne 10cfe3 <_Watchdog_Tickle+0x4b> <== NEVER TAKEN
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
10cfd5: 50 push %eax
10cfd6: 50 push %eax
10cfd7: ff 73 24 pushl 0x24(%ebx)
10cfda: ff 73 20 pushl 0x20(%ebx)
10cfdd: ff 53 1c call *0x1c(%ebx)
the_watchdog->id,
the_watchdog->user_data
);
break;
10cfe0: 83 c4 10 add $0x10,%esp
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
10cfe3: 9c pushf
10cfe4: fa cli
10cfe5: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10cfe6: 8b 1f mov (%edi),%ebx
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
10cfe8: 3b 5d e4 cmp -0x1c(%ebp),%ebx
10cfeb: 74 06 je 10cff3 <_Watchdog_Tickle+0x5b>
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
10cfed: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10cff1: eb cd jmp 10cfc0 <_Watchdog_Tickle+0x28>
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
10cff3: 56 push %esi
10cff4: 9d popf
}
10cff5: 8d 65 f4 lea -0xc(%ebp),%esp
10cff8: 5b pop %ebx
10cff9: 5e pop %esi
10cffa: 5f pop %edi
10cffb: c9 leave
10cffc: c3 ret
0010b21c <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
10b21c: 55 push %ebp
10b21d: 89 e5 mov %esp,%ebp
10b21f: 57 push %edi
10b220: 56 push %esi
10b221: 53 push %ebx
10b222: 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 );
10b225: ff 75 0c pushl 0xc(%ebp)
10b228: e8 3a ed ff ff call 109f67 <rtems_filesystem_dirname>
10b22d: 89 45 94 mov %eax,-0x6c(%ebp)
if ( old_parent_pathlen == 0 )
10b230: 83 c4 10 add $0x10,%esp
10b233: 85 c0 test %eax,%eax
10b235: 8d 45 b8 lea -0x48(%ebp),%eax
10b238: 75 15 jne 10b24f <_rename_r+0x33>
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
10b23a: 51 push %ecx
10b23b: 50 push %eax
10b23c: 8d 45 e4 lea -0x1c(%ebp),%eax
10b23f: 50 push %eax
10b240: ff 75 0c pushl 0xc(%ebp)
10b243: e8 48 03 00 00 call 10b590 <rtems_filesystem_get_start_loc>
10b248: 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;
10b24b: 31 db xor %ebx,%ebx
10b24d: eb 23 jmp 10b272 <_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,
10b24f: 83 ec 0c sub $0xc,%esp
10b252: 6a 00 push $0x0
10b254: 50 push %eax
10b255: 6a 02 push $0x2
10b257: ff 75 94 pushl -0x6c(%ebp)
10b25a: ff 75 0c pushl 0xc(%ebp)
10b25d: e8 c4 ec ff ff call 109f26 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
10b262: 83 c4 20 add $0x20,%esp
return -1;
10b265: 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 )
10b268: 85 c0 test %eax,%eax
10b26a: 0f 85 50 01 00 00 jne 10b3c0 <_rename_r+0x1a4> <== NEVER TAKEN
return -1;
free_old_parentloc = true;
10b270: b3 01 mov $0x1,%bl
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
10b272: 8d 7d cc lea -0x34(%ebp),%edi
10b275: 8d 75 b8 lea -0x48(%ebp),%esi
10b278: b9 05 00 00 00 mov $0x5,%ecx
10b27d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = old + old_parent_pathlen;
10b27f: 8b 75 0c mov 0xc(%ebp),%esi
10b282: 03 75 94 add -0x6c(%ebp),%esi
10b285: 89 75 e0 mov %esi,-0x20(%ebp)
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
10b288: 83 c9 ff or $0xffffffff,%ecx
10b28b: 89 f7 mov %esi,%edi
10b28d: 31 c0 xor %eax,%eax
10b28f: f2 ae repnz scas %es:(%edi),%al
10b291: f7 d1 not %ecx
10b293: 49 dec %ecx
10b294: 52 push %edx
10b295: 52 push %edx
10b296: 51 push %ecx
10b297: 56 push %esi
10b298: e8 09 ed ff ff call 109fa6 <rtems_filesystem_prefix_separators>
10b29d: 01 c6 add %eax,%esi
10b29f: 89 75 e0 mov %esi,-0x20(%ebp)
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
10b2a2: 83 c9 ff or $0xffffffff,%ecx
10b2a5: 89 f7 mov %esi,%edi
10b2a7: 31 c0 xor %eax,%eax
10b2a9: f2 ae repnz scas %es:(%edi),%al
10b2ab: f7 d1 not %ecx
10b2ad: 49 dec %ecx
10b2ae: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10b2b5: 8d 7d cc lea -0x34(%ebp),%edi
10b2b8: 57 push %edi
10b2b9: 6a 00 push $0x0
10b2bb: 51 push %ecx
10b2bc: 56 push %esi
10b2bd: e8 06 ec ff ff call 109ec8 <rtems_filesystem_evaluate_relative_path>
0, &old_loc, false );
if ( result != 0 ) {
10b2c2: 83 c4 20 add $0x20,%esp
10b2c5: 85 c0 test %eax,%eax
10b2c7: 74 16 je 10b2df <_rename_r+0xc3>
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
return -1;
10b2c9: 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 )
10b2cc: 84 db test %bl,%bl
10b2ce: 0f 84 ec 00 00 00 je 10b3c0 <_rename_r+0x1a4> <== NEVER TAKEN
rtems_filesystem_freenode( &old_parent_loc );
10b2d4: 83 ec 0c sub $0xc,%esp
10b2d7: 8d 45 b8 lea -0x48(%ebp),%eax
10b2da: e9 d8 00 00 00 jmp 10b3b7 <_rename_r+0x19b>
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
10b2df: 50 push %eax
10b2e0: 8d 75 a4 lea -0x5c(%ebp),%esi
10b2e3: 56 push %esi
10b2e4: 8d 45 e4 lea -0x1c(%ebp),%eax
10b2e7: 50 push %eax
10b2e8: ff 75 10 pushl 0x10(%ebp)
10b2eb: e8 a0 02 00 00 call 10b590 <rtems_filesystem_get_start_loc>
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
10b2f0: 83 c4 0c add $0xc,%esp
10b2f3: 8d 45 e0 lea -0x20(%ebp),%eax
10b2f6: 50 push %eax
10b2f7: 56 push %esi
10b2f8: 8b 45 10 mov 0x10(%ebp),%eax
10b2fb: 03 45 e4 add -0x1c(%ebp),%eax
10b2fe: 50 push %eax
10b2ff: 8b 45 b0 mov -0x50(%ebp),%eax
10b302: ff 50 04 call *0x4(%eax)
if ( result != 0 ) {
10b305: 83 c4 10 add $0x10,%esp
10b308: 85 c0 test %eax,%eax
10b30a: 74 2d je 10b339 <_rename_r+0x11d>
rtems_filesystem_freenode( &new_parent_loc );
10b30c: 83 ec 0c sub $0xc,%esp
10b30f: 56 push %esi
10b310: e8 1f ee ff ff call 10a134 <rtems_filesystem_freenode>
if ( free_old_parentloc )
10b315: 83 c4 10 add $0x10,%esp
10b318: 84 db test %bl,%bl
10b31a: 74 0f je 10b32b <_rename_r+0x10f> <== NEVER TAKEN
rtems_filesystem_freenode( &old_parent_loc );
10b31c: 83 ec 0c sub $0xc,%esp
10b31f: 8d 45 b8 lea -0x48(%ebp),%eax
10b322: 50 push %eax
10b323: e8 0c ee ff ff call 10a134 <rtems_filesystem_freenode>
10b328: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &old_loc );
10b32b: 83 ec 0c sub $0xc,%esp
10b32e: 8d 45 cc lea -0x34(%ebp),%eax
10b331: 50 push %eax
10b332: e8 fd ed ff ff call 10a134 <rtems_filesystem_freenode>
10b337: eb 3e jmp 10b377 <_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 ) {
10b339: 8b 45 b4 mov -0x4c(%ebp),%eax
10b33c: 39 45 c8 cmp %eax,-0x38(%ebp)
10b33f: 74 3e je 10b37f <_rename_r+0x163>
rtems_filesystem_freenode( &new_parent_loc );
10b341: 83 ec 0c sub $0xc,%esp
10b344: 56 push %esi
10b345: e8 ea ed ff ff call 10a134 <rtems_filesystem_freenode>
if ( free_old_parentloc )
10b34a: 83 c4 10 add $0x10,%esp
10b34d: 84 db test %bl,%bl
10b34f: 74 0f je 10b360 <_rename_r+0x144>
rtems_filesystem_freenode( &old_parent_loc );
10b351: 83 ec 0c sub $0xc,%esp
10b354: 8d 45 b8 lea -0x48(%ebp),%eax
10b357: 50 push %eax
10b358: e8 d7 ed ff ff call 10a134 <rtems_filesystem_freenode>
10b35d: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &old_loc );
10b360: 83 ec 0c sub $0xc,%esp
10b363: 8d 45 cc lea -0x34(%ebp),%eax
10b366: 50 push %eax
10b367: e8 c8 ed ff ff call 10a134 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
10b36c: e8 5f 95 00 00 call 1148d0 <__errno>
10b371: c7 00 12 00 00 00 movl $0x12,(%eax)
10b377: 83 c4 10 add $0x10,%esp
10b37a: 83 cf ff or $0xffffffff,%edi
10b37d: eb 41 jmp 10b3c0 <_rename_r+0x1a4>
}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
10b37f: ff 75 e0 pushl -0x20(%ebp)
10b382: 56 push %esi
10b383: 57 push %edi
10b384: 8d 55 b8 lea -0x48(%ebp),%edx
10b387: 52 push %edx
10b388: 8b 45 b0 mov -0x50(%ebp),%eax
10b38b: 89 55 90 mov %edx,-0x70(%ebp)
10b38e: ff 50 40 call *0x40(%eax)
10b391: 89 c7 mov %eax,%edi
rtems_filesystem_freenode( &new_parent_loc );
10b393: 89 34 24 mov %esi,(%esp)
10b396: e8 99 ed ff ff call 10a134 <rtems_filesystem_freenode>
if ( free_old_parentloc )
10b39b: 83 c4 10 add $0x10,%esp
10b39e: 84 db test %bl,%bl
10b3a0: 8b 55 90 mov -0x70(%ebp),%edx
10b3a3: 74 0c je 10b3b1 <_rename_r+0x195>
rtems_filesystem_freenode( &old_parent_loc );
10b3a5: 83 ec 0c sub $0xc,%esp
10b3a8: 52 push %edx
10b3a9: e8 86 ed ff ff call 10a134 <rtems_filesystem_freenode>
10b3ae: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &old_loc );
10b3b1: 83 ec 0c sub $0xc,%esp
10b3b4: 8d 45 cc lea -0x34(%ebp),%eax
10b3b7: 50 push %eax
10b3b8: e8 77 ed ff ff call 10a134 <rtems_filesystem_freenode>
return result;
10b3bd: 83 c4 10 add $0x10,%esp
}
10b3c0: 89 f8 mov %edi,%eax
10b3c2: 8d 65 f4 lea -0xc(%ebp),%esp
10b3c5: 5b pop %ebx
10b3c6: 5e pop %esi
10b3c7: 5f pop %edi
10b3c8: c9 leave
10b3c9: c3 ret
0010a818 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
10a818: 55 push %ebp
10a819: 89 e5 mov %esp,%ebp
10a81b: 57 push %edi
10a81c: 56 push %esi
10a81d: 53 push %ebx
10a81e: 83 ec 18 sub $0x18,%esp
10a821: 8b 75 08 mov 0x8(%ebp),%esi
10a824: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
10a827: 68 d8 72 12 00 push $0x1272d8
10a82c: e8 2f 10 00 00 call 10b860 <pthread_mutex_lock>
if (fcntl (fildes, F_GETFD) < 0) {
10a831: 5f pop %edi
10a832: 58 pop %eax
10a833: 6a 01 push $0x1
10a835: 56 push %esi
10a836: e8 f1 60 00 00 call 11092c <fcntl>
10a83b: 83 c4 10 add $0x10,%esp
10a83e: 85 c0 test %eax,%eax
10a840: 79 1d jns 10a85f <aio_cancel+0x47>
pthread_mutex_unlock(&aio_request_queue.mutex);
10a842: 83 ec 0c sub $0xc,%esp
10a845: 68 d8 72 12 00 push $0x1272d8
10a84a: e8 91 10 00 00 call 10b8e0 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
10a84f: e8 94 8e 00 00 call 1136e8 <__errno>
10a854: c7 00 09 00 00 00 movl $0x9,(%eax)
10a85a: e9 e3 00 00 00 jmp 10a942 <aio_cancel+0x12a>
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
10a85f: 85 db test %ebx,%ebx
10a861: 0f 85 bd 00 00 00 jne 10a924 <aio_cancel+0x10c>
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
10a867: 51 push %ecx
10a868: 6a 00 push $0x0
10a86a: 56 push %esi
10a86b: 68 20 73 12 00 push $0x127320
10a870: e8 27 03 00 00 call 10ab9c <rtems_aio_search_fd>
10a875: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10a877: 83 c4 10 add $0x10,%esp
10a87a: 85 c0 test %eax,%eax
10a87c: 75 6c jne 10a8ea <aio_cancel+0xd2>
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10a87e: 81 3d 2c 73 12 00 30 cmpl $0x127330,0x12732c
10a885: 73 12 00
10a888: 0f 84 07 01 00 00 je 10a995 <aio_cancel+0x17d> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10a88e: 52 push %edx
10a88f: 6a 00 push $0x0
10a891: 56 push %esi
10a892: 68 2c 73 12 00 push $0x12732c
10a897: e8 00 03 00 00 call 10ab9c <rtems_aio_search_fd>
10a89c: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10a89e: 83 c4 10 add $0x10,%esp
10a8a1: 85 c0 test %eax,%eax
10a8a3: 75 17 jne 10a8bc <aio_cancel+0xa4>
pthread_mutex_unlock(&aio_request_queue.mutex);
10a8a5: 83 ec 0c sub $0xc,%esp
10a8a8: 68 d8 72 12 00 push $0x1272d8
10a8ad: e8 2e 10 00 00 call 10b8e0 <pthread_mutex_unlock>
return AIO_ALLDONE;
10a8b2: 83 c4 10 add $0x10,%esp
10a8b5: b3 02 mov $0x2,%bl
10a8b7: e9 21 01 00 00 jmp 10a9dd <aio_cancel+0x1c5>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10a8bc: 83 ec 0c sub $0xc,%esp
10a8bf: 50 push %eax
10a8c0: e8 fb 26 00 00 call 10cfc0 <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10a8c5: 89 1c 24 mov %ebx,(%esp)
10a8c8: e8 12 06 00 00 call 10aedf <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
10a8cd: 8d 73 1c lea 0x1c(%ebx),%esi
10a8d0: 89 34 24 mov %esi,(%esp)
10a8d3: e8 68 0d 00 00 call 10b640 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
10a8d8: 89 34 24 mov %esi,(%esp)
10a8db: e8 6c 0a 00 00 call 10b34c <pthread_cond_destroy>
free (r_chain);
10a8e0: 89 1c 24 mov %ebx,(%esp)
10a8e3: e8 88 d4 ff ff call 107d70 <free>
10a8e8: eb 24 jmp 10a90e <aio_cancel+0xf6>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10a8ea: 8d 70 1c lea 0x1c(%eax),%esi
10a8ed: 83 ec 0c sub $0xc,%esp
10a8f0: 56 push %esi
10a8f1: e8 6a 0f 00 00 call 10b860 <pthread_mutex_lock>
10a8f6: 89 1c 24 mov %ebx,(%esp)
10a8f9: e8 c2 26 00 00 call 10cfc0 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10a8fe: 89 1c 24 mov %ebx,(%esp)
10a901: e8 d9 05 00 00 call 10aedf <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
10a906: 89 34 24 mov %esi,(%esp)
10a909: e8 d2 0f 00 00 call 10b8e0 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10a90e: c7 04 24 d8 72 12 00 movl $0x1272d8,(%esp)
10a915: e8 c6 0f 00 00 call 10b8e0 <pthread_mutex_unlock>
return AIO_CANCELED;
10a91a: 83 c4 10 add $0x10,%esp
10a91d: 31 db xor %ebx,%ebx
10a91f: e9 b9 00 00 00 jmp 10a9dd <aio_cancel+0x1c5>
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
10a924: 8b 3b mov (%ebx),%edi
10a926: 39 f7 cmp %esi,%edi
10a928: 74 23 je 10a94d <aio_cancel+0x135>
pthread_mutex_unlock (&aio_request_queue.mutex);
10a92a: 83 ec 0c sub $0xc,%esp
10a92d: 68 d8 72 12 00 push $0x1272d8
10a932: e8 a9 0f 00 00 call 10b8e0 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
10a937: e8 ac 8d 00 00 call 1136e8 <__errno>
10a93c: c7 00 16 00 00 00 movl $0x16,(%eax)
10a942: 83 c4 10 add $0x10,%esp
10a945: 83 cb ff or $0xffffffff,%ebx
10a948: e9 90 00 00 00 jmp 10a9dd <aio_cancel+0x1c5>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
10a94d: 50 push %eax
10a94e: 6a 00 push $0x0
10a950: 57 push %edi
10a951: 68 20 73 12 00 push $0x127320
10a956: e8 41 02 00 00 call 10ab9c <rtems_aio_search_fd>
10a95b: 89 c6 mov %eax,%esi
if (r_chain == NULL) {
10a95d: 83 c4 10 add $0x10,%esp
10a960: 85 c0 test %eax,%eax
10a962: 75 48 jne 10a9ac <aio_cancel+0x194>
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10a964: 81 3d 2c 73 12 00 30 cmpl $0x127330,0x12732c
10a96b: 73 12 00
10a96e: 74 25 je 10a995 <aio_cancel+0x17d> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10a970: 56 push %esi
10a971: 6a 00 push $0x0
10a973: 57 push %edi
10a974: 68 2c 73 12 00 push $0x12732c
10a979: e8 1e 02 00 00 call 10ab9c <rtems_aio_search_fd>
if (r_chain == NULL) {
10a97e: 83 c4 10 add $0x10,%esp
10a981: 85 c0 test %eax,%eax
10a983: 74 a5 je 10a92a <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);
10a985: 51 push %ecx
10a986: 51 push %ecx
10a987: 53 push %ebx
10a988: 83 c0 08 add $0x8,%eax
10a98b: 50 push %eax
10a98c: e8 97 05 00 00 call 10af28 <rtems_aio_remove_req>
10a991: 89 c3 mov %eax,%ebx
10a993: eb 39 jmp 10a9ce <aio_cancel+0x1b6>
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
10a995: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a998: 68 d8 72 12 00 push $0x1272d8 <== NOT EXECUTED
10a99d: e8 3e 0f 00 00 call 10b8e0 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
10a9a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a9a5: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED
10a9aa: eb 31 jmp 10a9dd <aio_cancel+0x1c5> <== NOT EXECUTED
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10a9ac: 8d 78 1c lea 0x1c(%eax),%edi
10a9af: 83 ec 0c sub $0xc,%esp
10a9b2: 57 push %edi
10a9b3: e8 a8 0e 00 00 call 10b860 <pthread_mutex_lock>
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
10a9b8: 58 pop %eax
10a9b9: 5a pop %edx
10a9ba: 53 push %ebx
10a9bb: 83 c6 08 add $0x8,%esi
10a9be: 56 push %esi
10a9bf: e8 64 05 00 00 call 10af28 <rtems_aio_remove_req>
10a9c4: 89 c3 mov %eax,%ebx
pthread_mutex_unlock (&r_chain->mutex);
10a9c6: 89 3c 24 mov %edi,(%esp)
10a9c9: e8 12 0f 00 00 call 10b8e0 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10a9ce: c7 04 24 d8 72 12 00 movl $0x1272d8,(%esp)
10a9d5: e8 06 0f 00 00 call 10b8e0 <pthread_mutex_unlock>
return result;
10a9da: 83 c4 10 add $0x10,%esp
}
return AIO_ALLDONE;
}
10a9dd: 89 d8 mov %ebx,%eax
10a9df: 8d 65 f4 lea -0xc(%ebp),%esp
10a9e2: 5b pop %ebx
10a9e3: 5e pop %esi
10a9e4: 5f pop %edi
10a9e5: c9 leave
10a9e6: c3 ret
0010a9f4 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
10a9f4: 55 push %ebp
10a9f5: 89 e5 mov %esp,%ebp
10a9f7: 53 push %ebx
10a9f8: 83 ec 04 sub $0x4,%esp
10a9fb: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
10a9fe: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp)
10aa05: 74 1b je 10aa22 <aio_fsync+0x2e>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10aa07: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10aa0e: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10aa15: e8 ce 8c 00 00 call 1136e8 <__errno>
10aa1a: c7 00 16 00 00 00 movl $0x16,(%eax)
10aa20: eb 74 jmp 10aa96 <aio_fsync+0xa2>
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10aa22: 50 push %eax
10aa23: 50 push %eax
10aa24: 6a 03 push $0x3
10aa26: ff 33 pushl (%ebx)
10aa28: e8 ff 5e 00 00 call 11092c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10aa2d: 83 e0 03 and $0x3,%eax
10aa30: 48 dec %eax
10aa31: 83 c4 10 add $0x10,%esp
10aa34: 83 f8 01 cmp $0x1,%eax
10aa37: 76 1b jbe 10aa54 <aio_fsync+0x60>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10aa39: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10aa40: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10aa47: e8 9c 8c 00 00 call 1136e8 <__errno>
10aa4c: c7 00 09 00 00 00 movl $0x9,(%eax)
10aa52: eb 42 jmp 10aa96 <aio_fsync+0xa2>
req = malloc (sizeof (rtems_aio_request));
10aa54: 83 ec 0c sub $0xc,%esp
10aa57: 6a 18 push $0x18
10aa59: e8 96 d7 ff ff call 1081f4 <malloc>
if (req == NULL)
10aa5e: 83 c4 10 add $0x10,%esp
10aa61: 85 c0 test %eax,%eax
10aa63: 75 1b jne 10aa80 <aio_fsync+0x8c> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10aa65: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10aa6c: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10aa73: e8 70 8c 00 00 call 1136e8 <__errno> <== NOT EXECUTED
10aa78: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10aa7e: eb 16 jmp 10aa96 <aio_fsync+0xa2> <== NOT EXECUTED
req->aiocbp = aiocbp;
10aa80: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_SYNC;
10aa83: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx)
return rtems_aio_enqueue (req);
10aa8a: 89 45 08 mov %eax,0x8(%ebp)
}
10aa8d: 8b 5d fc mov -0x4(%ebp),%ebx
10aa90: 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);
10aa91: e9 ef 04 00 00 jmp 10af85 <rtems_aio_enqueue>
}
10aa96: 83 c8 ff or $0xffffffff,%eax
10aa99: 8b 5d fc mov -0x4(%ebp),%ebx
10aa9c: c9 leave
10aa9d: c3 ret
0010b188 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
10b188: 55 push %ebp
10b189: 89 e5 mov %esp,%ebp
10b18b: 53 push %ebx
10b18c: 83 ec 0c sub $0xc,%esp
10b18f: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10b192: 6a 03 push $0x3
10b194: ff 33 pushl (%ebx)
10b196: e8 91 57 00 00 call 11092c <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10b19b: 83 e0 03 and $0x3,%eax
10b19e: 83 c4 10 add $0x10,%esp
10b1a1: 83 f8 02 cmp $0x2,%eax
10b1a4: 74 1f je 10b1c5 <aio_read+0x3d>
10b1a6: 85 c0 test %eax,%eax
10b1a8: 74 1b je 10b1c5 <aio_read+0x3d> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10b1aa: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10b1b1: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b1b8: e8 2b 85 00 00 call 1136e8 <__errno>
10b1bd: c7 00 09 00 00 00 movl $0x9,(%eax)
10b1c3: eb 69 jmp 10b22e <aio_read+0xa6>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10b1c5: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10b1c9: 75 06 jne 10b1d1 <aio_read+0x49>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10b1cb: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10b1cf: 79 1b jns 10b1ec <aio_read+0x64>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10b1d1: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10b1d8: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b1df: e8 04 85 00 00 call 1136e8 <__errno>
10b1e4: c7 00 16 00 00 00 movl $0x16,(%eax)
10b1ea: eb 42 jmp 10b22e <aio_read+0xa6>
req = malloc (sizeof (rtems_aio_request));
10b1ec: 83 ec 0c sub $0xc,%esp
10b1ef: 6a 18 push $0x18
10b1f1: e8 fe cf ff ff call 1081f4 <malloc>
if (req == NULL)
10b1f6: 83 c4 10 add $0x10,%esp
10b1f9: 85 c0 test %eax,%eax
10b1fb: 75 1b jne 10b218 <aio_read+0x90> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10b1fd: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10b204: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10b20b: e8 d8 84 00 00 call 1136e8 <__errno> <== NOT EXECUTED
10b210: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10b216: eb 16 jmp 10b22e <aio_read+0xa6> <== NOT EXECUTED
req->aiocbp = aiocbp;
10b218: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_READ;
10b21b: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx)
return rtems_aio_enqueue (req);
10b222: 89 45 08 mov %eax,0x8(%ebp)
}
10b225: 8b 5d fc mov -0x4(%ebp),%ebx
10b228: 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);
10b229: e9 57 fd ff ff jmp 10af85 <rtems_aio_enqueue>
}
10b22e: 83 c8 ff or $0xffffffff,%eax
10b231: 8b 5d fc mov -0x4(%ebp),%ebx
10b234: c9 leave
10b235: c3 ret
0010b244 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
10b244: 55 push %ebp
10b245: 89 e5 mov %esp,%ebp
10b247: 53 push %ebx
10b248: 83 ec 0c sub $0xc,%esp
10b24b: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10b24e: 6a 03 push $0x3
10b250: ff 33 pushl (%ebx)
10b252: e8 d5 56 00 00 call 11092c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10b257: 83 e0 03 and $0x3,%eax
10b25a: 48 dec %eax
10b25b: 83 c4 10 add $0x10,%esp
10b25e: 83 f8 01 cmp $0x1,%eax
10b261: 76 1b jbe 10b27e <aio_write+0x3a>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10b263: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10b26a: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b271: e8 72 84 00 00 call 1136e8 <__errno>
10b276: c7 00 09 00 00 00 movl $0x9,(%eax)
10b27c: eb 69 jmp 10b2e7 <aio_write+0xa3>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10b27e: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10b282: 75 06 jne 10b28a <aio_write+0x46>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10b284: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10b288: 79 1b jns 10b2a5 <aio_write+0x61>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10b28a: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10b291: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b298: e8 4b 84 00 00 call 1136e8 <__errno>
10b29d: c7 00 16 00 00 00 movl $0x16,(%eax)
10b2a3: eb 42 jmp 10b2e7 <aio_write+0xa3>
req = malloc (sizeof (rtems_aio_request));
10b2a5: 83 ec 0c sub $0xc,%esp
10b2a8: 6a 18 push $0x18
10b2aa: e8 45 cf ff ff call 1081f4 <malloc>
if (req == NULL)
10b2af: 83 c4 10 add $0x10,%esp
10b2b2: 85 c0 test %eax,%eax
10b2b4: 75 1b jne 10b2d1 <aio_write+0x8d> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10b2b6: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10b2bd: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10b2c4: e8 1f 84 00 00 call 1136e8 <__errno> <== NOT EXECUTED
10b2c9: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10b2cf: eb 16 jmp 10b2e7 <aio_write+0xa3> <== NOT EXECUTED
req->aiocbp = aiocbp;
10b2d1: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
10b2d4: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx)
return rtems_aio_enqueue (req);
10b2db: 89 45 08 mov %eax,0x8(%ebp)
}
10b2de: 8b 5d fc mov -0x4(%ebp),%ebx
10b2e1: 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);
10b2e2: e9 9e fc ff ff jmp 10af85 <rtems_aio_enqueue>
}
10b2e7: 83 c8 ff or $0xffffffff,%eax
10b2ea: 8b 5d fc mov -0x4(%ebp),%ebx
10b2ed: c9 leave
10b2ee: c3 ret
00107548 <chroot>:
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
107548: 55 push %ebp
107549: 89 e5 mov %esp,%ebp
10754b: 57 push %edi
10754c: 56 push %esi
10754d: 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) {
107550: 81 3d 6c 30 12 00 48 cmpl $0x125248,0x12306c
107557: 52 12 00
10755a: 75 1e jne 10757a <chroot+0x32>
rtems_libio_set_private_env(); /* try to set a new private env*/
10755c: e8 f0 10 00 00 call 108651 <rtems_libio_set_private_env>
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
107561: 81 3d 6c 30 12 00 48 cmpl $0x125248,0x12306c
107568: 52 12 00
10756b: 75 0d jne 10757a <chroot+0x32>
rtems_set_errno_and_return_minus_one( ENOTSUP );
10756d: e8 8e a3 00 00 call 111900 <__errno>
107572: c7 00 86 00 00 00 movl $0x86,(%eax)
107578: eb 22 jmp 10759c <chroot+0x54>
}
result = chdir(pathname);
10757a: 83 ec 0c sub $0xc,%esp
10757d: ff 75 08 pushl 0x8(%ebp)
107580: e8 b7 74 00 00 call 10ea3c <chdir>
if (result) {
107585: 83 c4 10 add $0x10,%esp
107588: 85 c0 test %eax,%eax
10758a: 74 15 je 1075a1 <chroot+0x59>
rtems_set_errno_and_return_minus_one( errno );
10758c: e8 6f a3 00 00 call 111900 <__errno>
107591: 89 c6 mov %eax,%esi
107593: e8 68 a3 00 00 call 111900 <__errno>
107598: 8b 00 mov (%eax),%eax
10759a: 89 06 mov %eax,(%esi)
10759c: 83 c8 ff or $0xffffffff,%eax
10759f: eb 44 jmp 1075e5 <chroot+0x9d>
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
1075a1: 83 ec 0c sub $0xc,%esp
1075a4: 6a 00 push $0x0
1075a6: 8d 75 e4 lea -0x1c(%ebp),%esi
1075a9: 56 push %esi
1075aa: 6a 00 push $0x0
1075ac: 6a 01 push $0x1
1075ae: 68 ea fc 11 00 push $0x11fcea
1075b3: e8 02 01 00 00 call 1076ba <rtems_filesystem_evaluate_path>
1075b8: 83 c4 20 add $0x20,%esp
1075bb: 85 c0 test %eax,%eax
1075bd: 75 cd jne 10758c <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);
1075bf: 83 ec 0c sub $0xc,%esp
1075c2: a1 6c 30 12 00 mov 0x12306c,%eax
1075c7: 83 c0 18 add $0x18,%eax
1075ca: 50 push %eax
1075cb: e8 a8 01 00 00 call 107778 <rtems_filesystem_freenode>
rtems_filesystem_root = loc;
1075d0: 8b 3d 6c 30 12 00 mov 0x12306c,%edi
1075d6: 83 c7 18 add $0x18,%edi
1075d9: b9 05 00 00 00 mov $0x5,%ecx
1075de: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
1075e0: 83 c4 10 add $0x10,%esp
1075e3: 31 c0 xor %eax,%eax
}
1075e5: 8d 65 f8 lea -0x8(%ebp),%esp
1075e8: 5e pop %esi
1075e9: 5f pop %edi
1075ea: c9 leave
1075eb: c3 ret
00109fec <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
109fec: 55 push %ebp
109fed: 89 e5 mov %esp,%ebp
109fef: 83 ec 08 sub $0x8,%esp
109ff2: 8b 45 08 mov 0x8(%ebp),%eax
109ff5: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
109ff8: 85 d2 test %edx,%edx
109ffa: 74 3c je 10a038 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
109ffc: 83 f8 01 cmp $0x1,%eax
109fff: 75 0b jne 10a00c <clock_gettime+0x20>
_TOD_Get(tp);
10a001: 83 ec 0c sub $0xc,%esp
10a004: 52 push %edx
10a005: e8 a6 1b 00 00 call 10bbb0 <_TOD_Get>
10a00a: eb 13 jmp 10a01f <clock_gettime+0x33>
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
10a00c: 83 f8 04 cmp $0x4,%eax
10a00f: 74 05 je 10a016 <clock_gettime+0x2a> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
10a011: 83 f8 02 cmp $0x2,%eax
10a014: 75 10 jne 10a026 <clock_gettime+0x3a>
_TOD_Get_uptime_as_timespec( tp );
10a016: 83 ec 0c sub $0xc,%esp
10a019: 52 push %edx
10a01a: e8 e5 1b 00 00 call 10bc04 <_TOD_Get_uptime_as_timespec>
return 0;
10a01f: 83 c4 10 add $0x10,%esp
10a022: 31 c0 xor %eax,%eax
10a024: eb 20 jmp 10a046 <clock_gettime+0x5a>
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
10a026: 83 f8 03 cmp $0x3,%eax
10a029: 75 0d jne 10a038 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( ENOSYS );
10a02b: e8 9c 7f 00 00 call 111fcc <__errno>
10a030: c7 00 58 00 00 00 movl $0x58,(%eax)
10a036: eb 0b jmp 10a043 <clock_gettime+0x57>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
10a038: e8 8f 7f 00 00 call 111fcc <__errno>
10a03d: c7 00 16 00 00 00 movl $0x16,(%eax)
10a043: 83 c8 ff or $0xffffffff,%eax
return 0;
}
10a046: c9 leave
10a047: c3 ret
0010a048 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
10a048: 55 push %ebp
10a049: 89 e5 mov %esp,%ebp
10a04b: 83 ec 08 sub $0x8,%esp
10a04e: 8b 45 08 mov 0x8(%ebp),%eax
10a051: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
10a054: 85 d2 test %edx,%edx
10a056: 74 44 je 10a09c <clock_settime+0x54> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10a058: 83 f8 01 cmp $0x1,%eax
10a05b: 75 28 jne 10a085 <clock_settime+0x3d>
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
10a05d: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx)
10a063: 76 37 jbe 10a09c <clock_settime+0x54>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a065: a1 a0 73 12 00 mov 0x1273a0,%eax
10a06a: 40 inc %eax
10a06b: a3 a0 73 12 00 mov %eax,0x1273a0
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
10a070: 83 ec 0c sub $0xc,%esp
10a073: 52 push %edx
10a074: e8 e3 1b 00 00 call 10bc5c <_TOD_Set>
_Thread_Enable_dispatch();
10a079: e8 38 2f 00 00 call 10cfb6 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
10a07e: 83 c4 10 add $0x10,%esp
10a081: 31 c0 xor %eax,%eax
10a083: eb 25 jmp 10a0aa <clock_settime+0x62>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
10a085: 83 f8 02 cmp $0x2,%eax
10a088: 74 05 je 10a08f <clock_settime+0x47>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
10a08a: 83 f8 03 cmp $0x3,%eax
10a08d: 75 0d jne 10a09c <clock_settime+0x54>
rtems_set_errno_and_return_minus_one( ENOSYS );
10a08f: e8 38 7f 00 00 call 111fcc <__errno>
10a094: c7 00 58 00 00 00 movl $0x58,(%eax)
10a09a: eb 0b jmp 10a0a7 <clock_settime+0x5f>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
10a09c: e8 2b 7f 00 00 call 111fcc <__errno>
10a0a1: c7 00 16 00 00 00 movl $0x16,(%eax)
10a0a7: 83 c8 ff or $0xffffffff,%eax
return 0;
}
10a0aa: c9 leave
10a0ab: c3 ret
0010d4d0 <devFS_evaluate_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
10d4d0: 55 push %ebp
10d4d1: 89 e5 mov %esp,%ebp
10d4d3: 57 push %edi
10d4d4: 56 push %esi
10d4d5: 53 push %ebx
10d4d6: 83 ec 1c sub $0x1c,%esp
10d4d9: 8b 4d 0c mov 0xc(%ebp),%ecx
10d4dc: 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 ) )
10d4df: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp)
10d4e6: 74 0d je 10d4f5 <devFS_evaluate_path+0x25><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
10d4e8: e8 53 22 00 00 call 10f740 <__errno> <== NOT EXECUTED
10d4ed: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10d4f3: eb 77 jmp 10d56c <devFS_evaluate_path+0x9c><== NOT EXECUTED
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
10d4f5: 8b 33 mov (%ebx),%esi
if (!device_name_table)
10d4f7: 85 f6 test %esi,%esi
10d4f9: 74 04 je 10d4ff <devFS_evaluate_path+0x2f>
10d4fb: 31 ff xor %edi,%edi
10d4fd: eb 5a jmp 10d559 <devFS_evaluate_path+0x89>
rtems_set_errno_and_return_minus_one( EFAULT );
10d4ff: e8 3c 22 00 00 call 10f740 <__errno>
10d504: c7 00 0e 00 00 00 movl $0xe,(%eax)
10d50a: eb 60 jmp 10d56c <devFS_evaluate_path+0x9c>
for (i = 0; i < rtems_device_table_size; i++) {
if (!device_name_table[i].device_name)
10d50c: 8b 16 mov (%esi),%edx
10d50e: 85 d2 test %edx,%edx
10d510: 74 43 je 10d555 <devFS_evaluate_path+0x85>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
10d512: 50 push %eax
10d513: 51 push %ecx
10d514: 52 push %edx
10d515: ff 75 08 pushl 0x8(%ebp)
10d518: 89 55 e4 mov %edx,-0x1c(%ebp)
10d51b: 89 4d e0 mov %ecx,-0x20(%ebp)
10d51e: e8 f1 2e 00 00 call 110414 <strncmp>
10d523: 83 c4 10 add $0x10,%esp
10d526: 85 c0 test %eax,%eax
10d528: 8b 55 e4 mov -0x1c(%ebp),%edx
10d52b: 8b 4d e0 mov -0x20(%ebp),%ecx
10d52e: 75 25 jne 10d555 <devFS_evaluate_path+0x85>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
10d530: 80 3c 0a 00 cmpb $0x0,(%edx,%ecx,1)
10d534: 75 1f jne 10d555 <devFS_evaluate_path+0x85><== NEVER TAKEN
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
10d536: 89 33 mov %esi,(%ebx)
pathloc->handlers = &devFS_file_handlers;
10d538: c7 43 08 ac 0f 12 00 movl $0x120fac,0x8(%ebx)
pathloc->ops = &devFS_ops;
10d53f: c7 43 0c 64 0f 12 00 movl $0x120f64,0xc(%ebx)
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
10d546: a1 00 11 12 00 mov 0x121100,%eax
10d54b: 8b 40 28 mov 0x28(%eax),%eax
10d54e: 89 43 10 mov %eax,0x10(%ebx)
return 0;
10d551: 31 c0 xor %eax,%eax
10d553: eb 1a jmp 10d56f <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++) {
10d555: 47 inc %edi
10d556: 83 c6 14 add $0x14,%esi
10d559: 3b 3d 48 f1 11 00 cmp 0x11f148,%edi
10d55f: 72 ab jb 10d50c <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 );
10d561: e8 da 21 00 00 call 10f740 <__errno>
10d566: c7 00 02 00 00 00 movl $0x2,(%eax)
10d56c: 83 c8 ff or $0xffffffff,%eax
}
10d56f: 8d 65 f4 lea -0xc(%ebp),%esp
10d572: 5b pop %ebx
10d573: 5e pop %esi
10d574: 5f pop %edi
10d575: c9 leave
10d576: c3 ret
00106c70 <devFS_mknod>:
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
106c70: 55 push %ebp
106c71: 89 e5 mov %esp,%ebp
106c73: 57 push %edi
106c74: 56 push %esi
106c75: 53 push %ebx
106c76: 83 ec 1c sub $0x1c,%esp
106c79: 8b 7d 08 mov 0x8(%ebp),%edi
106c7c: 8b 4d 10 mov 0x10(%ebp),%ecx
106c7f: 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') &&
106c82: 80 3f 64 cmpb $0x64,(%edi)
106c85: 75 18 jne 106c9f <devFS_mknod+0x2f>
106c87: 80 7f 01 65 cmpb $0x65,0x1(%edi)
106c8b: 75 12 jne 106c9f <devFS_mknod+0x2f> <== NEVER TAKEN
106c8d: 80 7f 02 76 cmpb $0x76,0x2(%edi)
106c91: 75 0c jne 106c9f <devFS_mknod+0x2f> <== NEVER TAKEN
(path[2] == 'v') && (path[3] == '\0'))
return 0;
106c93: 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'))
106c95: 80 7f 03 00 cmpb $0x0,0x3(%edi)
106c99: 0f 84 c9 00 00 00 je 106d68 <devFS_mknod+0xf8>
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
106c9f: 8b 45 0c mov 0xc(%ebp),%eax
106ca2: 25 00 f0 00 00 and $0xf000,%eax
106ca7: 3d 00 20 00 00 cmp $0x2000,%eax
106cac: 74 14 je 106cc2 <devFS_mknod+0x52>
106cae: 3d 00 60 00 00 cmp $0x6000,%eax
106cb3: 74 0d je 106cc2 <devFS_mknod+0x52>
rtems_set_errno_and_return_minus_one( EINVAL );
106cb5: e8 86 8a 00 00 call 10f740 <__errno>
106cba: c7 00 16 00 00 00 movl $0x16,(%eax)
106cc0: eb 23 jmp 106ce5 <devFS_mknod+0x75>
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.major;
106cc2: 89 4d e4 mov %ecx,-0x1c(%ebp)
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
106cc5: 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;
106cc8: 8b 45 18 mov 0x18(%ebp),%eax
106ccb: 8b 08 mov (%eax),%ecx
if (!device_name_table)
106ccd: 85 c9 test %ecx,%ecx
106ccf: 74 09 je 106cda <devFS_mknod+0x6a>
106cd1: 89 ca mov %ecx,%edx
106cd3: 83 ce ff or $0xffffffff,%esi
106cd6: 31 db xor %ebx,%ebx
106cd8: eb 46 jmp 106d20 <devFS_mknod+0xb0>
rtems_set_errno_and_return_minus_one( EFAULT );
106cda: e8 61 8a 00 00 call 10f740 <__errno>
106cdf: c7 00 0e 00 00 00 movl $0xe,(%eax)
106ce5: 83 c8 ff or $0xffffffff,%eax
106ce8: eb 7e jmp 106d68 <devFS_mknod+0xf8>
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
106cea: 8b 02 mov (%edx),%eax
106cec: 85 c0 test %eax,%eax
106cee: 74 2a je 106d1a <devFS_mknod+0xaa>
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
106cf0: 83 ec 08 sub $0x8,%esp
106cf3: 50 push %eax
106cf4: 57 push %edi
106cf5: 89 55 d8 mov %edx,-0x28(%ebp)
106cf8: 89 4d dc mov %ecx,-0x24(%ebp)
106cfb: e8 6c 96 00 00 call 11036c <strcmp>
106d00: 83 c4 10 add $0x10,%esp
106d03: 85 c0 test %eax,%eax
106d05: 8b 55 d8 mov -0x28(%ebp),%edx
106d08: 8b 4d dc mov -0x24(%ebp),%ecx
106d0b: 75 0f jne 106d1c <devFS_mknod+0xac>
rtems_set_errno_and_return_minus_one( EEXIST );
106d0d: e8 2e 8a 00 00 call 10f740 <__errno>
106d12: c7 00 11 00 00 00 movl $0x11,(%eax)
106d18: eb cb jmp 106ce5 <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;
106d1a: 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++){
106d1c: 43 inc %ebx
106d1d: 83 c2 14 add $0x14,%edx
106d20: 3b 1d 48 f1 11 00 cmp 0x11f148,%ebx
106d26: 72 c2 jb 106cea <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)
106d28: 83 fe ff cmp $0xffffffff,%esi
106d2b: 75 0d jne 106d3a <devFS_mknod+0xca>
rtems_set_errno_and_return_minus_one( ENOMEM );
106d2d: e8 0e 8a 00 00 call 10f740 <__errno>
106d32: c7 00 0c 00 00 00 movl $0xc,(%eax)
106d38: eb ab jmp 106ce5 <devFS_mknod+0x75>
_ISR_Disable(level);
106d3a: 9c pushf
106d3b: fa cli
106d3c: 5b pop %ebx
device_name_table[slot].device_name = (char *)path;
106d3d: 6b d6 14 imul $0x14,%esi,%edx
106d40: 8d 14 11 lea (%ecx,%edx,1),%edx
106d43: 89 3a mov %edi,(%edx)
device_name_table[slot].device_name_length = strlen(path);
106d45: 31 c0 xor %eax,%eax
106d47: 83 c9 ff or $0xffffffff,%ecx
106d4a: f2 ae repnz scas %es:(%edi),%al
106d4c: f7 d1 not %ecx
106d4e: 49 dec %ecx
106d4f: 89 4a 04 mov %ecx,0x4(%edx)
device_name_table[slot].major = major;
106d52: 8b 45 e4 mov -0x1c(%ebp),%eax
106d55: 89 42 08 mov %eax,0x8(%edx)
device_name_table[slot].minor = minor;
106d58: 8b 45 e0 mov -0x20(%ebp),%eax
106d5b: 89 42 0c mov %eax,0xc(%edx)
device_name_table[slot].mode = mode;
106d5e: 8b 45 0c mov 0xc(%ebp),%eax
106d61: 89 42 10 mov %eax,0x10(%edx)
_ISR_Enable(level);
106d64: 53 push %ebx
106d65: 9d popf
return 0;
106d66: 31 c0 xor %eax,%eax
}
106d68: 8d 65 f4 lea -0xc(%ebp),%esp
106d6b: 5b pop %ebx
106d6c: 5e pop %esi
106d6d: 5f pop %edi
106d6e: c9 leave
106d6f: c3 ret
001080d8 <drainOutput>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
1080d8: 55 push %ebp
1080d9: 89 e5 mov %esp,%ebp
1080db: 53 push %ebx
1080dc: 83 ec 04 sub $0x4,%esp
1080df: 89 c3 mov %eax,%ebx
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
1080e1: 83 b8 b4 00 00 00 00 cmpl $0x0,0xb4(%eax)
1080e8: 74 46 je 108130 <drainOutput+0x58>
rtems_interrupt_disable (level);
1080ea: 9c pushf
1080eb: fa cli
1080ec: 58 pop %eax
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
1080ed: eb 2f jmp 10811e <drainOutput+0x46>
tty->rawOutBufState = rob_wait;
1080ef: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
1080f6: 00 00 00
rtems_interrupt_enable (level);
1080f9: 50 push %eax
1080fa: 9d popf
sc = rtems_semaphore_obtain(
1080fb: 50 push %eax
1080fc: 6a 00 push $0x0
1080fe: 6a 00 push $0x0
108100: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
108106: e8 b1 20 00 00 call 10a1bc <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
10810b: 83 c4 10 add $0x10,%esp
10810e: 85 c0 test %eax,%eax
108110: 74 09 je 10811b <drainOutput+0x43> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
108112: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108115: 50 push %eax <== NOT EXECUTED
108116: e8 6d 26 00 00 call 10a788 <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_interrupt_disable (level);
10811b: 9c pushf
10811c: fa cli
10811d: 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) {
10811e: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx
108124: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
10812a: 39 d1 cmp %edx,%ecx
10812c: 75 c1 jne 1080ef <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);
10812e: 50 push %eax
10812f: 9d popf
}
}
108130: 8b 5d fc mov -0x4(%ebp),%ebx
108133: c9 leave
108134: c3 ret
00108c8f <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
108c8f: 55 push %ebp
108c90: 89 e5 mov %esp,%ebp
108c92: 53 push %ebx
108c93: 83 ec 24 sub $0x24,%esp
if ((tty->termios.c_lflag & ECHOCTL) &&
108c96: f6 42 3d 02 testb $0x2,0x3d(%edx)
108c9a: 74 3e je 108cda <echo+0x4b> <== NEVER TAKEN
iscntrl(c) && (c != '\t') && (c != '\n')) {
108c9c: 0f b6 c8 movzbl %al,%ecx
108c9f: 8b 1d 3c 31 12 00 mov 0x12313c,%ebx
108ca5: f6 44 0b 01 20 testb $0x20,0x1(%ebx,%ecx,1)
108caa: 74 2e je 108cda <echo+0x4b>
108cac: 3c 09 cmp $0x9,%al
108cae: 74 2a je 108cda <echo+0x4b>
108cb0: 3c 0a cmp $0xa,%al
108cb2: 74 26 je 108cda <echo+0x4b>
char echobuf[2];
echobuf[0] = '^';
108cb4: c6 45 f6 5e movb $0x5e,-0xa(%ebp)
echobuf[1] = c ^ 0x40;
108cb8: 83 f0 40 xor $0x40,%eax
108cbb: 88 45 f7 mov %al,-0x9(%ebp)
rtems_termios_puts (echobuf, 2, tty);
108cbe: 50 push %eax
108cbf: 52 push %edx
108cc0: 6a 02 push $0x2
108cc2: 8d 45 f6 lea -0xa(%ebp),%eax
108cc5: 50 push %eax
108cc6: 89 55 e4 mov %edx,-0x1c(%ebp)
108cc9: e8 84 fd ff ff call 108a52 <rtems_termios_puts>
tty->column += 2;
108cce: 8b 55 e4 mov -0x1c(%ebp),%edx
108cd1: 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')) {
108cd5: 83 c4 10 add $0x10,%esp
108cd8: eb 08 jmp 108ce2 <echo+0x53>
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
108cda: 0f b6 c0 movzbl %al,%eax
108cdd: e8 90 fe ff ff call 108b72 <oproc>
}
}
108ce2: 8b 5d fc mov -0x4(%ebp),%ebx
108ce5: c9 leave
108ce6: c3 ret
0010814e <endgrent>:
void endgrent(void)
{
10814e: 55 push %ebp
10814f: 89 e5 mov %esp,%ebp
108151: 83 ec 08 sub $0x8,%esp
if (group_fp != NULL)
108154: a1 b8 6b 12 00 mov 0x126bb8,%eax
108159: 85 c0 test %eax,%eax
10815b: 74 0c je 108169 <endgrent+0x1b> <== NEVER TAKEN
fclose(group_fp);
10815d: 83 ec 0c sub $0xc,%esp
108160: 50 push %eax
108161: e8 aa 9e 00 00 call 112010 <fclose>
108166: 83 c4 10 add $0x10,%esp
}
108169: c9 leave
10816a: c3 ret
00108001 <endpwent>:
void endpwent(void)
{
108001: 55 push %ebp
108002: 89 e5 mov %esp,%ebp
108004: 83 ec 08 sub $0x8,%esp
if (passwd_fp != NULL)
108007: a1 94 6c 12 00 mov 0x126c94,%eax
10800c: 85 c0 test %eax,%eax
10800e: 74 0c je 10801c <endpwent+0x1b> <== NEVER TAKEN
fclose(passwd_fp);
108010: 83 ec 0c sub $0xc,%esp
108013: 50 push %eax
108014: e8 f7 9f 00 00 call 112010 <fclose>
108019: 83 c4 10 add $0x10,%esp
}
10801c: c9 leave
10801d: c3 ret
00108ce7 <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)
{
108ce7: 55 push %ebp
108ce8: 89 e5 mov %esp,%ebp
108cea: 57 push %edi
108ceb: 56 push %esi
108cec: 53 push %ebx
108ced: 83 ec 2c sub $0x2c,%esp
108cf0: 89 c3 mov %eax,%ebx
108cf2: 89 55 e4 mov %edx,-0x1c(%ebp)
if (tty->ccount == 0)
108cf5: 83 78 20 00 cmpl $0x0,0x20(%eax)
108cf9: 0f 84 59 01 00 00 je 108e58 <erase+0x171>
return;
if (lineFlag) {
108cff: 85 d2 test %edx,%edx
108d01: 0f 84 46 01 00 00 je 108e4d <erase+0x166>
if (!(tty->termios.c_lflag & ECHO)) {
108d07: 8b 40 3c mov 0x3c(%eax),%eax
108d0a: a8 08 test $0x8,%al
108d0c: 75 0c jne 108d1a <erase+0x33> <== ALWAYS TAKEN
tty->ccount = 0;
108d0e: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
return;
108d15: e9 3e 01 00 00 jmp 108e58 <erase+0x171> <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
108d1a: a8 10 test $0x10,%al
108d1c: 0f 85 2b 01 00 00 jne 108e4d <erase+0x166> <== ALWAYS TAKEN
tty->ccount = 0;
108d22: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
108d29: 0f b6 43 44 movzbl 0x44(%ebx),%eax <== NOT EXECUTED
108d2d: 89 da mov %ebx,%edx <== NOT EXECUTED
108d2f: e8 5b ff ff ff call 108c8f <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
108d34: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED
108d38: 0f 84 1a 01 00 00 je 108e58 <erase+0x171> <== NOT EXECUTED
echo ('\n', tty);
108d3e: 89 da mov %ebx,%edx <== NOT EXECUTED
108d40: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
108d45: eb 2a jmp 108d71 <erase+0x8a> <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
108d47: 8b 7b 1c mov 0x1c(%ebx),%edi
108d4a: 8d 50 ff lea -0x1(%eax),%edx
108d4d: 89 53 20 mov %edx,0x20(%ebx)
108d50: 8a 4c 07 ff mov -0x1(%edi,%eax,1),%cl
if (tty->termios.c_lflag & ECHO) {
108d54: 8b 53 3c mov 0x3c(%ebx),%edx
108d57: f6 c2 08 test $0x8,%dl
108d5a: 0f 84 e7 00 00 00 je 108e47 <erase+0x160> <== NEVER TAKEN
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
108d60: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
108d64: 75 17 jne 108d7d <erase+0x96>
108d66: f6 c2 10 test $0x10,%dl
108d69: 75 12 jne 108d7d <erase+0x96> <== ALWAYS TAKEN
echo (tty->termios.c_cc[VERASE], tty);
108d6b: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED
108d6f: 89 da mov %ebx,%edx <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
108d71: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108d74: 5b pop %ebx <== NOT EXECUTED
108d75: 5e pop %esi <== NOT EXECUTED
108d76: 5f pop %edi <== NOT EXECUTED
108d77: 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);
108d78: e9 12 ff ff ff jmp 108c8f <echo> <== NOT EXECUTED
} else if (c == '\t') {
108d7d: 80 f9 09 cmp $0x9,%cl
108d80: 8b 35 3c 31 12 00 mov 0x12313c,%esi
108d86: 89 75 e0 mov %esi,-0x20(%ebp)
108d89: 75 60 jne 108deb <erase+0x104>
int col = tty->read_start_column;
108d8b: 8b 73 2c mov 0x2c(%ebx),%esi
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
108d8e: 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)
108d93: 81 e2 00 02 00 00 and $0x200,%edx
108d99: 89 55 dc mov %edx,-0x24(%ebp)
108d9c: 89 45 d4 mov %eax,-0x2c(%ebp)
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
108d9f: eb 28 jmp 108dc9 <erase+0xe2>
c = tty->cbuf[i++];
108da1: 8a 54 0f ff mov -0x1(%edi,%ecx,1),%dl
if (c == '\t') {
108da5: 80 fa 09 cmp $0x9,%dl
108da8: 75 05 jne 108daf <erase+0xc8>
col = (col | 7) + 1;
108daa: 83 ce 07 or $0x7,%esi
108dad: eb 18 jmp 108dc7 <erase+0xe0>
} else if (iscntrl (c)) {
108daf: 0f b6 d2 movzbl %dl,%edx
108db2: 8b 45 e0 mov -0x20(%ebp),%eax
108db5: f6 44 10 01 20 testb $0x20,0x1(%eax,%edx,1)
108dba: 74 0b je 108dc7 <erase+0xe0> <== ALWAYS TAKEN
if (tty->termios.c_lflag & ECHOCTL)
108dbc: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) <== NOT EXECUTED
108dc0: 74 06 je 108dc8 <erase+0xe1> <== NOT EXECUTED
col += 2;
108dc2: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
108dc5: eb 01 jmp 108dc8 <erase+0xe1> <== NOT EXECUTED
} else {
col++;
108dc7: 46 inc %esi
108dc8: 41 inc %ecx
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
108dc9: 3b 4d d4 cmp -0x2c(%ebp),%ecx
108dcc: 75 d3 jne 108da1 <erase+0xba>
108dce: eb 14 jmp 108de4 <erase+0xfd>
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
108dd0: 57 push %edi
108dd1: 53 push %ebx
108dd2: 6a 01 push $0x1
108dd4: 68 68 f0 11 00 push $0x11f068
108dd9: e8 74 fc ff ff call 108a52 <rtems_termios_puts>
tty->column--;
108dde: ff 4b 28 decl 0x28(%ebx)
108de1: 83 c4 10 add $0x10,%esp
}
/*
* Back up over the tab
*/
while (tty->column > col) {
108de4: 39 73 28 cmp %esi,0x28(%ebx)
108de7: 7f e7 jg 108dd0 <erase+0xe9>
108de9: eb 5c jmp 108e47 <erase+0x160>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
108deb: 0f b6 f1 movzbl %cl,%esi
108dee: 8b 45 e0 mov -0x20(%ebp),%eax
108df1: f6 44 30 01 20 testb $0x20,0x1(%eax,%esi,1)
108df6: 74 21 je 108e19 <erase+0x132> <== ALWAYS TAKEN
108df8: 80 e6 02 and $0x2,%dh <== NOT EXECUTED
108dfb: 74 1c je 108e19 <erase+0x132> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
108dfd: 51 push %ecx <== NOT EXECUTED
108dfe: 53 push %ebx <== NOT EXECUTED
108dff: 6a 03 push $0x3 <== NOT EXECUTED
108e01: 68 66 f0 11 00 push $0x11f066 <== NOT EXECUTED
108e06: e8 47 fc ff ff call 108a52 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
108e0b: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
108e0e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108e11: 85 c0 test %eax,%eax <== NOT EXECUTED
108e13: 74 04 je 108e19 <erase+0x132> <== NOT EXECUTED
tty->column--;
108e15: 48 dec %eax <== NOT EXECUTED
108e16: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
108e19: a1 3c 31 12 00 mov 0x12313c,%eax
108e1e: f6 44 30 01 20 testb $0x20,0x1(%eax,%esi,1)
108e23: 74 06 je 108e2b <erase+0x144> <== ALWAYS TAKEN
108e25: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED
108e29: 74 1c je 108e47 <erase+0x160> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
108e2b: 52 push %edx
108e2c: 53 push %ebx
108e2d: 6a 03 push $0x3
108e2f: 68 66 f0 11 00 push $0x11f066
108e34: e8 19 fc ff ff call 108a52 <rtems_termios_puts>
if (tty->column)
108e39: 8b 43 28 mov 0x28(%ebx),%eax
108e3c: 83 c4 10 add $0x10,%esp
108e3f: 85 c0 test %eax,%eax
108e41: 74 04 je 108e47 <erase+0x160> <== NEVER TAKEN
tty->column--;
108e43: 48 dec %eax
108e44: 89 43 28 mov %eax,0x28(%ebx)
}
}
}
if (!lineFlag)
108e47: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
108e4b: 74 0b je 108e58 <erase+0x171>
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
108e4d: 8b 43 20 mov 0x20(%ebx),%eax
108e50: 85 c0 test %eax,%eax
108e52: 0f 85 ef fe ff ff jne 108d47 <erase+0x60>
}
}
if (!lineFlag)
break;
}
}
108e58: 8d 65 f4 lea -0xc(%ebp),%esp
108e5b: 5b pop %ebx
108e5c: 5e pop %esi
108e5d: 5f pop %edi
108e5e: c9 leave
108e5f: c3 ret
00107c08 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
107c08: 55 push %ebp
107c09: 89 e5 mov %esp,%ebp
107c0b: 57 push %edi
107c0c: 56 push %esi
107c0d: 53 push %ebx
107c0e: 83 ec 0c sub $0xc,%esp
107c11: 8b 5d 08 mov 0x8(%ebp),%ebx
int ret;
va_list ap;
va_start( ap, cmd );
107c14: 8d 75 10 lea 0x10(%ebp),%esi
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
107c17: 8b 0d 44 21 12 00 mov 0x122144,%ecx
107c1d: 39 cb cmp %ecx,%ebx
107c1f: 73 14 jae 107c35 <fcntl+0x2d>
iop = rtems_libio_iop( fd );
107c21: 8b 15 f8 61 12 00 mov 0x1261f8,%edx
107c27: 6b db 38 imul $0x38,%ebx,%ebx
107c2a: 8d 1c 1a lea (%edx,%ebx,1),%ebx
rtems_libio_check_is_open(iop);
107c2d: 8b 43 14 mov 0x14(%ebx),%eax
107c30: f6 c4 01 test $0x1,%ah
107c33: 75 10 jne 107c45 <fcntl+0x3d>
107c35: e8 56 a3 00 00 call 111f90 <__errno>
107c3a: c7 00 09 00 00 00 movl $0x9,(%eax)
107c40: e9 e6 00 00 00 jmp 107d2b <fcntl+0x123>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
107c45: 83 7d 0c 09 cmpl $0x9,0xc(%ebp)
107c49: 0f 87 af 00 00 00 ja 107cfe <fcntl+0xf6>
107c4f: 8b 7d 0c mov 0xc(%ebp),%edi
107c52: ff 24 bd b4 08 12 00 jmp *0x1208b4(,%edi,4)
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
107c59: 8b 36 mov (%esi),%esi
if ( fd2 )
107c5b: 85 f6 test %esi,%esi
107c5d: 74 0e je 107c6d <fcntl+0x65>
diop = rtems_libio_iop( fd2 );
107c5f: 31 c0 xor %eax,%eax
107c61: 39 ce cmp %ecx,%esi
107c63: 73 15 jae 107c7a <fcntl+0x72> <== NEVER TAKEN
107c65: 6b c6 38 imul $0x38,%esi,%eax
107c68: 8d 04 02 lea (%edx,%eax,1),%eax
107c6b: eb 0d jmp 107c7a <fcntl+0x72>
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
107c6d: e8 d1 04 00 00 call 108143 <rtems_libio_allocate>
if ( diop == 0 ) {
107c72: 85 c0 test %eax,%eax
107c74: 0f 84 b1 00 00 00 je 107d2b <fcntl+0x123> <== NEVER TAKEN
ret = -1;
break;
}
}
diop->flags = iop->flags;
107c7a: 8b 53 14 mov 0x14(%ebx),%edx
107c7d: 89 50 14 mov %edx,0x14(%eax)
diop->pathinfo = iop->pathinfo;
107c80: 8d 78 18 lea 0x18(%eax),%edi
107c83: 8d 73 18 lea 0x18(%ebx),%esi
107c86: b9 05 00 00 00 mov $0x5,%ecx
107c8b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ret = (int) (diop - rtems_libio_iops);
107c8d: 2b 05 f8 61 12 00 sub 0x1261f8,%eax
107c93: c1 f8 03 sar $0x3,%eax
107c96: 69 f0 b7 6d db b6 imul $0xb6db6db7,%eax,%esi
107c9c: eb 6d jmp 107d0b <fcntl+0x103>
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
107c9e: f6 c4 08 test $0x8,%ah
107ca1: 0f 95 c0 setne %al
107ca4: 0f b6 c0 movzbl %al,%eax
107ca7: 89 c6 mov %eax,%esi
107ca9: eb 64 jmp 107d0f <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 ) )
107cab: 83 3e 00 cmpl $0x0,(%esi)
107cae: 74 05 je 107cb5 <fcntl+0xad>
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
107cb0: 80 cc 08 or $0x8,%ah
107cb3: eb 03 jmp 107cb8 <fcntl+0xb0>
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
107cb5: 80 e4 f7 and $0xf7,%ah
107cb8: 89 43 14 mov %eax,0x14(%ebx)
107cbb: eb 30 jmp 107ced <fcntl+0xe5>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
107cbd: 83 ec 0c sub $0xc,%esp
107cc0: 50 push %eax
107cc1: e8 3f 04 00 00 call 108105 <rtems_libio_to_fcntl_flags>
107cc6: 89 c6 mov %eax,%esi
107cc8: 83 c4 10 add $0x10,%esp
107ccb: eb 3e jmp 107d0b <fcntl+0x103>
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
107ccd: 83 ec 0c sub $0xc,%esp
107cd0: ff 36 pushl (%esi)
107cd2: e8 f9 03 00 00 call 1080d0 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
107cd7: 25 01 02 00 00 and $0x201,%eax
107cdc: 8b 53 14 mov 0x14(%ebx),%edx
107cdf: 81 e2 fe fd ff ff and $0xfffffdfe,%edx
107ce5: 09 d0 or %edx,%eax
107ce7: 89 43 14 mov %eax,0x14(%ebx)
107cea: 83 c4 10 add $0x10,%esp
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
107ced: 31 f6 xor %esi,%esi
107cef: eb 1e jmp 107d0f <fcntl+0x107>
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
107cf1: e8 9a a2 00 00 call 111f90 <__errno>
107cf6: c7 00 86 00 00 00 movl $0x86,(%eax)
107cfc: eb 2d jmp 107d2b <fcntl+0x123>
ret = -1;
break;
default:
errno = EINVAL;
107cfe: e8 8d a2 00 00 call 111f90 <__errno>
107d03: c7 00 16 00 00 00 movl $0x16,(%eax)
107d09: eb 20 jmp 107d2b <fcntl+0x123>
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
107d0b: 85 f6 test %esi,%esi
107d0d: 78 1f js 107d2e <fcntl+0x126> <== NEVER TAKEN
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
107d0f: 50 push %eax
107d10: 50 push %eax
107d11: 8b 43 20 mov 0x20(%ebx),%eax
107d14: 53 push %ebx
107d15: ff 75 0c pushl 0xc(%ebp)
107d18: ff 50 30 call *0x30(%eax)
107d1b: 89 c3 mov %eax,%ebx
if (err) {
107d1d: 83 c4 10 add $0x10,%esp
107d20: 85 c0 test %eax,%eax
107d22: 74 0a je 107d2e <fcntl+0x126> <== ALWAYS TAKEN
errno = err;
107d24: e8 67 a2 00 00 call 111f90 <__errno> <== NOT EXECUTED
107d29: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
ret = -1;
107d2b: 83 ce ff or $0xffffffff,%esi
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
107d2e: 89 f0 mov %esi,%eax
107d30: 8d 65 f4 lea -0xc(%ebp),%esp
107d33: 5b pop %ebx
107d34: 5e pop %esi
107d35: 5f pop %edi
107d36: c9 leave
107d37: c3 ret
0010fb83 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
10fb83: 55 push %ebp
10fb84: 89 e5 mov %esp,%ebp
10fb86: 57 push %edi
10fb87: 56 push %esi
10fb88: 53 push %ebx
10fb89: 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) {
10fb8c: 83 3d 20 70 12 00 00 cmpl $0x0,0x127020
10fb93: 75 50 jne 10fbe5 <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 );
10fb95: 53 push %ebx
10fb96: 6a 00 push $0x0
10fb98: 6a 00 push $0x0
10fb9a: ff 35 20 72 12 00 pushl 0x127220
10fba0: e8 bb c0 ff ff call 10bc60 <rtems_semaphore_obtain>
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
10fba5: 83 c4 10 add $0x10,%esp
free(pipe);
}
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
10fba8: 31 db xor %ebx,%ebx
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
10fbaa: 83 3d 20 70 12 00 00 cmpl $0x0,0x127020
10fbb1: 75 1d jne 10fbd0 <fifo_open+0x4d> <== NEVER TAKEN
sc = rtems_semaphore_create(
10fbb3: 83 ec 0c sub $0xc,%esp
10fbb6: 68 20 70 12 00 push $0x127020
10fbbb: 6a 00 push $0x0
10fbbd: 6a 54 push $0x54
10fbbf: 6a 01 push $0x1
10fbc1: 68 45 50 49 50 push $0x50495045
10fbc6: e8 6d be ff ff call 10ba38 <rtems_semaphore_create>
10fbcb: 89 c3 mov %eax,%ebx
10fbcd: 83 c4 20 add $0x20,%esp
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10fbd0: 83 ec 0c sub $0xc,%esp
10fbd3: ff 35 20 72 12 00 pushl 0x127220
10fbd9: e8 6e c1 ff ff call 10bd4c <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
10fbde: 83 c4 10 add $0x10,%esp
10fbe1: 85 db test %ebx,%ebx
10fbe3: 75 19 jne 10fbfe <fifo_open+0x7b>
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
10fbe5: 51 push %ecx
10fbe6: 6a 00 push $0x0
10fbe8: 6a 00 push $0x0
10fbea: ff 35 20 70 12 00 pushl 0x127020
10fbf0: e8 6b c0 ff ff call 10bc60 <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
10fbf5: 83 c4 10 add $0x10,%esp
return 0;
10fbf8: 31 f6 xor %esi,%esi
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
}
if (sc == RTEMS_SUCCESSFUL) {
10fbfa: 85 c0 test %eax,%eax
10fbfc: 74 05 je 10fc03 <fifo_open+0x80> <== ALWAYS TAKEN
return 0;
} else {
return -ENOMEM;
10fbfe: be f4 ff ff ff mov $0xfffffff4,%esi
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
if (err)
10fc03: 85 f6 test %esi,%esi
10fc05: 0f 85 37 03 00 00 jne 10ff42 <fifo_open+0x3bf>
return err;
pipe = *pipep;
10fc0b: 8b 45 08 mov 0x8(%ebp),%eax
10fc0e: 8b 18 mov (%eax),%ebx
if (pipe == NULL) {
10fc10: 85 db test %ebx,%ebx
10fc12: 0f 85 56 01 00 00 jne 10fd6e <fifo_open+0x1eb>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
10fc18: 83 ec 0c sub $0xc,%esp
10fc1b: 6a 34 push $0x34
10fc1d: e8 be 93 ff ff call 108fe0 <malloc>
10fc22: 89 c3 mov %eax,%ebx
10fc24: 89 45 d4 mov %eax,-0x2c(%ebp)
if (pipe == NULL)
10fc27: 83 c4 10 add $0x10,%esp
10fc2a: 85 c0 test %eax,%eax
10fc2c: 0f 84 35 01 00 00 je 10fd67 <fifo_open+0x1e4>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
10fc32: b9 0d 00 00 00 mov $0xd,%ecx
10fc37: 89 c7 mov %eax,%edi
10fc39: 89 f0 mov %esi,%eax
10fc3b: f3 ab rep stos %eax,%es:(%edi)
pipe->Size = PIPE_BUF;
10fc3d: c7 43 04 00 02 00 00 movl $0x200,0x4(%ebx)
pipe->Buffer = malloc(pipe->Size);
10fc44: 83 ec 0c sub $0xc,%esp
10fc47: 68 00 02 00 00 push $0x200
10fc4c: e8 8f 93 ff ff call 108fe0 <malloc>
10fc51: 89 03 mov %eax,(%ebx)
if (! pipe->Buffer)
10fc53: 83 c4 10 add $0x10,%esp
10fc56: 85 c0 test %eax,%eax
10fc58: 0f 84 fb 00 00 00 je 10fd59 <fifo_open+0x1d6> <== NEVER TAKEN
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
10fc5e: 8d 43 2c lea 0x2c(%ebx),%eax
10fc61: 50 push %eax
10fc62: 6a 00 push $0x0
10fc64: 6a 00 push $0x0
rtems_build_name ('P', 'I', 'r', c),
10fc66: 0f be 05 a8 50 12 00 movsbl 0x1250a8,%eax
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
10fc6d: 0d 00 72 49 50 or $0x50497200,%eax
10fc72: 50 push %eax
10fc73: e8 40 18 00 00 call 1114b8 <rtems_barrier_create>
10fc78: 83 c4 10 add $0x10,%esp
10fc7b: 85 c0 test %eax,%eax
10fc7d: 0f 85 c6 00 00 00 jne 10fd49 <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(
10fc83: 8d 43 30 lea 0x30(%ebx),%eax
10fc86: 50 push %eax
10fc87: 6a 00 push $0x0
10fc89: 6a 00 push $0x0
rtems_build_name ('P', 'I', 'w', c),
10fc8b: 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(
10fc92: 0d 00 77 49 50 or $0x50497700,%eax
10fc97: 50 push %eax
10fc98: e8 1b 18 00 00 call 1114b8 <rtems_barrier_create>
10fc9d: 83 c4 10 add $0x10,%esp
10fca0: 85 c0 test %eax,%eax
10fca2: 0f 85 90 00 00 00 jne 10fd38 <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(
10fca8: 83 ec 0c sub $0xc,%esp
10fcab: 8d 43 28 lea 0x28(%ebx),%eax
10fcae: 50 push %eax
10fcaf: 6a 00 push $0x0
10fcb1: 6a 10 push $0x10
10fcb3: 6a 01 push $0x1
rtems_build_name ('P', 'I', 's', c), 1,
10fcb5: 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(
10fcbc: 0d 00 73 49 50 or $0x50497300,%eax
10fcc1: 50 push %eax
10fcc2: e8 71 bd ff ff call 10ba38 <rtems_semaphore_create>
10fcc7: 83 c4 20 add $0x20,%esp
10fcca: 85 c0 test %eax,%eax
10fccc: 75 59 jne 10fd27 <fifo_open+0x1a4>
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
10fcce: 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
10fccf: 8d 7d e0 lea -0x20(%ebp),%edi
10fcd2: 57 push %edi
10fcd3: ff 73 2c pushl 0x2c(%ebx)
10fcd6: 68 5c 7c 12 00 push $0x127c5c
10fcdb: e8 c8 d4 ff ff call 10d1a8 <_Objects_Get>
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
10fce0: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax)
_Thread_Enable_dispatch();
10fce7: e8 9e df ff ff call 10dc8a <_Thread_Enable_dispatch>
10fcec: 83 c4 0c add $0xc,%esp
10fcef: 57 push %edi
10fcf0: ff 73 30 pushl 0x30(%ebx)
10fcf3: 68 5c 7c 12 00 push $0x127c5c
10fcf8: e8 ab d4 ff ff call 10d1a8 <_Objects_Get>
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
10fcfd: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax)
_Thread_Enable_dispatch();
10fd04: e8 81 df ff ff call 10dc8a <_Thread_Enable_dispatch>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
10fd09: a0 a8 50 12 00 mov 0x1250a8,%al
10fd0e: 8d 50 01 lea 0x1(%eax),%edx
10fd11: 88 15 a8 50 12 00 mov %dl,0x1250a8
10fd17: 83 c4 10 add $0x10,%esp
10fd1a: 3c 7a cmp $0x7a,%al
10fd1c: 75 50 jne 10fd6e <fifo_open+0x1eb>
c = 'a';
10fd1e: c6 05 a8 50 12 00 61 movb $0x61,0x1250a8
10fd25: eb 47 jmp 10fd6e <fifo_open+0x1eb>
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
10fd27: 83 ec 0c sub $0xc,%esp
10fd2a: 8b 55 d4 mov -0x2c(%ebp),%edx
10fd2d: ff 72 30 pushl 0x30(%edx)
10fd30: e8 3b 18 00 00 call 111570 <rtems_barrier_delete>
10fd35: 83 c4 10 add $0x10,%esp
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
10fd38: 83 ec 0c sub $0xc,%esp
10fd3b: 8b 45 d4 mov -0x2c(%ebp),%eax
10fd3e: ff 70 2c pushl 0x2c(%eax)
10fd41: e8 2a 18 00 00 call 111570 <rtems_barrier_delete>
10fd46: 83 c4 10 add $0x10,%esp
err_rbar:
free(pipe->Buffer);
10fd49: 83 ec 0c sub $0xc,%esp
10fd4c: 8b 55 d4 mov -0x2c(%ebp),%edx
10fd4f: ff 32 pushl (%edx)
10fd51: e8 66 8c ff ff call 1089bc <free>
10fd56: 83 c4 10 add $0x10,%esp
err_buf:
free(pipe);
10fd59: 83 ec 0c sub $0xc,%esp
10fd5c: ff 75 d4 pushl -0x2c(%ebp)
10fd5f: e8 58 8c ff ff call 1089bc <free>
10fd64: 83 c4 10 add $0x10,%esp
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
10fd67: be f4 ff ff ff mov $0xfffffff4,%esi
10fd6c: eb 33 jmp 10fda1 <fifo_open+0x21e>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
10fd6e: 50 push %eax
10fd6f: 6a 00 push $0x0
10fd71: 6a 00 push $0x0
10fd73: ff 73 28 pushl 0x28(%ebx)
10fd76: e8 e5 be ff ff call 10bc60 <rtems_semaphore_obtain>
10fd7b: 83 c4 10 add $0x10,%esp
10fd7e: 85 c0 test %eax,%eax
10fd80: 74 05 je 10fd87 <fifo_open+0x204> <== ALWAYS TAKEN
err = -EINTR;
10fd82: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
if (*pipep == NULL) {
10fd87: 8b 45 08 mov 0x8(%ebp),%eax
10fd8a: 83 38 00 cmpl $0x0,(%eax)
10fd8d: 75 12 jne 10fda1 <fifo_open+0x21e>
if (err)
10fd8f: 85 f6 test %esi,%esi
10fd91: 74 09 je 10fd9c <fifo_open+0x219> <== ALWAYS TAKEN
pipe_free(pipe);
10fd93: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10fd95: e8 1c fd ff ff call 10fab6 <pipe_free> <== NOT EXECUTED
10fd9a: eb 05 jmp 10fda1 <fifo_open+0x21e> <== NOT EXECUTED
else
*pipep = pipe;
10fd9c: 8b 55 08 mov 0x8(%ebp),%edx
10fd9f: 89 1a mov %ebx,(%edx)
}
out:
pipe_unlock();
10fda1: e8 fa fc ff ff call 10faa0 <pipe_unlock>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
10fda6: 85 f6 test %esi,%esi
10fda8: 0f 85 94 01 00 00 jne 10ff42 <fifo_open+0x3bf>
return err;
pipe = *pipep;
10fdae: 8b 45 08 mov 0x8(%ebp),%eax
10fdb1: 8b 18 mov (%eax),%ebx
switch (LIBIO_ACCMODE(iop)) {
10fdb3: 8b 55 0c mov 0xc(%ebp),%edx
10fdb6: 8b 42 14 mov 0x14(%edx),%eax
10fdb9: 83 e0 06 and $0x6,%eax
10fdbc: 83 f8 04 cmp $0x4,%eax
10fdbf: 0f 84 91 00 00 00 je 10fe56 <fifo_open+0x2d3>
10fdc5: 83 f8 06 cmp $0x6,%eax
10fdc8: 0f 84 10 01 00 00 je 10fede <fifo_open+0x35b>
10fdce: 83 f8 02 cmp $0x2,%eax
10fdd1: 0f 85 49 01 00 00 jne 10ff20 <fifo_open+0x39d> <== NEVER TAKEN
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
10fdd7: ff 43 20 incl 0x20(%ebx)
if (pipe->Readers ++ == 0)
10fdda: 8b 43 10 mov 0x10(%ebx),%eax
10fddd: 8d 50 01 lea 0x1(%eax),%edx
10fde0: 89 53 10 mov %edx,0x10(%ebx)
10fde3: 85 c0 test %eax,%eax
10fde5: 75 11 jne 10fdf8 <fifo_open+0x275> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
10fde7: 57 push %edi
10fde8: 57 push %edi
10fde9: 8d 45 e4 lea -0x1c(%ebp),%eax
10fdec: 50 push %eax
10fded: ff 73 30 pushl 0x30(%ebx)
10fdf0: e8 03 18 00 00 call 1115f8 <rtems_barrier_release>
10fdf5: 83 c4 10 add $0x10,%esp
if (pipe->Writers == 0) {
10fdf8: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fdfc: 0f 85 1e 01 00 00 jne 10ff20 <fifo_open+0x39d>
/* Not an error */
if (LIBIO_NODELAY(iop))
10fe02: 8b 45 0c mov 0xc(%ebp),%eax
10fe05: f6 40 14 01 testb $0x1,0x14(%eax)
10fe09: 0f 85 11 01 00 00 jne 10ff20 <fifo_open+0x39d>
break;
prevCounter = pipe->writerCounter;
10fe0f: 8b 7b 24 mov 0x24(%ebx),%edi
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
10fe12: 83 ec 0c sub $0xc,%esp
10fe15: ff 73 28 pushl 0x28(%ebx)
10fe18: e8 2f bf ff ff call 10bd4c <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
10fe1d: 5a pop %edx
10fe1e: 59 pop %ecx
10fe1f: 6a 00 push $0x0
10fe21: ff 73 2c pushl 0x2c(%ebx)
10fe24: e8 27 18 00 00 call 111650 <rtems_barrier_wait>
10fe29: 83 c4 10 add $0x10,%esp
10fe2c: 85 c0 test %eax,%eax
10fe2e: 0f 85 f9 00 00 00 jne 10ff2d <fifo_open+0x3aa> <== NEVER TAKEN
goto out_error;
if (! PIPE_LOCK(pipe))
10fe34: 50 push %eax
10fe35: 6a 00 push $0x0
10fe37: 6a 00 push $0x0
10fe39: ff 73 28 pushl 0x28(%ebx)
10fe3c: e8 1f be ff ff call 10bc60 <rtems_semaphore_obtain>
10fe41: 83 c4 10 add $0x10,%esp
10fe44: 85 c0 test %eax,%eax
10fe46: 0f 85 e1 00 00 00 jne 10ff2d <fifo_open+0x3aa> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->writerCounter);
10fe4c: 3b 7b 24 cmp 0x24(%ebx),%edi
10fe4f: 74 c1 je 10fe12 <fifo_open+0x28f> <== NEVER TAKEN
10fe51: e9 ca 00 00 00 jmp 10ff20 <fifo_open+0x39d>
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
10fe56: ff 43 24 incl 0x24(%ebx)
if (pipe->Writers ++ == 0)
10fe59: 8b 43 14 mov 0x14(%ebx),%eax
10fe5c: 8d 50 01 lea 0x1(%eax),%edx
10fe5f: 89 53 14 mov %edx,0x14(%ebx)
10fe62: 85 c0 test %eax,%eax
10fe64: 75 11 jne 10fe77 <fifo_open+0x2f4> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
10fe66: 57 push %edi
10fe67: 57 push %edi
10fe68: 8d 45 e4 lea -0x1c(%ebp),%eax
10fe6b: 50 push %eax
10fe6c: ff 73 2c pushl 0x2c(%ebx)
10fe6f: e8 84 17 00 00 call 1115f8 <rtems_barrier_release>
10fe74: 83 c4 10 add $0x10,%esp
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
10fe77: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10fe7b: 0f 85 9f 00 00 00 jne 10ff20 <fifo_open+0x39d>
10fe81: 8b 55 0c mov 0xc(%ebp),%edx
10fe84: f6 42 14 01 testb $0x1,0x14(%edx)
10fe88: 74 18 je 10fea2 <fifo_open+0x31f>
PIPE_UNLOCK(pipe);
10fe8a: 83 ec 0c sub $0xc,%esp
10fe8d: ff 73 28 pushl 0x28(%ebx)
10fe90: e8 b7 be ff ff call 10bd4c <rtems_semaphore_release>
err = -ENXIO;
goto out_error;
10fe95: 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;
10fe98: be fa ff ff ff mov $0xfffffffa,%esi
goto out_error;
10fe9d: e9 90 00 00 00 jmp 10ff32 <fifo_open+0x3af>
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
10fea2: 8b 7b 20 mov 0x20(%ebx),%edi
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
10fea5: 83 ec 0c sub $0xc,%esp
10fea8: ff 73 28 pushl 0x28(%ebx)
10feab: e8 9c be ff ff call 10bd4c <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
10feb0: 5a pop %edx
10feb1: 59 pop %ecx
10feb2: 6a 00 push $0x0
10feb4: ff 73 30 pushl 0x30(%ebx)
10feb7: e8 94 17 00 00 call 111650 <rtems_barrier_wait>
10febc: 83 c4 10 add $0x10,%esp
10febf: 85 c0 test %eax,%eax
10fec1: 75 6a jne 10ff2d <fifo_open+0x3aa> <== NEVER TAKEN
goto out_error;
if (! PIPE_LOCK(pipe))
10fec3: 50 push %eax
10fec4: 6a 00 push $0x0
10fec6: 6a 00 push $0x0
10fec8: ff 73 28 pushl 0x28(%ebx)
10fecb: e8 90 bd ff ff call 10bc60 <rtems_semaphore_obtain>
10fed0: 83 c4 10 add $0x10,%esp
10fed3: 85 c0 test %eax,%eax
10fed5: 75 56 jne 10ff2d <fifo_open+0x3aa> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->readerCounter);
10fed7: 3b 7b 20 cmp 0x20(%ebx),%edi
10feda: 74 c9 je 10fea5 <fifo_open+0x322> <== NEVER TAKEN
10fedc: eb 42 jmp 10ff20 <fifo_open+0x39d>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
10fede: ff 43 20 incl 0x20(%ebx)
if (pipe->Readers ++ == 0)
10fee1: 8b 43 10 mov 0x10(%ebx),%eax
10fee4: 8d 50 01 lea 0x1(%eax),%edx
10fee7: 89 53 10 mov %edx,0x10(%ebx)
10feea: 85 c0 test %eax,%eax
10feec: 75 11 jne 10feff <fifo_open+0x37c> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
10feee: 51 push %ecx
10feef: 51 push %ecx
10fef0: 8d 45 e4 lea -0x1c(%ebp),%eax
10fef3: 50 push %eax
10fef4: ff 73 30 pushl 0x30(%ebx)
10fef7: e8 fc 16 00 00 call 1115f8 <rtems_barrier_release>
10fefc: 83 c4 10 add $0x10,%esp
pipe->writerCounter ++;
10feff: ff 43 24 incl 0x24(%ebx)
if (pipe->Writers ++ == 0)
10ff02: 8b 43 14 mov 0x14(%ebx),%eax
10ff05: 8d 50 01 lea 0x1(%eax),%edx
10ff08: 89 53 14 mov %edx,0x14(%ebx)
10ff0b: 85 c0 test %eax,%eax
10ff0d: 75 11 jne 10ff20 <fifo_open+0x39d> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
10ff0f: 52 push %edx
10ff10: 52 push %edx
10ff11: 8d 45 e4 lea -0x1c(%ebp),%eax
10ff14: 50 push %eax
10ff15: ff 73 2c pushl 0x2c(%ebx)
10ff18: e8 db 16 00 00 call 1115f8 <rtems_barrier_release>
10ff1d: 83 c4 10 add $0x10,%esp
break;
}
PIPE_UNLOCK(pipe);
10ff20: 83 ec 0c sub $0xc,%esp
10ff23: ff 73 28 pushl 0x28(%ebx)
10ff26: e8 21 be ff ff call 10bd4c <rtems_semaphore_release>
10ff2b: eb 12 jmp 10ff3f <fifo_open+0x3bc>
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
10ff2d: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
10ff32: 50 push %eax
10ff33: 50 push %eax
10ff34: ff 75 0c pushl 0xc(%ebp)
10ff37: ff 75 08 pushl 0x8(%ebp)
10ff3a: e8 b2 fb ff ff call 10faf1 <pipe_release>
return err;
10ff3f: 83 c4 10 add $0x10,%esp
}
10ff42: 89 f0 mov %esi,%eax
10ff44: 8d 65 f4 lea -0xc(%ebp),%esp
10ff47: 5b pop %ebx
10ff48: 5e pop %esi
10ff49: 5f pop %edi
10ff4a: c9 leave
10ff4b: c3 ret
00107dac <fpathconf>:
long fpathconf(
int fd,
int name
)
{
107dac: 55 push %ebp
107dad: 89 e5 mov %esp,%ebp
107daf: 83 ec 08 sub $0x8,%esp
107db2: 8b 45 08 mov 0x8(%ebp),%eax
107db5: 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);
107db8: 3b 05 44 21 12 00 cmp 0x122144,%eax
107dbe: 73 11 jae 107dd1 <fpathconf+0x25>
iop = rtems_libio_iop(fd);
107dc0: 6b c0 38 imul $0x38,%eax,%eax
107dc3: 03 05 f8 61 12 00 add 0x1261f8,%eax
rtems_libio_check_is_open(iop);
107dc9: 8b 48 14 mov 0x14(%eax),%ecx
107dcc: f6 c5 01 test $0x1,%ch
107dcf: 75 0d jne 107dde <fpathconf+0x32> <== ALWAYS TAKEN
107dd1: e8 ba a1 00 00 call 111f90 <__errno>
107dd6: c7 00 09 00 00 00 movl $0x9,(%eax)
107ddc: eb 5b jmp 107e39 <fpathconf+0x8d>
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
107dde: 80 e1 02 and $0x2,%cl
107de1: 74 4b je 107e2e <fpathconf+0x82>
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
107de3: 8b 40 28 mov 0x28(%eax),%eax
switch ( name ) {
107de6: 83 fa 0b cmp $0xb,%edx
107de9: 77 43 ja 107e2e <fpathconf+0x82>
107deb: ff 24 95 dc 08 12 00 jmp *0x1208dc(,%edx,4)
case _PC_LINK_MAX:
return_value = the_limits->link_max;
107df2: 8b 40 38 mov 0x38(%eax),%eax
break;
107df5: eb 45 jmp 107e3c <fpathconf+0x90>
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
107df7: 8b 40 3c mov 0x3c(%eax),%eax
break;
107dfa: eb 40 jmp 107e3c <fpathconf+0x90>
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
107dfc: 8b 40 40 mov 0x40(%eax),%eax
break;
107dff: eb 3b jmp 107e3c <fpathconf+0x90>
case _PC_NAME_MAX:
return_value = the_limits->name_max;
107e01: 8b 40 44 mov 0x44(%eax),%eax
break;
107e04: eb 36 jmp 107e3c <fpathconf+0x90>
case _PC_PATH_MAX:
return_value = the_limits->path_max;
107e06: 8b 40 48 mov 0x48(%eax),%eax
break;
107e09: eb 31 jmp 107e3c <fpathconf+0x90>
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
107e0b: 8b 40 4c mov 0x4c(%eax),%eax
break;
107e0e: eb 2c jmp 107e3c <fpathconf+0x90>
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
107e10: 8b 40 54 mov 0x54(%eax),%eax
break;
107e13: eb 27 jmp 107e3c <fpathconf+0x90>
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
107e15: 8b 40 58 mov 0x58(%eax),%eax
break;
107e18: eb 22 jmp 107e3c <fpathconf+0x90>
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
107e1a: 8b 40 64 mov 0x64(%eax),%eax
break;
107e1d: eb 1d jmp 107e3c <fpathconf+0x90>
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
107e1f: 8b 40 50 mov 0x50(%eax),%eax
break;
107e22: eb 18 jmp 107e3c <fpathconf+0x90>
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
107e24: 8b 40 5c mov 0x5c(%eax),%eax
break;
107e27: eb 13 jmp 107e3c <fpathconf+0x90>
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
107e29: 8b 40 60 mov 0x60(%eax),%eax
break;
107e2c: eb 0e jmp 107e3c <fpathconf+0x90>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
107e2e: e8 5d a1 00 00 call 111f90 <__errno>
107e33: c7 00 16 00 00 00 movl $0x16,(%eax)
107e39: 83 c8 ff or $0xffffffff,%eax
break;
}
return return_value;
}
107e3c: c9 leave
107e3d: c3 ret
00107378 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
107378: 55 push %ebp
107379: 89 e5 mov %esp,%ebp
10737b: 53 push %ebx
10737c: 83 ec 04 sub $0x4,%esp
10737f: 8b 5d 08 mov 0x8(%ebp),%ebx
MSBUMP(free_calls, 1);
107382: ff 05 1c 52 12 00 incl 0x12521c
if ( !ptr )
107388: 85 db test %ebx,%ebx
10738a: 74 5f je 1073eb <free+0x73>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10738c: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c
107393: 75 15 jne 1073aa <free+0x32> <== NEVER TAKEN
!malloc_is_system_state_OK() ) {
107395: e8 56 01 00 00 call 1074f0 <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()) &&
10739a: 84 c0 test %al,%al
10739c: 75 0c jne 1073aa <free+0x32>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
10739e: 89 5d 08 mov %ebx,0x8(%ebp)
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
1073a1: 8b 5d fc mov -0x4(%ebp),%ebx
1073a4: 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);
1073a5: e9 ae 01 00 00 jmp 107558 <malloc_deferred_free>
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
1073aa: a1 70 36 12 00 mov 0x123670,%eax
1073af: 85 c0 test %eax,%eax
1073b1: 74 0a je 1073bd <free+0x45>
(*rtems_malloc_statistics_helpers->at_free)(ptr);
1073b3: 83 ec 0c sub $0xc,%esp
1073b6: 53 push %ebx
1073b7: ff 50 08 call *0x8(%eax)
1073ba: 83 c4 10 add $0x10,%esp
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
1073bd: 50 push %eax
1073be: 50 push %eax
1073bf: 53 push %ebx
1073c0: ff 35 80 11 12 00 pushl 0x121180
1073c6: e8 39 46 00 00 call 10ba04 <_Protected_heap_Free>
1073cb: 83 c4 10 add $0x10,%esp
1073ce: 84 c0 test %al,%al
1073d0: 75 19 jne 1073eb <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
1073d2: 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",
1073d7: ff 70 1c pushl 0x1c(%eax)
1073da: ff 70 18 pushl 0x18(%eax)
1073dd: 53 push %ebx
1073de: 68 87 ef 11 00 push $0x11ef87
1073e3: e8 fc 0b 00 00 call 107fe4 <printk>
1073e8: 83 c4 10 add $0x10,%esp
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
1073eb: 8b 5d fc mov -0x4(%ebp),%ebx
1073ee: c9 leave
1073ef: c3 ret
00108614 <free_user_env>:
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
108614: 55 push %ebp
108615: 89 e5 mov %esp,%ebp
108617: 53 push %ebx
108618: 83 ec 04 sub $0x4,%esp
10861b: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
10861e: 81 fb 48 52 12 00 cmp $0x125248,%ebx
108624: 74 26 je 10864c <free_user_env+0x38> <== NEVER TAKEN
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
108626: 83 ec 0c sub $0xc,%esp
108629: 8d 43 04 lea 0x4(%ebx),%eax
10862c: 50 push %eax
10862d: e8 46 f1 ff ff call 107778 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &env->root_directory);
108632: 8d 43 18 lea 0x18(%ebx),%eax
108635: 89 04 24 mov %eax,(%esp)
108638: e8 3b f1 ff ff call 107778 <rtems_filesystem_freenode>
free(env);
10863d: 83 c4 10 add $0x10,%esp
108640: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
108643: 8b 5d fc mov -0x4(%ebp),%ebx
108646: c9 leave
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
108647: e9 40 f1 ff ff jmp 10778c <free>
}
}
10864c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10864f: c9 leave <== NOT EXECUTED
108650: c3 ret <== NOT EXECUTED
0011e7a8 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
11e7a8: 55 push %ebp
11e7a9: 89 e5 mov %esp,%ebp
11e7ab: 57 push %edi
11e7ac: 56 push %esi
11e7ad: 53 push %ebx
11e7ae: 83 ec 2c sub $0x2c,%esp
11e7b1: 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 );
11e7b4: 31 db xor %ebx,%ebx
11e7b6: 3b 05 44 31 12 00 cmp 0x123144,%eax
11e7bc: 73 09 jae 11e7c7 <getdents+0x1f> <== NEVER TAKEN
11e7be: 6b d8 38 imul $0x38,%eax,%ebx
11e7c1: 03 1d 40 73 12 00 add 0x127340,%ebx
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
11e7c7: 8d 7d d4 lea -0x2c(%ebp),%edi
11e7ca: 8d 73 18 lea 0x18(%ebx),%esi
11e7cd: b9 05 00 00 00 mov $0x5,%ecx
11e7d2: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
11e7d4: 83 ec 0c sub $0xc,%esp
11e7d7: 8d 45 d4 lea -0x2c(%ebp),%eax
11e7da: 50 push %eax
11e7db: 8b 45 e0 mov -0x20(%ebp),%eax
11e7de: ff 50 10 call *0x10(%eax)
11e7e1: 83 c4 10 add $0x10,%esp
11e7e4: 48 dec %eax
11e7e5: 74 10 je 11e7f7 <getdents+0x4f>
rtems_set_errno_and_return_minus_one( ENOTDIR );
11e7e7: e8 d4 38 ff ff call 1120c0 <__errno>
11e7ec: c7 00 14 00 00 00 movl $0x14,(%eax)
11e7f2: 83 c8 ff or $0xffffffff,%eax
11e7f5: eb 11 jmp 11e808 <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 );
11e7f7: 50 push %eax
11e7f8: 8b 43 20 mov 0x20(%ebx),%eax
11e7fb: ff 75 10 pushl 0x10(%ebp)
11e7fe: ff 75 0c pushl 0xc(%ebp)
11e801: 53 push %ebx
11e802: ff 50 08 call *0x8(%eax)
11e805: 83 c4 10 add $0x10,%esp
}
11e808: 8d 65 f4 lea -0xc(%ebp),%esp
11e80b: 5b pop %ebx
11e80c: 5e pop %esi
11e80d: 5f pop %edi
11e80e: c9 leave
11e80f: c3 ret
00107f88 <getpwent>:
struct passwd *getpwent(void)
{
107f88: 55 push %ebp
107f89: 89 e5 mov %esp,%ebp
107f8b: 83 ec 08 sub $0x8,%esp
if (passwd_fp == NULL)
107f8e: a1 94 6c 12 00 mov 0x126c94,%eax
return NULL;
107f93: 31 d2 xor %edx,%edx
return p;
}
struct passwd *getpwent(void)
{
if (passwd_fp == NULL)
107f95: 85 c0 test %eax,%eax
107f97: 74 29 je 107fc2 <getpwent+0x3a> <== NEVER TAKEN
return NULL;
if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf))
107f99: 83 ec 0c sub $0xc,%esp
107f9c: 68 c8 00 00 00 push $0xc8
107fa1: b9 b4 6c 12 00 mov $0x126cb4,%ecx
107fa6: ba 98 6c 12 00 mov $0x126c98,%edx
107fab: e8 e9 fb ff ff call 107b99 <scanpw>
107fb0: 83 c4 10 add $0x10,%esp
return NULL;
107fb3: 31 d2 xor %edx,%edx
107fb5: 85 c0 test %eax,%eax
107fb7: 0f 95 c2 setne %dl
107fba: f7 da neg %edx
107fbc: 81 e2 98 6c 12 00 and $0x126c98,%edx
return &pwent;
}
107fc2: 89 d0 mov %edx,%eax
107fc4: c9 leave
107fc5: c3 ret
00110710 <imfs_dir_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
110710: 55 push %ebp
110711: 89 e5 mov %esp,%ebp
110713: 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 )
110716: 8b 4a 18 mov 0x18(%edx),%ecx
return -1; /* It wasn't a directory --> return error */
110719: 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 )
11071c: 83 79 4c 01 cmpl $0x1,0x4c(%ecx)
110720: 75 10 jne 110732 <imfs_dir_open+0x22> <== NEVER TAKEN
return -1; /* It wasn't a directory --> return error */
iop->offset = 0;
110722: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
110729: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
return 0;
110730: 31 c0 xor %eax,%eax
}
110732: c9 leave
110733: c3 ret
00110979 <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
110979: 55 push %ebp
11097a: 89 e5 mov %esp,%ebp
11097c: 53 push %ebx
11097d: 83 ec 04 sub $0x4,%esp
110980: 8b 45 0c mov 0xc(%ebp),%eax
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
110983: 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 );
110985: 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 ) )
110988: 39 53 50 cmp %edx,0x50(%ebx)
11098b: 74 0d je 11099a <imfs_dir_rmnod+0x21>
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
11098d: e8 a6 07 00 00 call 111138 <__errno>
110992: c7 00 5a 00 00 00 movl $0x5a,(%eax)
110998: eb 13 jmp 1109ad <imfs_dir_rmnod+0x34>
/*
* You cannot remove the file system root node.
*/
if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
11099a: 8b 40 10 mov 0x10(%eax),%eax
11099d: 39 58 1c cmp %ebx,0x1c(%eax)
1109a0: 75 10 jne 1109b2 <imfs_dir_rmnod+0x39>
rtems_set_errno_and_return_minus_one( EBUSY );
1109a2: e8 91 07 00 00 call 111138 <__errno>
1109a7: c7 00 10 00 00 00 movl $0x10,(%eax)
1109ad: 83 c8 ff or $0xffffffff,%eax
1109b0: eb 1c jmp 1109ce <imfs_dir_rmnod+0x55>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
1109b2: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx)
1109b6: 75 ea jne 1109a2 <imfs_dir_rmnod+0x29> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBUSY );
IMFS_create_orphan( the_jnode );
1109b8: 83 ec 0c sub $0xc,%esp
1109bb: 53 push %ebx
1109bc: e8 1b d5 ff ff call 10dedc <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
1109c1: 89 1c 24 mov %ebx,(%esp)
1109c4: e8 55 d5 ff ff call 10df1e <IMFS_check_node_remove>
return 0;
1109c9: 83 c4 10 add $0x10,%esp
1109cc: 31 c0 xor %eax,%eax
}
1109ce: 8b 5d fc mov -0x4(%ebp),%ebx
1109d1: c9 leave
1109d2: c3 ret
00107c9c <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
107c9c: 55 push %ebp
107c9d: 89 e5 mov %esp,%ebp
107c9f: 53 push %ebx
107ca0: 83 ec 04 sub $0x4,%esp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
107ca3: 80 3d 7c 6d 12 00 00 cmpb $0x0,0x126d7c
107caa: 0f 85 b8 00 00 00 jne 107d68 <init_etc_passwd_group+0xcc>
return;
etc_passwd_initted = 1;
107cb0: c6 05 7c 6d 12 00 01 movb $0x1,0x126d7c
mkdir("/etc", 0777);
107cb7: 50 push %eax
107cb8: 50 push %eax
107cb9: 68 ff 01 00 00 push $0x1ff
107cbe: 68 13 08 12 00 push $0x120813
107cc3: e8 7c 07 00 00 call 108444 <mkdir>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
107cc8: 59 pop %ecx
107cc9: 5b pop %ebx
107cca: 68 12 f5 11 00 push $0x11f512
107ccf: 68 18 08 12 00 push $0x120818
107cd4: e8 3b aa 00 00 call 112714 <fopen>
107cd9: 83 c4 10 add $0x10,%esp
107cdc: 85 c0 test %eax,%eax
107cde: 74 06 je 107ce6 <init_etc_passwd_group+0x4a>
fclose(fp);
107ce0: 83 ec 0c sub $0xc,%esp
107ce3: 50 push %eax
107ce4: eb 2a jmp 107d10 <init_etc_passwd_group+0x74>
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
107ce6: 52 push %edx
107ce7: 52 push %edx
107ce8: 68 2c f4 11 00 push $0x11f42c
107ced: 68 18 08 12 00 push $0x120818
107cf2: e8 1d aa 00 00 call 112714 <fopen>
107cf7: 89 c3 mov %eax,%ebx
107cf9: 83 c4 10 add $0x10,%esp
107cfc: 85 c0 test %eax,%eax
107cfe: 74 18 je 107d18 <init_etc_passwd_group+0x7c><== NEVER TAKEN
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
107d00: 50 push %eax
107d01: 50 push %eax
107d02: 53 push %ebx
107d03: 68 24 08 12 00 push $0x120824
107d08: e8 d3 aa 00 00 call 1127e0 <fputs>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
107d0d: 89 1c 24 mov %ebx,(%esp)
107d10: e8 fb a2 00 00 call 112010 <fclose>
107d15: 83 c4 10 add $0x10,%esp
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
107d18: 51 push %ecx
107d19: 51 push %ecx
107d1a: 68 12 f5 11 00 push $0x11f512
107d1f: 68 8b 08 12 00 push $0x12088b
107d24: e8 eb a9 00 00 call 112714 <fopen>
107d29: 83 c4 10 add $0x10,%esp
107d2c: 85 c0 test %eax,%eax
107d2e: 74 06 je 107d36 <init_etc_passwd_group+0x9a>
fclose(fp);
107d30: 83 ec 0c sub $0xc,%esp
107d33: 50 push %eax
107d34: eb 2a jmp 107d60 <init_etc_passwd_group+0xc4>
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
107d36: 52 push %edx
107d37: 52 push %edx
107d38: 68 2c f4 11 00 push $0x11f42c
107d3d: 68 8b 08 12 00 push $0x12088b
107d42: e8 cd a9 00 00 call 112714 <fopen>
107d47: 89 c3 mov %eax,%ebx
107d49: 83 c4 10 add $0x10,%esp
107d4c: 85 c0 test %eax,%eax
107d4e: 74 18 je 107d68 <init_etc_passwd_group+0xcc><== NEVER TAKEN
fprintf( fp, "root:x:0:root\n"
107d50: 50 push %eax
107d51: 50 push %eax
107d52: 53 push %ebx
107d53: 68 96 08 12 00 push $0x120896
107d58: e8 83 aa 00 00 call 1127e0 <fputs>
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
107d5d: 89 1c 24 mov %ebx,(%esp)
107d60: e8 ab a2 00 00 call 112010 <fclose>
107d65: 83 c4 10 add $0x10,%esp
}
}
107d68: 8b 5d fc mov -0x4(%ebp),%ebx
107d6b: c9 leave
107d6c: c3 ret
00108e60 <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
108e60: 55 push %ebp
108e61: 89 e5 mov %esp,%ebp
108e63: 53 push %ebx
108e64: 83 ec 14 sub $0x14,%esp
108e67: 89 d3 mov %edx,%ebx
108e69: 88 c1 mov %al,%cl
if (tty->termios.c_iflag & ISTRIP)
108e6b: 8b 52 30 mov 0x30(%edx),%edx
108e6e: f6 c2 20 test $0x20,%dl
108e71: 74 03 je 108e76 <iproc+0x16> <== ALWAYS TAKEN
c &= 0x7f;
108e73: 83 e1 7f and $0x7f,%ecx <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
108e76: f6 c6 02 test $0x2,%dh
108e79: 74 16 je 108e91 <iproc+0x31>
c = tolower (c);
108e7b: 0f b6 c9 movzbl %cl,%ecx
108e7e: a1 3c 31 12 00 mov 0x12313c,%eax
108e83: 0f be 44 08 01 movsbl 0x1(%eax,%ecx,1),%eax
108e88: 83 e0 03 and $0x3,%eax
108e8b: 48 dec %eax
108e8c: 75 03 jne 108e91 <iproc+0x31>
108e8e: 83 c1 20 add $0x20,%ecx
if (c == '\r') {
108e91: 80 f9 0d cmp $0xd,%cl
108e94: 75 14 jne 108eaa <iproc+0x4a>
if (tty->termios.c_iflag & IGNCR)
return 0;
108e96: 31 c0 xor %eax,%eax
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
108e98: f6 c2 80 test $0x80,%dl
108e9b: 0f 85 d9 00 00 00 jne 108f7a <iproc+0x11a> <== NEVER TAKEN
return 0;
if (tty->termios.c_iflag & ICRNL)
108ea1: 80 e6 01 and $0x1,%dh
108ea4: 74 1a je 108ec0 <iproc+0x60> <== NEVER TAKEN
c = '\n';
108ea6: b1 0a mov $0xa,%cl
108ea8: eb 16 jmp 108ec0 <iproc+0x60>
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
108eaa: 80 f9 0a cmp $0xa,%cl
108ead: 75 09 jne 108eb8 <iproc+0x58>
108eaf: 80 e2 40 and $0x40,%dl
108eb2: 74 0c je 108ec0 <iproc+0x60> <== ALWAYS TAKEN
c = '\r';
108eb4: b1 0d mov $0xd,%cl <== NOT EXECUTED
108eb6: eb 08 jmp 108ec0 <iproc+0x60> <== NOT EXECUTED
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
108eb8: 84 c9 test %cl,%cl
108eba: 0f 84 87 00 00 00 je 108f47 <iproc+0xe7> <== NEVER TAKEN
108ec0: 8b 53 3c mov 0x3c(%ebx),%edx
108ec3: f6 c2 02 test $0x2,%dl
108ec6: 74 7f je 108f47 <iproc+0xe7>
if (c == tty->termios.c_cc[VERASE]) {
108ec8: 3a 4b 43 cmp 0x43(%ebx),%cl
108ecb: 75 04 jne 108ed1 <iproc+0x71>
erase (tty, 0);
108ecd: 31 d2 xor %edx,%edx
108ecf: eb 0a jmp 108edb <iproc+0x7b>
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
108ed1: 3a 4b 44 cmp 0x44(%ebx),%cl
108ed4: 75 11 jne 108ee7 <iproc+0x87>
erase (tty, 1);
108ed6: ba 01 00 00 00 mov $0x1,%edx
108edb: 89 d8 mov %ebx,%eax
108edd: e8 05 fe ff ff call 108ce7 <erase>
108ee2: e9 91 00 00 00 jmp 108f78 <iproc+0x118>
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
108ee7: 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]) {
108eec: 3a 4b 45 cmp 0x45(%ebx),%cl
108eef: 0f 84 85 00 00 00 je 108f7a <iproc+0x11a> <== NEVER TAKEN
return 1;
} else if (c == '\n') {
108ef5: 80 f9 0a cmp $0xa,%cl
108ef8: 75 1a jne 108f14 <iproc+0xb4>
if (tty->termios.c_lflag & (ECHO | ECHONL))
108efa: 80 e2 48 and $0x48,%dl
108efd: 74 09 je 108f08 <iproc+0xa8> <== NEVER TAKEN
echo (c, tty);
108eff: 89 da mov %ebx,%edx
108f01: b0 0a mov $0xa,%al
108f03: e8 87 fd ff ff call 108c8f <echo>
tty->cbuf[tty->ccount++] = c;
108f08: 8b 43 20 mov 0x20(%ebx),%eax
108f0b: 8b 53 1c mov 0x1c(%ebx),%edx
108f0e: c6 04 02 0a movb $0xa,(%edx,%eax,1)
108f12: eb 28 jmp 108f3c <iproc+0xdc>
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
108f14: 3a 4b 4c cmp 0x4c(%ebx),%cl
108f17: 74 05 je 108f1e <iproc+0xbe> <== NEVER TAKEN
108f19: 3a 4b 51 cmp 0x51(%ebx),%cl
108f1c: 75 29 jne 108f47 <iproc+0xe7> <== ALWAYS TAKEN
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
108f1e: 80 e2 08 and $0x8,%dl <== NOT EXECUTED
108f21: 74 10 je 108f33 <iproc+0xd3> <== NOT EXECUTED
echo (c, tty);
108f23: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED
108f26: 89 da mov %ebx,%edx <== NOT EXECUTED
108f28: 88 4d f4 mov %cl,-0xc(%ebp) <== NOT EXECUTED
108f2b: e8 5f fd ff ff call 108c8f <echo> <== NOT EXECUTED
108f30: 8a 4d f4 mov -0xc(%ebp),%cl <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
108f33: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED
108f36: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED
108f39: 88 0c 02 mov %cl,(%edx,%eax,1) <== NOT EXECUTED
108f3c: 40 inc %eax
108f3d: 89 43 20 mov %eax,0x20(%ebx)
return 1;
108f40: b8 01 00 00 00 mov $0x1,%eax
108f45: eb 33 jmp 108f7a <iproc+0x11a>
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
108f47: 8b 15 70 30 12 00 mov 0x123070,%edx
108f4d: 4a dec %edx
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
108f4e: 31 c0 xor %eax,%eax
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
108f50: 39 53 20 cmp %edx,0x20(%ebx)
108f53: 7d 25 jge 108f7a <iproc+0x11a> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHO)
108f55: f6 43 3c 08 testb $0x8,0x3c(%ebx)
108f59: 74 10 je 108f6b <iproc+0x10b> <== NEVER TAKEN
echo (c, tty);
108f5b: 0f b6 c1 movzbl %cl,%eax
108f5e: 89 da mov %ebx,%edx
108f60: 88 4d f4 mov %cl,-0xc(%ebp)
108f63: e8 27 fd ff ff call 108c8f <echo>
108f68: 8a 4d f4 mov -0xc(%ebp),%cl
tty->cbuf[tty->ccount++] = c;
108f6b: 8b 43 20 mov 0x20(%ebx),%eax
108f6e: 8b 53 1c mov 0x1c(%ebx),%edx
108f71: 88 0c 02 mov %cl,(%edx,%eax,1)
108f74: 40 inc %eax
108f75: 89 43 20 mov %eax,0x20(%ebx)
}
return 0;
108f78: 31 c0 xor %eax,%eax
}
108f7a: 83 c4 14 add $0x14,%esp
108f7d: 5b pop %ebx
108f7e: c9 leave
108f7f: c3 ret
00121f58 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
121f58: 55 push %ebp
121f59: 89 e5 mov %esp,%ebp
121f5b: 57 push %edi
121f5c: 56 push %esi
121f5d: 53 push %ebx
121f5e: 83 ec 4c sub $0x4c,%esp
121f61: 8b 5d 0c mov 0xc(%ebp),%ebx
121f64: 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() )
121f67: e8 64 fd ff ff call 121cd0 <getpid>
121f6c: 39 45 08 cmp %eax,0x8(%ebp)
121f6f: 74 0d je 121f7e <killinfo+0x26> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ESRCH );
121f71: e8 5a 3a ff ff call 1159d0 <__errno> <== NOT EXECUTED
121f76: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED
121f7c: eb 0f jmp 121f8d <killinfo+0x35> <== NOT EXECUTED
/*
* Validate the signal passed.
*/
if ( !sig )
121f7e: 85 db test %ebx,%ebx
121f80: 75 13 jne 121f95 <killinfo+0x3d> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
121f82: e8 49 3a ff ff call 1159d0 <__errno> <== NOT EXECUTED
121f87: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
121f8d: 83 c8 ff or $0xffffffff,%eax
121f90: e9 ef 01 00 00 jmp 122184 <killinfo+0x22c>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
121f95: 8d 4b ff lea -0x1(%ebx),%ecx
if ( !is_valid_signo(sig) )
121f98: 83 f9 1f cmp $0x1f,%ecx
121f9b: 77 e5 ja 121f82 <killinfo+0x2a> <== NEVER TAKEN
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 )
121f9d: 6b d3 0c imul $0xc,%ebx,%edx
return 0;
121fa0: 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 )
121fa2: 83 ba 18 ba 12 00 01 cmpl $0x1,0x12ba18(%edx)
121fa9: 0f 84 d5 01 00 00 je 122184 <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 ) )
121faf: 83 fb 04 cmp $0x4,%ebx
121fb2: 74 0a je 121fbe <killinfo+0x66>
121fb4: 83 fb 08 cmp $0x8,%ebx
121fb7: 74 05 je 121fbe <killinfo+0x66>
121fb9: 83 fb 0b cmp $0xb,%ebx
121fbc: 75 16 jne 121fd4 <killinfo+0x7c>
return pthread_kill( pthread_self(), sig );
121fbe: e8 85 03 00 00 call 122348 <pthread_self>
121fc3: 56 push %esi
121fc4: 56 push %esi
121fc5: 53 push %ebx
121fc6: 50 push %eax
121fc7: e8 d8 02 00 00 call 1222a4 <pthread_kill>
121fcc: 83 c4 10 add $0x10,%esp
121fcf: e9 b0 01 00 00 jmp 122184 <killinfo+0x22c>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
121fd4: be 01 00 00 00 mov $0x1,%esi
121fd9: d3 e6 shl %cl,%esi
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
121fdb: 89 5d dc mov %ebx,-0x24(%ebp)
siginfo->si_code = SI_USER;
121fde: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
if ( !value ) {
121fe5: 85 ff test %edi,%edi
121fe7: 75 09 jne 121ff2 <killinfo+0x9a>
siginfo->si_value.sival_int = 0;
121fe9: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
121ff0: eb 05 jmp 121ff7 <killinfo+0x9f>
} else {
siginfo->si_value = *value;
121ff2: 8b 07 mov (%edi),%eax
121ff4: 89 45 e4 mov %eax,-0x1c(%ebp)
121ff7: a1 b4 b4 12 00 mov 0x12b4b4,%eax
121ffc: 40 inc %eax
121ffd: 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;
122002: a1 dc b9 12 00 mov 0x12b9dc,%eax
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
122007: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
12200d: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx
122013: f7 d2 not %edx
122015: 85 d6 test %edx,%esi
122017: 0f 85 ed 00 00 00 jne 12210a <killinfo+0x1b2>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
12201d: 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 );
122023: eb 23 jmp 122048 <killinfo+0xf0>
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
122025: 89 d0 mov %edx,%eax
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
122027: 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)
12202d: 85 72 30 test %esi,0x30(%edx)
122030: 0f 85 d4 00 00 00 jne 12210a <killinfo+0x1b2>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
122036: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx
12203c: f7 d1 not %ecx
12203e: 85 ce test %ecx,%esi
122040: 0f 85 c4 00 00 00 jne 12210a <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 ) {
122046: 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 );
122048: 81 fa a0 bb 12 00 cmp $0x12bba0,%edx
12204e: 75 d5 jne 122025 <killinfo+0xcd>
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
122050: 0f b6 0d 24 72 12 00 movzbl 0x127224,%ecx
122057: 41 inc %ecx
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
122058: 31 c0 xor %eax,%eax
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
12205a: 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 ] )
122061: 8b 7d cc mov -0x34(%ebp),%edi
122064: 8b 14 bd 8c b4 12 00 mov 0x12b48c(,%edi,4),%edx
12206b: 85 d2 test %edx,%edx
12206d: 0f 84 86 00 00 00 je 1220f9 <killinfo+0x1a1> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
122073: 8b 52 04 mov 0x4(%edx),%edx
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
122076: 0f b7 7a 10 movzwl 0x10(%edx),%edi
12207a: 89 7d c4 mov %edi,-0x3c(%ebp)
object_table = the_info->local_table;
12207d: 8b 52 1c mov 0x1c(%edx),%edx
122080: 89 55 c0 mov %edx,-0x40(%ebp)
for ( index = 1 ; index <= maximum ; index++ ) {
122083: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp)
12208a: 89 5d b4 mov %ebx,-0x4c(%ebp)
12208d: eb 5f jmp 1220ee <killinfo+0x196>
the_thread = (Thread_Control *) object_table[ index ];
12208f: 8b 5d d0 mov -0x30(%ebp),%ebx
122092: 8b 7d c0 mov -0x40(%ebp),%edi
122095: 8b 14 9f mov (%edi,%ebx,4),%edx
if ( !the_thread )
122098: 85 d2 test %edx,%edx
12209a: 74 4f je 1220eb <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 )
12209c: 8b 5a 14 mov 0x14(%edx),%ebx
12209f: 89 5d d4 mov %ebx,-0x2c(%ebp)
1220a2: 39 cb cmp %ecx,%ebx
1220a4: 77 45 ja 1220eb <killinfo+0x193>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
1220a6: 8b ba ec 00 00 00 mov 0xec(%edx),%edi
1220ac: 8b bf d0 00 00 00 mov 0xd0(%edi),%edi
1220b2: f7 d7 not %edi
1220b4: 85 fe test %edi,%esi
1220b6: 74 33 je 1220eb <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 ) {
1220b8: 39 cb cmp %ecx,%ebx
1220ba: 72 2a jb 1220e6 <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 ) ) {
1220bc: 85 c0 test %eax,%eax
1220be: 74 2b je 1220eb <killinfo+0x193> <== NEVER TAKEN
1220c0: 8b 78 10 mov 0x10(%eax),%edi
1220c3: 89 7d c8 mov %edi,-0x38(%ebp)
1220c6: 85 ff test %edi,%edi
1220c8: 74 21 je 1220eb <killinfo+0x193> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
1220ca: 8b 7a 10 mov 0x10(%edx),%edi
1220cd: 85 ff test %edi,%edi
1220cf: 74 15 je 1220e6 <killinfo+0x18e>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
1220d1: f7 45 c8 00 00 00 10 testl $0x10000000,-0x38(%ebp)
1220d8: 75 11 jne 1220eb <killinfo+0x193>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
1220da: 81 e7 00 00 00 10 and $0x10000000,%edi
1220e0: 74 09 je 1220eb <killinfo+0x193>
1220e2: 89 d9 mov %ebx,%ecx
1220e4: eb 03 jmp 1220e9 <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 ) ) {
1220e6: 8b 4d d4 mov -0x2c(%ebp),%ecx
1220e9: 89 d0 mov %edx,%eax
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
1220eb: ff 45 d0 incl -0x30(%ebp)
1220ee: 8b 55 c4 mov -0x3c(%ebp),%edx
1220f1: 39 55 d0 cmp %edx,-0x30(%ebp)
1220f4: 76 99 jbe 12208f <killinfo+0x137>
1220f6: 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++) {
1220f9: ff 45 cc incl -0x34(%ebp)
1220fc: 83 7d cc 04 cmpl $0x4,-0x34(%ebp)
122100: 0f 85 5b ff ff ff jne 122061 <killinfo+0x109>
}
}
}
}
if ( interested ) {
122106: 85 c0 test %eax,%eax
122108: 74 13 je 12211d <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 ) ) {
12210a: 51 push %ecx
mask = signo_to_mask( sig );
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
12210b: 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 ) ) {
12210e: 52 push %edx
12210f: 53 push %ebx
122110: 50 push %eax
122111: e8 8a 00 00 00 call 1221a0 <_POSIX_signals_Unblock_thread>
122116: 83 c4 10 add $0x10,%esp
122119: 84 c0 test %al,%al
12211b: 75 60 jne 12217d <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 );
12211d: 83 ec 0c sub $0xc,%esp
122120: 56 push %esi
122121: e8 66 00 00 00 call 12218c <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
122126: 6b db 0c imul $0xc,%ebx,%ebx
122129: 83 c4 10 add $0x10,%esp
12212c: 83 bb 10 ba 12 00 02 cmpl $0x2,0x12ba10(%ebx)
122133: 75 48 jne 12217d <killinfo+0x225>
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
122135: 83 ec 0c sub $0xc,%esp
122138: 68 90 bb 12 00 push $0x12bb90
12213d: e8 4e d0 fe ff call 10f190 <_Chain_Get>
if ( !psiginfo ) {
122142: 83 c4 10 add $0x10,%esp
122145: 85 c0 test %eax,%eax
122147: 75 15 jne 12215e <killinfo+0x206>
_Thread_Enable_dispatch();
122149: e8 6c e8 fe ff call 1109ba <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
12214e: e8 7d 38 ff ff call 1159d0 <__errno>
122153: c7 00 0b 00 00 00 movl $0xb,(%eax)
122159: e9 2f fe ff ff jmp 121f8d <killinfo+0x35>
}
psiginfo->Info = *siginfo;
12215e: 8d 78 08 lea 0x8(%eax),%edi
122161: 8d 75 dc lea -0x24(%ebp),%esi
122164: b9 03 00 00 00 mov $0x3,%ecx
122169: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
12216b: 52 push %edx
12216c: 52 push %edx
12216d: 50 push %eax
12216e: 81 c3 08 bc 12 00 add $0x12bc08,%ebx
122174: 53 push %ebx
122175: e8 da cf fe ff call 10f154 <_Chain_Append>
12217a: 83 c4 10 add $0x10,%esp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
12217d: e8 38 e8 fe ff call 1109ba <_Thread_Enable_dispatch>
return 0;
122182: 31 c0 xor %eax,%eax
}
122184: 8d 65 f4 lea -0xc(%ebp),%esp
122187: 5b pop %ebx
122188: 5e pop %esi
122189: 5f pop %edi
12218a: c9 leave
12218b: c3 ret
0011d094 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
11d094: 55 push %ebp
11d095: 89 e5 mov %esp,%ebp
11d097: 53 push %ebx
11d098: 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()))
11d09b: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c
11d0a2: 75 4f jne 11d0f3 <libc_wrapup+0x5f> <== NEVER TAKEN
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
11d0a4: 8b 1d 80 fa 11 00 mov 0x11fa80,%ebx
11d0aa: 39 1d 40 31 12 00 cmp %ebx,0x123140
11d0b0: 74 12 je 11d0c4 <libc_wrapup+0x30>
_wrapup_reent(_global_impure_ptr);
11d0b2: 83 ec 0c sub $0xc,%esp
11d0b5: 53 push %ebx
11d0b6: e8 b5 05 00 00 call 11d670 <_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;
11d0bb: 89 1d 40 31 12 00 mov %ebx,0x123140
11d0c1: 83 c4 10 add $0x10,%esp
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
11d0c4: 83 ec 0c sub $0xc,%esp
11d0c7: a1 40 31 12 00 mov 0x123140,%eax
11d0cc: ff 70 04 pushl 0x4(%eax)
11d0cf: e8 bc 41 ff ff call 111290 <fclose>
fclose (stdout);
11d0d4: 5a pop %edx
11d0d5: a1 40 31 12 00 mov 0x123140,%eax
11d0da: ff 70 08 pushl 0x8(%eax)
11d0dd: e8 ae 41 ff ff call 111290 <fclose>
fclose (stderr);
11d0e2: 58 pop %eax
11d0e3: a1 40 31 12 00 mov 0x123140,%eax
11d0e8: ff 70 0c pushl 0xc(%eax)
11d0eb: e8 a0 41 ff ff call 111290 <fclose>
11d0f0: 83 c4 10 add $0x10,%esp
}
11d0f3: 8b 5d fc mov -0x4(%ebp),%ebx
11d0f6: c9 leave
11d0f7: c3 ret
0011cfa0 <lseek>:
off_t lseek(
int fd,
off_t offset,
int whence
)
{
11cfa0: 55 push %ebp
11cfa1: 89 e5 mov %esp,%ebp
11cfa3: 57 push %edi
11cfa4: 56 push %esi
11cfa5: 53 push %ebx
11cfa6: 83 ec 1c sub $0x1c,%esp
11cfa9: 8b 5d 08 mov 0x8(%ebp),%ebx
11cfac: 8b 45 0c mov 0xc(%ebp),%eax
11cfaf: 8b 55 10 mov 0x10(%ebp),%edx
11cfb2: 8b 4d 14 mov 0x14(%ebp),%ecx
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
11cfb5: 3b 1d 44 11 12 00 cmp 0x121144,%ebx
11cfbb: 73 0f jae 11cfcc <lseek+0x2c>
iop = rtems_libio_iop( fd );
11cfbd: 6b db 38 imul $0x38,%ebx,%ebx
11cfc0: 03 1d f8 51 12 00 add 0x1251f8,%ebx
rtems_libio_check_is_open(iop);
11cfc6: f6 43 15 01 testb $0x1,0x15(%ebx)
11cfca: 75 0d jne 11cfd9 <lseek+0x39>
11cfcc: e8 67 41 ff ff call 111138 <__errno>
11cfd1: c7 00 09 00 00 00 movl $0x9,(%eax)
11cfd7: eb 4b jmp 11d024 <lseek+0x84>
/*
* Now process the lseek().
*/
old_offset = iop->offset;
11cfd9: 8b 73 0c mov 0xc(%ebx),%esi
11cfdc: 8b 7b 10 mov 0x10(%ebx),%edi
11cfdf: 89 75 e0 mov %esi,-0x20(%ebp)
11cfe2: 89 7d e4 mov %edi,-0x1c(%ebp)
switch ( whence ) {
11cfe5: 83 f9 01 cmp $0x1,%ecx
11cfe8: 74 11 je 11cffb <lseek+0x5b>
11cfea: 83 f9 02 cmp $0x2,%ecx
11cfed: 74 18 je 11d007 <lseek+0x67>
11cfef: 85 c9 test %ecx,%ecx
11cff1: 75 26 jne 11d019 <lseek+0x79>
case SEEK_SET:
iop->offset = offset;
11cff3: 89 43 0c mov %eax,0xc(%ebx)
11cff6: 89 53 10 mov %edx,0x10(%ebx)
break;
11cff9: eb 30 jmp 11d02b <lseek+0x8b>
case SEEK_CUR:
iop->offset += offset;
11cffb: 8b 75 e0 mov -0x20(%ebp),%esi
11cffe: 8b 7d e4 mov -0x1c(%ebp),%edi
11d001: 01 c6 add %eax,%esi
11d003: 11 d7 adc %edx,%edi
11d005: eb 0a jmp 11d011 <lseek+0x71>
break;
case SEEK_END:
iop->offset = iop->size + offset;
11d007: 89 c6 mov %eax,%esi
11d009: 89 d7 mov %edx,%edi
11d00b: 03 73 04 add 0x4(%ebx),%esi
11d00e: 13 7b 08 adc 0x8(%ebx),%edi
11d011: 89 73 0c mov %esi,0xc(%ebx)
11d014: 89 7b 10 mov %edi,0x10(%ebx)
break;
11d017: eb 12 jmp 11d02b <lseek+0x8b>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
11d019: e8 1a 41 ff ff call 111138 <__errno>
11d01e: c7 00 16 00 00 00 movl $0x16,(%eax)
11d024: 83 c8 ff or $0xffffffff,%eax
11d027: 89 c2 mov %eax,%edx
11d029: eb 23 jmp 11d04e <lseek+0xae>
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
11d02b: 8b 73 20 mov 0x20(%ebx),%esi
11d02e: 51 push %ecx
11d02f: 52 push %edx
11d030: 50 push %eax
11d031: 53 push %ebx
11d032: ff 56 14 call *0x14(%esi)
if ( status == (off_t) -1 )
11d035: 83 c4 10 add $0x10,%esp
11d038: 83 fa ff cmp $0xffffffff,%edx
11d03b: 75 11 jne 11d04e <lseek+0xae>
11d03d: 83 f8 ff cmp $0xffffffff,%eax
11d040: 75 0c jne 11d04e <lseek+0xae> <== NEVER TAKEN
iop->offset = old_offset;
11d042: 8b 75 e0 mov -0x20(%ebp),%esi
11d045: 8b 7d e4 mov -0x1c(%ebp),%edi
11d048: 89 73 0c mov %esi,0xc(%ebx)
11d04b: 89 7b 10 mov %edi,0x10(%ebx)
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
11d04e: 8d 65 f4 lea -0xc(%ebp),%esp
11d051: 5b pop %ebx
11d052: 5e pop %esi
11d053: 5f pop %edi
11d054: c9 leave
11d055: c3 ret
00107614 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
107614: 55 push %ebp
107615: 89 e5 mov %esp,%ebp
107617: 56 push %esi
107618: 53 push %ebx
107619: 8b 75 08 mov 0x8(%ebp),%esi
void *return_this;
MSBUMP(malloc_calls, 1);
10761c: ff 05 14 52 12 00 incl 0x125214
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
107622: e8 07 ff ff ff call 10752e <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
return (void *) 0;
107627: 31 db xor %ebx,%ebx
malloc_deferred_frees_process();
/*
* Validate the parameters
*/
if ( !size )
107629: 85 f6 test %esi,%esi
10762b: 74 78 je 1076a5 <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()) &&
10762d: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c
107634: 75 09 jne 10763f <malloc+0x2b>
!malloc_is_system_state_OK() )
107636: e8 b5 fe ff ff call 1074f0 <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()) &&
10763b: 84 c0 test %al,%al
10763d: 74 66 je 1076a5 <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 );
10763f: 6a 00 push $0x0
107641: 6a 00 push $0x0
107643: 56 push %esi
107644: ff 35 80 11 12 00 pushl 0x121180
10764a: e8 7d 43 00 00 call 10b9cc <_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 ) {
10764f: 83 c4 10 add $0x10,%esp
107652: 89 c3 mov %eax,%ebx
107654: 85 c0 test %eax,%eax
107656: 75 28 jne 107680 <malloc+0x6c>
if (rtems_malloc_sbrk_helpers)
107658: a1 74 36 12 00 mov 0x123674,%eax
10765d: 85 c0 test %eax,%eax
10765f: 74 10 je 107671 <malloc+0x5d>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
107661: 83 ec 0c sub $0xc,%esp
107664: 56 push %esi
107665: ff 50 04 call *0x4(%eax)
107668: 89 c3 mov %eax,%ebx
if ( !return_this ) {
10766a: 83 c4 10 add $0x10,%esp
10766d: 85 c0 test %eax,%eax
10766f: 75 0f jne 107680 <malloc+0x6c>
errno = ENOMEM;
107671: e8 c2 9a 00 00 call 111138 <__errno>
107676: c7 00 0c 00 00 00 movl $0xc,(%eax)
return (void *) 0;
10767c: 31 db xor %ebx,%ebx
10767e: eb 25 jmp 1076a5 <malloc+0x91>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
107680: a1 78 36 12 00 mov 0x123678,%eax
107685: 85 c0 test %eax,%eax
107687: 74 09 je 107692 <malloc+0x7e>
(*rtems_malloc_dirty_helper)( return_this, size );
107689: 52 push %edx
10768a: 52 push %edx
10768b: 56 push %esi
10768c: 53 push %ebx
10768d: ff d0 call *%eax
10768f: 83 c4 10 add $0x10,%esp
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
107692: a1 70 36 12 00 mov 0x123670,%eax
107697: 85 c0 test %eax,%eax
107699: 74 0a je 1076a5 <malloc+0x91>
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
10769b: 83 ec 0c sub $0xc,%esp
10769e: 53 push %ebx
10769f: ff 50 04 call *0x4(%eax)
1076a2: 83 c4 10 add $0x10,%esp
return return_this;
}
1076a5: 89 d8 mov %ebx,%eax
1076a7: 8d 65 f8 lea -0x8(%ebp),%esp
1076aa: 5b pop %ebx
1076ab: 5e pop %esi
1076ac: c9 leave
1076ad: c3 ret
0010797c <malloc_sbrk_extend_and_allocate>:
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
10797c: 55 push %ebp
10797d: 89 e5 mov %esp,%ebp
10797f: 57 push %edi
107980: 56 push %esi
107981: 53 push %ebx
107982: 83 ec 0c sub $0xc,%esp
107985: 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;
107988: 8b 0d 94 53 12 00 mov 0x125394,%ecx
if ( sbrk_amount == 0 )
return (void *) 0;
10798e: 31 f6 xor %esi,%esi
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
107990: 85 c9 test %ecx,%ecx
107992: 74 67 je 1079fb <malloc_sbrk_extend_and_allocate+0x7f><== NEVER TAKEN
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
107994: 8d 1c 0f lea (%edi,%ecx,1),%ebx
107997: 89 d8 mov %ebx,%eax
107999: 31 d2 xor %edx,%edx
10799b: f7 f1 div %ecx
10799d: 89 c3 mov %eax,%ebx
10799f: 0f af d9 imul %ecx,%ebx
starting_address = (void *) sbrk(the_size);
1079a2: 83 ec 0c sub $0xc,%esp
1079a5: 53 push %ebx
1079a6: e8 a8 8a ff ff call 100453 <sbrk>
if ( starting_address == (void*) -1 )
1079ab: 83 c4 10 add $0x10,%esp
1079ae: 83 f8 ff cmp $0xffffffff,%eax
1079b1: 74 48 je 1079fb <malloc_sbrk_extend_and_allocate+0x7f>
return (void *) 0;
if ( !_Protected_heap_Extend(
1079b3: 52 push %edx
1079b4: 53 push %ebx
1079b5: 50 push %eax
1079b6: ff 35 80 11 12 00 pushl 0x121180
1079bc: e8 a3 43 00 00 call 10bd64 <_Protected_heap_Extend>
1079c1: 83 c4 10 add $0x10,%esp
1079c4: 84 c0 test %al,%al
1079c6: 75 18 jne 1079e0 <malloc_sbrk_extend_and_allocate+0x64>
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
1079c8: 83 ec 0c sub $0xc,%esp
1079cb: f7 db neg %ebx
1079cd: 53 push %ebx
1079ce: e8 80 8a ff ff call 100453 <sbrk>
errno = ENOMEM;
1079d3: e8 38 9d 00 00 call 111710 <__errno>
1079d8: c7 00 0c 00 00 00 movl $0xc,(%eax)
1079de: eb 18 jmp 1079f8 <malloc_sbrk_extend_and_allocate+0x7c>
return (void *) 0;
}
MSBUMP(space_available, the_size);
1079e0: 01 1d 68 53 12 00 add %ebx,0x125368
1079e6: 6a 00 push $0x0
1079e8: 6a 00 push $0x0
1079ea: 57 push %edi
1079eb: ff 35 80 11 12 00 pushl 0x121180
1079f1: e8 36 43 00 00 call 10bd2c <_Protected_heap_Allocate_aligned_with_boundary>
1079f6: 89 c6 mov %eax,%esi
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
1079f8: 83 c4 10 add $0x10,%esp
}
1079fb: 89 f0 mov %esi,%eax
1079fd: 8d 65 f4 lea -0xc(%ebp),%esp
107a00: 5b pop %ebx
107a01: 5e pop %esi
107a02: 5f pop %edi
107a03: c9 leave
107a04: c3 ret
0011041b <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
11041b: 55 push %ebp
11041c: 89 e5 mov %esp,%ebp
11041e: 53 push %ebx
11041f: 83 ec 14 sub $0x14,%esp
110422: 8b 4d 08 mov 0x8(%ebp),%ecx
110425: 8b 45 0c mov 0xc(%ebp),%eax
110428: 8b 55 10 mov 0x10(%ebp),%edx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
11042b: 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 )
11042e: 3b 53 54 cmp 0x54(%ebx),%edx
110431: 7c 15 jl 110448 <memfile_ftruncate+0x2d><== NEVER TAKEN
110433: 7f 05 jg 11043a <memfile_ftruncate+0x1f><== NEVER TAKEN
110435: 3b 43 50 cmp 0x50(%ebx),%eax
110438: 76 0e jbe 110448 <memfile_ftruncate+0x2d>
return IMFS_memfile_extend( the_jnode, length );
11043a: 51 push %ecx
11043b: 52 push %edx
11043c: 50 push %eax
11043d: 53 push %ebx
11043e: e8 bf fc ff ff call 110102 <IMFS_memfile_extend>
110443: 83 c4 10 add $0x10,%esp
110446: eb 24 jmp 11046c <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;
110448: 89 43 50 mov %eax,0x50(%ebx)
11044b: 89 53 54 mov %edx,0x54(%ebx)
iop->size = the_jnode->info.file.size;
11044e: 89 41 04 mov %eax,0x4(%ecx)
110451: 89 51 08 mov %edx,0x8(%ecx)
IMFS_update_atime( the_jnode );
110454: 50 push %eax
110455: 50 push %eax
110456: 6a 00 push $0x0
110458: 8d 45 f0 lea -0x10(%ebp),%eax
11045b: 50 push %eax
11045c: e8 8f 6f ff ff call 1073f0 <gettimeofday>
110461: 8b 45 f0 mov -0x10(%ebp),%eax
110464: 89 43 40 mov %eax,0x40(%ebx)
return 0;
110467: 83 c4 10 add $0x10,%esp
11046a: 31 c0 xor %eax,%eax
}
11046c: 8b 5d fc mov -0x4(%ebp),%ebx
11046f: c9 leave
110470: c3 ret
00110471 <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
110471: 55 push %ebp
110472: 89 e5 mov %esp,%ebp
110474: 56 push %esi
110475: 53 push %ebx
110476: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
110479: 8b 73 18 mov 0x18(%ebx),%esi
if (the_jnode->type == IMFS_LINEAR_FILE) {
11047c: 83 7e 4c 06 cmpl $0x6,0x4c(%esi)
110480: 75 1a jne 11049c <memfile_lseek+0x2b>
if (iop->offset > the_jnode->info.linearfile.size)
110482: 8b 56 50 mov 0x50(%esi),%edx
110485: 8b 46 54 mov 0x54(%esi),%eax
110488: 39 43 10 cmp %eax,0x10(%ebx)
11048b: 7c 41 jl 1104ce <memfile_lseek+0x5d> <== NEVER TAKEN
11048d: 7f 05 jg 110494 <memfile_lseek+0x23> <== NEVER TAKEN
11048f: 39 53 0c cmp %edx,0xc(%ebx)
110492: 76 3a jbe 1104ce <memfile_lseek+0x5d> <== ALWAYS TAKEN
iop->offset = the_jnode->info.linearfile.size;
110494: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED
110497: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED
11049a: eb 32 jmp 1104ce <memfile_lseek+0x5d> <== NOT EXECUTED
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
11049c: 50 push %eax
11049d: ff 73 10 pushl 0x10(%ebx)
1104a0: ff 73 0c pushl 0xc(%ebx)
1104a3: 56 push %esi
1104a4: e8 59 fc ff ff call 110102 <IMFS_memfile_extend>
1104a9: 83 c4 10 add $0x10,%esp
1104ac: 85 c0 test %eax,%eax
1104ae: 74 12 je 1104c2 <memfile_lseek+0x51>
rtems_set_errno_and_return_minus_one( ENOSPC );
1104b0: e8 83 0c 00 00 call 111138 <__errno>
1104b5: c7 00 1c 00 00 00 movl $0x1c,(%eax)
1104bb: 83 c8 ff or $0xffffffff,%eax
1104be: 89 c2 mov %eax,%edx
1104c0: eb 12 jmp 1104d4 <memfile_lseek+0x63>
iop->size = the_jnode->info.file.size;
1104c2: 8b 46 50 mov 0x50(%esi),%eax
1104c5: 8b 56 54 mov 0x54(%esi),%edx
1104c8: 89 43 04 mov %eax,0x4(%ebx)
1104cb: 89 53 08 mov %edx,0x8(%ebx)
}
return iop->offset;
1104ce: 8b 43 0c mov 0xc(%ebx),%eax
1104d1: 8b 53 10 mov 0x10(%ebx),%edx
}
1104d4: 8d 65 f8 lea -0x8(%ebp),%esp
1104d7: 5b pop %ebx
1104d8: 5e pop %esi
1104d9: c9 leave
1104da: c3 ret
0011038c <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
11038c: 55 push %ebp
11038d: 89 e5 mov %esp,%ebp
11038f: 56 push %esi
110390: 53 push %ebx
110391: 8b 75 08 mov 0x8(%ebp),%esi
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
110394: 8b 5e 18 mov 0x18(%esi),%ebx
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
110397: f7 46 14 04 02 00 00 testl $0x204,0x14(%esi)
11039e: 74 54 je 1103f4 <memfile_open+0x68>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
1103a0: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx)
1103a4: 75 4e jne 1103f4 <memfile_open+0x68> <== ALWAYS TAKEN
uint32_t count = the_jnode->info.linearfile.size;
1103a6: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
1103a9: 8b 53 58 mov 0x58(%ebx),%edx <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
1103ac: c7 43 4c 05 00 00 00 movl $0x5,0x4c(%ebx) <== NOT EXECUTED
the_jnode->info.file.size = 0;
1103b3: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED
1103ba: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
1103c1: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
1103c8: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
1103cf: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED
if ((count != 0)
1103d6: 85 c0 test %eax,%eax <== NOT EXECUTED
1103d8: 74 1a je 1103f4 <memfile_open+0x68> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
1103da: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1103dd: 50 push %eax <== NOT EXECUTED
1103de: 52 push %edx <== NOT EXECUTED
1103df: 6a 00 push $0x0 <== NOT EXECUTED
1103e1: 6a 00 push $0x0 <== NOT EXECUTED
1103e3: 53 push %ebx <== NOT EXECUTED
1103e4: e8 0b fe ff ff call 1101f4 <IMFS_memfile_write> <== NOT EXECUTED
1103e9: 89 c2 mov %eax,%edx <== NOT EXECUTED
1103eb: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
return -1;
1103ee: 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))
1103f1: 42 inc %edx <== NOT EXECUTED
1103f2: 74 20 je 110414 <memfile_open+0x88> <== NOT EXECUTED
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
1103f4: f6 46 15 02 testb $0x2,0x15(%esi)
1103f8: 74 0c je 110406 <memfile_open+0x7a>
iop->offset = the_jnode->info.file.size;
1103fa: 8b 43 50 mov 0x50(%ebx),%eax
1103fd: 8b 53 54 mov 0x54(%ebx),%edx
110400: 89 46 0c mov %eax,0xc(%esi)
110403: 89 56 10 mov %edx,0x10(%esi)
iop->size = the_jnode->info.file.size;
110406: 8b 43 50 mov 0x50(%ebx),%eax
110409: 8b 53 54 mov 0x54(%ebx),%edx
11040c: 89 46 04 mov %eax,0x4(%esi)
11040f: 89 56 08 mov %edx,0x8(%esi)
return 0;
110412: 31 c0 xor %eax,%eax
}
110414: 8d 65 f8 lea -0x8(%ebp),%esp
110417: 5b pop %ebx
110418: 5e pop %esi
110419: c9 leave
11041a: c3 ret
00107809 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
107809: 55 push %ebp
10780a: 89 e5 mov %esp,%ebp
10780c: 57 push %edi
10780d: 56 push %esi
10780e: 53 push %ebx
10780f: 83 ec 4c sub $0x4c,%esp
107812: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
107815: 83 7d 14 01 cmpl $0x1,0x14(%ebp)
107819: 77 13 ja 10782e <mount+0x25>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
10781b: 83 ec 0c sub $0xc,%esp
10781e: 56 push %esi
10781f: e8 83 6c 00 00 call 10e4a7 <rtems_filesystem_get_mount_handler>
107824: 89 45 b0 mov %eax,-0x50(%ebp)
if ( !mount_h )
107827: 83 c4 10 add $0x10,%esp
10782a: 85 c0 test %eax,%eax
10782c: 75 10 jne 10783e <mount+0x35>
rtems_set_errno_and_return_minus_one( EINVAL );
10782e: e8 05 99 00 00 call 111138 <__errno>
107833: c7 00 16 00 00 00 movl $0x16,(%eax)
107839: e9 ca 00 00 00 jmp 107908 <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;
10783e: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
107842: 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 : "/";
107846: 8b 45 0c mov 0xc(%ebp),%eax
107849: 89 45 b8 mov %eax,-0x48(%ebp)
10784c: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
107850: 75 07 jne 107859 <mount+0x50>
107852: c7 45 b8 80 ef 11 00 movl $0x11ef80,-0x48(%ebp)
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
107859: 83 ca ff or $0xffffffff,%edx
10785c: 31 c0 xor %eax,%eax
10785e: 89 d1 mov %edx,%ecx
107860: 89 f7 mov %esi,%edi
107862: f2 ae repnz scas %es:(%edi),%al
107864: f7 d1 not %ecx
107866: 89 4d bc mov %ecx,-0x44(%ebp)
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
107869: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
107870: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
107874: 74 0c je 107882 <mount+0x79>
107876: 89 d1 mov %edx,%ecx
107878: 8b 7d 08 mov 0x8(%ebp),%edi
10787b: f2 ae repnz scas %es:(%edi),%al
10787d: f7 d1 not %ecx
10787f: 89 4d c4 mov %ecx,-0x3c(%ebp)
size_t target_size = strlen( target ) + 1;
107882: 31 c0 xor %eax,%eax
107884: 83 c9 ff or $0xffffffff,%ecx
107887: 8b 7d b8 mov -0x48(%ebp),%edi
10788a: f2 ae repnz scas %es:(%edi),%al
10788c: f7 d1 not %ecx
10788e: 89 4d c0 mov %ecx,-0x40(%ebp)
107891: 49 dec %ecx
107892: 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 );
107895: 50 push %eax
107896: 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;
107897: 8b 55 c4 mov -0x3c(%ebp),%edx
10789a: 8b 7d bc mov -0x44(%ebp),%edi
10789d: 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 )
1078a1: 03 45 c0 add -0x40(%ebp),%eax
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
1078a4: 50 push %eax
1078a5: 6a 01 push $0x1
1078a7: e8 60 f9 ff ff call 10720c <calloc>
1078ac: 89 c3 mov %eax,%ebx
if ( mt_entry != NULL ) {
1078ae: 83 c4 10 add $0x10,%esp
1078b1: 85 c0 test %eax,%eax
1078b3: 74 48 je 1078fd <mount+0xf4> <== NEVER TAKEN
char *str = (char *) mt_entry + sizeof( *mt_entry );
1078b5: 8d 40 74 lea 0x74(%eax),%eax
memcpy( str, filesystemtype, filesystemtype_size );
1078b8: 89 c7 mov %eax,%edi
1078ba: 8b 4d bc mov -0x44(%ebp),%ecx
1078bd: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
1078bf: 89 fa mov %edi,%edx
mt_entry->type = str;
1078c1: 89 43 6c mov %eax,0x6c(%ebx)
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
1078c4: 8b 75 08 mov 0x8(%ebp),%esi
1078c7: 8b 4d c4 mov -0x3c(%ebp),%ecx
1078ca: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
1078cc: 89 f8 mov %edi,%eax
mt_entry->dev = str;
1078ce: 89 53 70 mov %edx,0x70(%ebx)
str += source_size;
memcpy( str, target, target_size );
1078d1: 8b 75 b8 mov -0x48(%ebp),%esi
1078d4: 8b 4d c0 mov -0x40(%ebp),%ecx
1078d7: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
mt_entry->target = str;
1078d9: 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;
1078dc: 89 5b 2c mov %ebx,0x2c(%ebx)
mt_entry->options = options;
1078df: 8b 45 14 mov 0x14(%ebp),%eax
1078e2: 89 43 30 mov %eax,0x30(%ebx)
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
1078e5: 8d 7b 38 lea 0x38(%ebx),%edi
1078e8: be c0 ef 11 00 mov $0x11efc0,%esi
1078ed: b1 0c mov $0xc,%cl
1078ef: 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 ) {
1078f1: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
1078f5: 0f 84 a3 00 00 00 je 10799e <mount+0x195>
1078fb: eb 13 jmp 107910 <mount+0x107>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
1078fd: e8 36 98 00 00 call 111138 <__errno> <== NOT EXECUTED
107902: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
107908: 83 c8 ff or $0xffffffff,%eax
10790b: e9 26 01 00 00 jmp 107a36 <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(
107910: 83 ec 0c sub $0xc,%esp
107913: 6a 01 push $0x1
107915: 8d 75 d4 lea -0x2c(%ebp),%esi
107918: 56 push %esi
107919: 6a 07 push $0x7
10791b: ff 75 ac pushl -0x54(%ebp)
10791e: ff 75 0c pushl 0xc(%ebp)
107921: e8 80 f9 ff ff call 1072a6 <rtems_filesystem_evaluate_path>
107926: 83 c4 20 add $0x20,%esp
107929: 40 inc %eax
10792a: 0f 84 df 00 00 00 je 107a0f <mount+0x206> <== NEVER TAKEN
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
107930: 83 ec 0c sub $0xc,%esp
107933: 56 push %esi
107934: 8b 45 e0 mov -0x20(%ebp),%eax
107937: ff 50 10 call *0x10(%eax)
10793a: 83 c4 10 add $0x10,%esp
10793d: 48 dec %eax
10793e: 74 10 je 107950 <mount+0x147>
errno = ENOTDIR;
107940: e8 f3 97 00 00 call 111138 <__errno>
107945: c7 00 14 00 00 00 movl $0x14,(%eax)
goto cleanup_and_bail;
10794b: e9 c1 00 00 00 jmp 107a11 <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 ) ) {
107950: 57 push %edi
107951: 57 push %edi
107952: ff 75 d4 pushl -0x2c(%ebp)
107955: 68 80 77 10 00 push $0x107780
10795a: e8 62 fe ff ff call 1077c1 <rtems_filesystem_mount_iterate>
10795f: 83 c4 10 add $0x10,%esp
107962: 84 c0 test %al,%al
107964: 74 10 je 107976 <mount+0x16d>
errno = EBUSY;
107966: e8 cd 97 00 00 call 111138 <__errno>
10796b: c7 00 10 00 00 00 movl $0x10,(%eax)
goto cleanup_and_bail;
107971: e9 9b 00 00 00 jmp 107a11 <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;
107976: 8b 45 d4 mov -0x2c(%ebp),%eax
107979: 89 43 08 mov %eax,0x8(%ebx)
mt_entry->mt_point_node.handlers = loc.handlers;
10797c: 8b 45 dc mov -0x24(%ebp),%eax
10797f: 89 43 10 mov %eax,0x10(%ebx)
mt_entry->mt_point_node.ops = loc.ops;
107982: 8b 45 e0 mov -0x20(%ebp),%eax
107985: 89 43 14 mov %eax,0x14(%ebx)
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
107988: 8b 55 e4 mov -0x1c(%ebp),%edx
10798b: 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 ) ) {
10798e: 83 ec 0c sub $0xc,%esp
107991: 53 push %ebx
107992: ff 50 20 call *0x20(%eax)
107995: 83 c4 10 add $0x10,%esp
107998: 85 c0 test %eax,%eax
10799a: 74 1d je 1079b9 <mount+0x1b0> <== ALWAYS TAKEN
10799c: eb 73 jmp 107a11 <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;
10799e: 31 f6 xor %esi,%esi
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
1079a0: 81 3d 64 2f 12 00 68 cmpl $0x122f68,0x122f64
1079a7: 2f 12 00
1079aa: 74 0d je 1079b9 <mount+0x1b0> <== ALWAYS TAKEN
errno = EINVAL;
1079ac: e8 87 97 00 00 call 111138 <__errno> <== NOT EXECUTED
1079b1: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
goto cleanup_and_bail;
1079b7: eb 58 jmp 107a11 <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 ) ) {
1079b9: 51 push %ecx
1079ba: 51 push %ecx
1079bb: ff 75 18 pushl 0x18(%ebp)
1079be: 53 push %ebx
1079bf: ff 55 b0 call *-0x50(%ebp)
1079c2: 83 c4 10 add $0x10,%esp
1079c5: 85 c0 test %eax,%eax
1079c7: 74 0f je 1079d8 <mount+0x1cf>
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
1079c9: 83 ec 0c sub $0xc,%esp
1079cc: 53 push %ebx
1079cd: 8b 45 e0 mov -0x20(%ebp),%eax
1079d0: ff 50 28 call *0x28(%eax)
goto cleanup_and_bail;
1079d3: 83 c4 10 add $0x10,%esp
1079d6: eb 39 jmp 107a11 <mount+0x208>
}
/*
* Add the mount table entry to the mount table chain
*/
rtems_libio_lock();
1079d8: e8 b4 fd ff ff call 107791 <rtems_libio_lock>
1079dd: 52 push %edx
1079de: 52 push %edx
1079df: 53 push %ebx
1079e0: 68 64 2f 12 00 push $0x122f64
1079e5: e8 4a 30 00 00 call 10aa34 <_Chain_Append>
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
1079ea: e8 bc fd ff ff call 1077ab <rtems_libio_unlock>
if ( !has_target )
1079ef: 83 c4 10 add $0x10,%esp
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
1079f2: 31 c0 xor %eax,%eax
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
1079f4: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
1079f8: 75 3c jne 107a36 <mount+0x22d>
rtems_filesystem_root = mt_entry->mt_fs_root;
1079fa: 8b 3d 80 30 12 00 mov 0x123080,%edi
107a00: 83 c7 18 add $0x18,%edi
107a03: 8d 73 1c lea 0x1c(%ebx),%esi
107a06: b9 05 00 00 00 mov $0x5,%ecx
107a0b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
107a0d: eb 27 jmp 107a36 <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;
107a0f: 31 f6 xor %esi,%esi
return 0;
cleanup_and_bail:
free( mt_entry );
107a11: 83 ec 0c sub $0xc,%esp
107a14: 53 push %ebx
107a15: e8 5e f9 ff ff call 107378 <free>
if ( loc_to_free )
107a1a: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( loc_to_free );
return -1;
107a1d: 83 c8 ff or $0xffffffff,%eax
cleanup_and_bail:
free( mt_entry );
if ( loc_to_free )
107a20: 85 f6 test %esi,%esi
107a22: 74 12 je 107a36 <mount+0x22d> <== NEVER TAKEN
rtems_filesystem_freenode( loc_to_free );
107a24: 83 ec 0c sub $0xc,%esp
107a27: 56 push %esi
107a28: 89 45 a8 mov %eax,-0x58(%ebp)
107a2b: e8 34 f9 ff ff call 107364 <rtems_filesystem_freenode>
107a30: 83 c4 10 add $0x10,%esp
107a33: 8b 45 a8 mov -0x58(%ebp),%eax
return -1;
}
107a36: 8d 65 f4 lea -0xc(%ebp),%esp
107a39: 5b pop %ebx
107a3a: 5e pop %esi
107a3b: 5f pop %edi
107a3c: c9 leave
107a3d: c3 ret
00107d90 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
107d90: 55 push %ebp
107d91: 89 e5 mov %esp,%ebp
107d93: 57 push %edi
107d94: 56 push %esi
107d95: 53 push %ebx
107d96: 83 ec 1c sub $0x1c,%esp
107d99: 8b 4d 08 mov 0x8(%ebp),%ecx
107d9c: 8b 5d 0c mov 0xc(%ebp),%ebx
107d9f: 8b 75 10 mov 0x10(%ebp),%esi
107da2: 8b 7d 14 mov 0x14(%ebp),%edi
107da5: 8b 55 18 mov 0x18(%ebp),%edx
int rv = -1;
if (target != NULL) {
107da8: 85 db test %ebx,%ebx
107daa: 74 3b je 107de7 <mount_and_make_target_path+0x57>
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
107dac: 50 push %eax
107dad: 50 push %eax
107dae: 68 ff 01 00 00 push $0x1ff
107db3: 53 push %ebx
107db4: 89 55 e0 mov %edx,-0x20(%ebp)
107db7: 89 4d e4 mov %ecx,-0x1c(%ebp)
107dba: e8 bd 08 00 00 call 10867c <rtems_mkdir>
if (rv == 0) {
107dbf: 83 c4 10 add $0x10,%esp
107dc2: 85 c0 test %eax,%eax
107dc4: 8b 55 e0 mov -0x20(%ebp),%edx
107dc7: 8b 4d e4 mov -0x1c(%ebp),%ecx
107dca: 75 29 jne 107df5 <mount_and_make_target_path+0x65><== NEVER TAKEN
rv = mount(
107dcc: 89 55 18 mov %edx,0x18(%ebp)
107dcf: 89 7d 14 mov %edi,0x14(%ebp)
107dd2: 89 75 10 mov %esi,0x10(%ebp)
107dd5: 89 5d 0c mov %ebx,0xc(%ebp)
107dd8: 89 4d 08 mov %ecx,0x8(%ebp)
} else {
errno = EINVAL;
}
return rv;
}
107ddb: 8d 65 f4 lea -0xc(%ebp),%esp
107dde: 5b pop %ebx
107ddf: 5e pop %esi
107de0: 5f pop %edi
107de1: c9 leave
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
107de2: e9 a2 00 00 00 jmp 107e89 <mount>
options,
data
);
}
} else {
errno = EINVAL;
107de7: e8 c8 99 00 00 call 1117b4 <__errno>
107dec: c7 00 16 00 00 00 movl $0x16,(%eax)
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
107df2: 83 c8 ff or $0xffffffff,%eax
} else {
errno = EINVAL;
}
return rv;
}
107df5: 8d 65 f4 lea -0xc(%ebp),%esp
107df8: 5b pop %ebx
107df9: 5e pop %esi
107dfa: 5f pop %edi
107dfb: c9 leave
107dfc: c3 ret
00107a99 <newlib_create_hook>:
*/
bool newlib_create_hook(
rtems_tcb *current_task __attribute__((unused)),
rtems_tcb *creating_task
)
{
107a99: 55 push %ebp
107a9a: 89 e5 mov %esp,%ebp
107a9c: 57 push %edi
107a9d: 56 push %esi
107a9e: 53 push %ebx
107a9f: 83 ec 1c sub $0x1c,%esp
struct _reent *ptr;
if (_Thread_libc_reent == 0)
107aa2: 83 3d c8 53 12 00 00 cmpl $0x0,0x1253c8
107aa9: 75 14 jne 107abf <newlib_create_hook+0x26>
{
_REENT = _global_impure_ptr;
107aab: a1 80 fa 11 00 mov 0x11fa80,%eax
107ab0: 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;
107ab5: c7 05 c8 53 12 00 40 movl $0x123140,0x1253c8
107abc: 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));
107abf: 83 ec 0c sub $0xc,%esp
107ac2: 68 24 04 00 00 push $0x424
107ac7: e8 7e 55 00 00 call 10d04a <_Workspace_Allocate>
107acc: 89 c2 mov %eax,%edx
#endif
if (ptr) {
107ace: 83 c4 10 add $0x10,%esp
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
creating_task->libc_reent = ptr;
return TRUE;
}
return FALSE;
107ad1: 31 c0 xor %eax,%eax
* hooks run with thread dispatching disabled.
*/
ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent));
#endif
if (ptr) {
107ad3: 85 d2 test %edx,%edx
107ad5: 0f 84 28 02 00 00 je 107d03 <newlib_create_hook+0x26a><== NEVER TAKEN
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
107adb: c7 02 00 00 00 00 movl $0x0,(%edx)
107ae1: 8d b2 ec 02 00 00 lea 0x2ec(%edx),%esi
107ae7: 89 72 04 mov %esi,0x4(%edx)
107aea: 8d 8a 54 03 00 00 lea 0x354(%edx),%ecx
107af0: 89 4a 08 mov %ecx,0x8(%edx)
107af3: 8d 8a bc 03 00 00 lea 0x3bc(%edx),%ecx
107af9: 89 4a 0c mov %ecx,0xc(%edx)
107afc: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
107b03: 8d 4a 14 lea 0x14(%edx),%ecx
107b06: bb 19 00 00 00 mov $0x19,%ebx
107b0b: 89 cf mov %ecx,%edi
107b0d: 89 d9 mov %ebx,%ecx
107b0f: f3 aa rep stos %al,%es:(%edi)
107b11: 89 cb mov %ecx,%ebx
107b13: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx)
107b1a: c7 42 34 12 ed 11 00 movl $0x11ed12,0x34(%edx)
107b21: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx)
107b28: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx)
107b2f: c7 42 40 00 00 00 00 movl $0x0,0x40(%edx)
107b36: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx)
107b3d: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx)
107b44: c7 42 4c 00 00 00 00 movl $0x0,0x4c(%edx)
107b4b: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx)
107b52: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx)
107b59: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx)
107b60: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx)
107b67: c6 42 60 00 movb $0x0,0x60(%edx)
107b6b: 8d 42 7c lea 0x7c(%edx),%eax
107b6e: 89 45 e4 mov %eax,-0x1c(%ebp)
107b71: b1 09 mov $0x9,%cl
107b73: 89 c7 mov %eax,%edi
107b75: 89 d8 mov %ebx,%eax
107b77: f3 ab rep stos %eax,%es:(%edi)
107b79: c7 82 a0 00 00 00 00 movl $0x0,0xa0(%edx)
107b80: 00 00 00
107b83: c7 82 a4 00 00 00 01 movl $0x1,0xa4(%edx)
107b8a: 00 00 00
107b8d: c7 82 a8 00 00 00 00 movl $0x0,0xa8(%edx)
107b94: 00 00 00
107b97: 66 c7 82 ac 00 00 00 movw $0x330e,0xac(%edx)
107b9e: 0e 33
107ba0: 66 c7 82 ae 00 00 00 movw $0xabcd,0xae(%edx)
107ba7: cd ab
107ba9: 66 c7 82 b0 00 00 00 movw $0x1234,0xb0(%edx)
107bb0: 34 12
107bb2: 66 c7 82 b2 00 00 00 movw $0xe66d,0xb2(%edx)
107bb9: 6d e6
107bbb: 66 c7 82 b4 00 00 00 movw $0xdeec,0xb4(%edx)
107bc2: ec de
107bc4: 66 c7 82 b6 00 00 00 movw $0x5,0xb6(%edx)
107bcb: 05 00
107bcd: 66 c7 82 b8 00 00 00 movw $0xb,0xb8(%edx)
107bd4: 0b 00
107bd6: c7 82 bc 00 00 00 00 movl $0x0,0xbc(%edx)
107bdd: 00 00 00
107be0: c7 82 c0 00 00 00 00 movl $0x0,0xc0(%edx)
107be7: 00 00 00
107bea: c7 82 c4 00 00 00 00 movl $0x0,0xc4(%edx)
107bf1: 00 00 00
107bf4: c7 82 c8 00 00 00 00 movl $0x0,0xc8(%edx)
107bfb: 00 00 00
107bfe: c7 82 cc 00 00 00 00 movl $0x0,0xcc(%edx)
107c05: 00 00 00
107c08: c7 82 d0 00 00 00 00 movl $0x0,0xd0(%edx)
107c0f: 00 00 00
107c12: c7 82 f8 00 00 00 00 movl $0x0,0xf8(%edx)
107c19: 00 00 00
107c1c: c7 82 fc 00 00 00 00 movl $0x0,0xfc(%edx)
107c23: 00 00 00
107c26: c7 82 00 01 00 00 00 movl $0x0,0x100(%edx)
107c2d: 00 00 00
107c30: c7 82 04 01 00 00 00 movl $0x0,0x104(%edx)
107c37: 00 00 00
107c3a: c7 82 08 01 00 00 00 movl $0x0,0x108(%edx)
107c41: 00 00 00
107c44: c7 82 0c 01 00 00 00 movl $0x0,0x10c(%edx)
107c4b: 00 00 00
107c4e: c7 82 10 01 00 00 00 movl $0x0,0x110(%edx)
107c55: 00 00 00
107c58: c7 82 14 01 00 00 00 movl $0x0,0x114(%edx)
107c5f: 00 00 00
107c62: c7 82 18 01 00 00 00 movl $0x0,0x118(%edx)
107c69: 00 00 00
107c6c: c7 82 1c 01 00 00 00 movl $0x0,0x11c(%edx)
107c73: 00 00 00
107c76: c6 82 d4 00 00 00 00 movb $0x0,0xd4(%edx)
107c7d: c6 82 dc 00 00 00 00 movb $0x0,0xdc(%edx)
107c84: c7 82 f4 00 00 00 00 movl $0x0,0xf4(%edx)
107c8b: 00 00 00
107c8e: c7 82 48 01 00 00 00 movl $0x0,0x148(%edx)
107c95: 00 00 00
107c98: c7 82 4c 01 00 00 00 movl $0x0,0x14c(%edx)
107c9f: 00 00 00
107ca2: c7 82 50 01 00 00 00 movl $0x0,0x150(%edx)
107ca9: 00 00 00
107cac: c7 82 54 01 00 00 00 movl $0x0,0x154(%edx)
107cb3: 00 00 00
107cb6: c7 82 d4 02 00 00 00 movl $0x0,0x2d4(%edx)
107cbd: 00 00 00
107cc0: c7 82 d4 01 00 00 00 movl $0x0,0x1d4(%edx)
107cc7: 00 00 00
107cca: c7 82 dc 02 00 00 00 movl $0x0,0x2dc(%edx)
107cd1: 00 00 00
107cd4: c7 82 e0 02 00 00 00 movl $0x0,0x2e0(%edx)
107cdb: 00 00 00
107cde: c7 82 e4 02 00 00 00 movl $0x0,0x2e4(%edx)
107ce5: 00 00 00
107ce8: c7 82 e8 02 00 00 00 movl $0x0,0x2e8(%edx)
107cef: 00 00 00
107cf2: b1 4e mov $0x4e,%cl
107cf4: 89 f7 mov %esi,%edi
107cf6: f3 ab rep stos %eax,%es:(%edi)
creating_task->libc_reent = ptr;
107cf8: 8b 45 0c mov 0xc(%ebp),%eax
107cfb: 89 90 e4 00 00 00 mov %edx,0xe4(%eax)
return TRUE;
107d01: b0 01 mov $0x1,%al
}
return FALSE;
}
107d03: 8d 65 f4 lea -0xc(%ebp),%esp
107d06: 5b pop %ebx
107d07: 5e pop %esi
107d08: 5f pop %edi
107d09: c9 leave
107d0a: c3 ret
00107d0b <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
107d0b: 55 push %ebp
107d0c: 89 e5 mov %esp,%ebp
107d0e: 57 push %edi
107d0f: 56 push %esi
107d10: 53 push %ebx
107d11: 83 ec 0c sub $0xc,%esp
107d14: 8b 7d 08 mov 0x8(%ebp),%edi
107d17: 8b 75 0c mov 0xc(%ebp),%esi
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
107d1a: 39 f7 cmp %esi,%edi
107d1c: 75 08 jne 107d26 <newlib_delete_hook+0x1b>
ptr = _REENT;
107d1e: 8b 1d 40 31 12 00 mov 0x123140,%ebx
107d24: eb 06 jmp 107d2c <newlib_delete_hook+0x21>
} else {
ptr = deleted_task->libc_reent;
107d26: 8b 9e e4 00 00 00 mov 0xe4(%esi),%ebx
}
if (ptr && ptr != _global_impure_ptr) {
107d2c: 85 db test %ebx,%ebx
107d2e: 74 20 je 107d50 <newlib_delete_hook+0x45><== NEVER TAKEN
107d30: 3b 1d 80 fa 11 00 cmp 0x11fa80,%ebx
107d36: 74 18 je 107d50 <newlib_delete_hook+0x45>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
107d38: 50 push %eax
107d39: 50 push %eax
107d3a: 68 48 7a 10 00 push $0x107a48
107d3f: 53 push %ebx
107d40: e8 db 9b 00 00 call 111920 <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
107d45: 89 1c 24 mov %ebx,(%esp)
107d48: e8 16 53 00 00 call 10d063 <_Workspace_Free>
107d4d: 83 c4 10 add $0x10,%esp
#endif
}
deleted_task->libc_reent = NULL;
107d50: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi)
107d57: 00 00 00
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
107d5a: 39 f7 cmp %esi,%edi
107d5c: 75 0a jne 107d68 <newlib_delete_hook+0x5d>
_REENT = 0;
107d5e: c7 05 40 31 12 00 00 movl $0x0,0x123140
107d65: 00 00 00
}
}
107d68: 8d 65 f4 lea -0xc(%ebp),%esp
107d6b: 5b pop %ebx
107d6c: 5e pop %esi
107d6d: 5f pop %edi
107d6e: c9 leave
107d6f: c3 ret
00107a48 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
107a48: 55 push %ebp
107a49: 89 e5 mov %esp,%ebp
107a4b: 53 push %ebx
107a4c: 83 ec 10 sub $0x10,%esp
107a4f: 8b 5d 08 mov 0x8(%ebp),%ebx
switch ( fileno(fp) ) {
107a52: 53 push %ebx
107a53: e8 b4 9a 00 00 call 11150c <fileno>
107a58: 83 c4 10 add $0x10,%esp
107a5b: 83 f8 02 cmp $0x2,%eax
107a5e: 77 26 ja 107a86 <newlib_free_buffers+0x3e><== NEVER TAKEN
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
107a60: f6 43 0c 80 testb $0x80,0xc(%ebx)
107a64: 74 2c je 107a92 <newlib_free_buffers+0x4a><== ALWAYS TAKEN
free( fp->_bf._base );
107a66: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107a69: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
107a6c: e8 07 f9 ff ff call 107378 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
107a71: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
107a77: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED
107a7d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED
107a84: eb 09 jmp 107a8f <newlib_free_buffers+0x47><== NOT EXECUTED
}
break;
default:
fclose(fp);
107a86: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107a89: 53 push %ebx <== NOT EXECUTED
107a8a: e8 01 98 00 00 call 111290 <fclose> <== NOT EXECUTED
107a8f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return 0;
}
107a92: 31 c0 xor %eax,%eax
107a94: 8b 5d fc mov -0x4(%ebp),%ebx
107a97: c9 leave
107a98: c3 ret
00107dd0 <open>:
int open(
const char *pathname,
int flags,
...
)
{
107dd0: 55 push %ebp
107dd1: 89 e5 mov %esp,%ebp
107dd3: 57 push %edi
107dd4: 56 push %esi
107dd5: 53 push %ebx
107dd6: 83 ec 3c sub $0x3c,%esp
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
107dd9: 8b 45 0c mov 0xc(%ebp),%eax
107ddc: 40 inc %eax
if ( ( status & _FREAD ) == _FREAD )
107ddd: 89 c6 mov %eax,%esi
107ddf: 83 e6 01 and $0x1,%esi
eval_flags |= RTEMS_LIBIO_PERMS_READ;
107de2: f7 de neg %esi
107de4: 83 e6 04 and $0x4,%esi
if ( ( status & _FWRITE ) == _FWRITE )
107de7: a8 02 test $0x2,%al
107de9: 74 03 je 107dee <open+0x1e>
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
107deb: 83 ce 02 or $0x2,%esi
va_start(ap, flags);
mode = va_arg( ap, int );
107dee: 8b 45 10 mov 0x10(%ebp),%eax
107df1: 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();
107df4: e8 92 64 00 00 call 10e28b <rtems_libio_allocate>
107df9: 89 c3 mov %eax,%ebx
if ( iop == 0 ) {
107dfb: 85 c0 test %eax,%eax
107dfd: 0f 84 56 01 00 00 je 107f59 <open+0x189>
}
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
107e03: 83 c9 ff or $0xffffffff,%ecx
107e06: 8b 7d 08 mov 0x8(%ebp),%edi
107e09: 31 c0 xor %eax,%eax
107e0b: f2 ae repnz scas %es:(%edi),%al
107e0d: f7 d1 not %ecx
107e0f: 49 dec %ecx
107e10: 83 ec 0c sub $0xc,%esp
107e13: 6a 01 push $0x1
107e15: 8d 45 d4 lea -0x2c(%ebp),%eax
107e18: 50 push %eax
107e19: 56 push %esi
107e1a: 51 push %ecx
107e1b: ff 75 08 pushl 0x8(%ebp)
107e1e: e8 83 f4 ff ff call 1072a6 <rtems_filesystem_evaluate_path>
107e23: 89 c6 mov %eax,%esi
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
107e25: 83 c4 20 add $0x20,%esp
107e28: 83 f8 ff cmp $0xffffffff,%eax
107e2b: 75 6c jne 107e99 <open+0xc9>
if ( errno != ENOENT ) {
107e2d: e8 06 93 00 00 call 111138 <__errno>
107e32: 83 38 02 cmpl $0x2,(%eax)
107e35: 75 27 jne 107e5e <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) ) {
107e37: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
107e3e: 0f 84 1c 01 00 00 je 107f60 <open+0x190>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
107e44: 6a 00 push $0x0
107e46: 6a 00 push $0x0
107e48: 8b 45 c4 mov -0x3c(%ebp),%eax
107e4b: 80 cc 80 or $0x80,%ah
107e4e: 50 push %eax
107e4f: ff 75 08 pushl 0x8(%ebp)
107e52: e8 75 f8 ff ff call 1076cc <mknod>
if ( rc ) {
107e57: 83 c4 10 add $0x10,%esp
107e5a: 85 c0 test %eax,%eax
107e5c: 74 0e je 107e6c <open+0x9c> <== ALWAYS TAKEN
rc = errno;
107e5e: e8 d5 92 00 00 call 111138 <__errno>
107e63: 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;
107e65: 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;
107e67: e9 10 01 00 00 jmp 107f7c <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(
107e6c: 89 f1 mov %esi,%ecx
107e6e: 8b 7d 08 mov 0x8(%ebp),%edi
107e71: 31 c0 xor %eax,%eax
107e73: f2 ae repnz scas %es:(%edi),%al
107e75: f7 d1 not %ecx
107e77: 49 dec %ecx
107e78: 83 ec 0c sub $0xc,%esp
107e7b: 6a 01 push $0x1
107e7d: 8d 45 d4 lea -0x2c(%ebp),%eax
107e80: 50 push %eax
107e81: 6a 00 push $0x0
107e83: 51 push %ecx
107e84: ff 75 08 pushl 0x8(%ebp)
107e87: e8 1a f4 ff ff call 1072a6 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
107e8c: 83 c4 20 add $0x20,%esp
107e8f: 85 c0 test %eax,%eax
107e91: 0f 85 d2 00 00 00 jne 107f69 <open+0x199> <== NEVER TAKEN
107e97: eb 13 jmp 107eac <open+0xdc>
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
107e99: 8b 45 0c mov 0xc(%ebp),%eax
107e9c: 25 00 0a 00 00 and $0xa00,%eax
107ea1: 3d 00 0a 00 00 cmp $0xa00,%eax
107ea6: 0f 84 c6 00 00 00 je 107f72 <open+0x1a2>
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
107eac: 8b 73 14 mov 0x14(%ebx),%esi
107eaf: 83 ec 0c sub $0xc,%esp
107eb2: ff 75 0c pushl 0xc(%ebp)
107eb5: e8 5e 63 00 00 call 10e218 <rtems_libio_fcntl_flags>
107eba: 09 f0 or %esi,%eax
107ebc: 89 43 14 mov %eax,0x14(%ebx)
iop->pathinfo = loc;
107ebf: 8d 7b 18 lea 0x18(%ebx),%edi
107ec2: 8d 75 d4 lea -0x2c(%ebp),%esi
107ec5: b9 05 00 00 00 mov $0x5,%ecx
107eca: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
107ecc: 8b 43 20 mov 0x20(%ebx),%eax
107ecf: ff 75 c4 pushl -0x3c(%ebp)
107ed2: ff 75 0c pushl 0xc(%ebp)
107ed5: ff 75 08 pushl 0x8(%ebp)
107ed8: 53 push %ebx
107ed9: ff 10 call *(%eax)
if ( rc ) {
107edb: 83 c4 20 add $0x20,%esp
107ede: 85 c0 test %eax,%eax
107ee0: 74 0f je 107ef1 <open+0x121>
rc = errno;
107ee2: e8 51 92 00 00 call 111138 <__errno>
107ee7: 8b 30 mov (%eax),%esi
rc = EEXIST;
loc_to_free = &loc;
goto done;
}
loc_to_free = &loc;
107ee9: 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;
107eec: e9 8b 00 00 00 jmp 107f7c <open+0x1ac>
}
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
107ef1: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
107ef8: 0f 84 ae 00 00 00 je 107fac <open+0x1dc>
rc = ftruncate( iop - rtems_libio_iops, 0 );
107efe: 50 push %eax
107eff: 6a 00 push $0x0
107f01: 6a 00 push $0x0
107f03: 89 d8 mov %ebx,%eax
107f05: 2b 05 f8 51 12 00 sub 0x1251f8,%eax
107f0b: c1 f8 03 sar $0x3,%eax
107f0e: 69 c0 b7 6d db b6 imul $0xb6db6db7,%eax,%eax
107f14: 50 push %eax
107f15: e8 16 62 00 00 call 10e130 <ftruncate>
107f1a: 89 c6 mov %eax,%esi
if ( rc ) {
107f1c: 83 c4 10 add $0x10,%esp
107f1f: 85 c0 test %eax,%eax
107f21: 0f 84 85 00 00 00 je 107fac <open+0x1dc>
if(errno) rc = errno;
107f27: e8 0c 92 00 00 call 111138 <__errno>
107f2c: 83 38 00 cmpl $0x0,(%eax)
107f2f: 74 07 je 107f38 <open+0x168> <== NEVER TAKEN
107f31: e8 02 92 00 00 call 111138 <__errno>
107f36: 8b 30 mov (%eax),%esi
close( iop - rtems_libio_iops );
107f38: 83 ec 0c sub $0xc,%esp
107f3b: 2b 1d f8 51 12 00 sub 0x1251f8,%ebx
107f41: c1 fb 03 sar $0x3,%ebx
107f44: 69 db b7 6d db b6 imul $0xb6db6db7,%ebx,%ebx
107f4a: 53 push %ebx
107f4b: e8 70 61 00 00 call 10e0c0 <close>
107f50: 83 c4 10 add $0x10,%esp
/* those are released by close(): */
iop = 0;
loc_to_free = NULL;
107f53: 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;
107f55: 31 db xor %ebx,%ebx
107f57: eb 23 jmp 107f7c <open+0x1ac>
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
rc = ENFILE;
107f59: be 17 00 00 00 mov $0x17,%esi
107f5e: eb 40 jmp 107fa0 <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;
107f60: 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;
107f62: be 02 00 00 00 mov $0x2,%esi
107f67: eb 17 jmp 107f80 <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;
107f69: 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;
107f6b: be 0d 00 00 00 mov $0xd,%esi <== NOT EXECUTED
107f70: eb 0e jmp 107f80 <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;
107f72: 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;
107f75: be 11 00 00 00 mov $0x11,%esi
107f7a: eb 04 jmp 107f80 <open+0x1b0>
* Single exit and clean up path.
*/
done:
va_end(ap);
if ( rc ) {
107f7c: 85 f6 test %esi,%esi
107f7e: 74 2c je 107fac <open+0x1dc> <== NEVER TAKEN
if ( iop )
107f80: 85 db test %ebx,%ebx
107f82: 74 0c je 107f90 <open+0x1c0>
rtems_libio_free( iop );
107f84: 83 ec 0c sub $0xc,%esp
107f87: 53 push %ebx
107f88: e8 77 63 00 00 call 10e304 <rtems_libio_free>
107f8d: 83 c4 10 add $0x10,%esp
if ( loc_to_free )
107f90: 85 ff test %edi,%edi
107f92: 74 0c je 107fa0 <open+0x1d0>
rtems_filesystem_freenode( loc_to_free );
107f94: 83 ec 0c sub $0xc,%esp
107f97: 57 push %edi
107f98: e8 c7 f3 ff ff call 107364 <rtems_filesystem_freenode>
107f9d: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( rc );
107fa0: e8 93 91 00 00 call 111138 <__errno>
107fa5: 89 30 mov %esi,(%eax)
107fa7: 83 c8 ff or $0xffffffff,%eax
107faa: eb 0f jmp 107fbb <open+0x1eb>
}
return iop - rtems_libio_iops;
107fac: 2b 1d f8 51 12 00 sub 0x1251f8,%ebx
107fb2: c1 fb 03 sar $0x3,%ebx
107fb5: 69 c3 b7 6d db b6 imul $0xb6db6db7,%ebx,%eax
}
107fbb: 8d 65 f4 lea -0xc(%ebp),%esp
107fbe: 5b pop %ebx
107fbf: 5e pop %esi
107fc0: 5f pop %edi
107fc1: c9 leave
107fc2: c3 ret
00108b72 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
108b72: 55 push %ebp
108b73: 89 e5 mov %esp,%ebp
108b75: 56 push %esi
108b76: 53 push %ebx
108b77: 83 ec 10 sub $0x10,%esp
108b7a: 89 d3 mov %edx,%ebx
108b7c: 88 45 f4 mov %al,-0xc(%ebp)
int i;
if (tty->termios.c_oflag & OPOST) {
108b7f: 8b 52 34 mov 0x34(%edx),%edx
108b82: f6 c2 01 test $0x1,%dl
108b85: 0f 84 ed 00 00 00 je 108c78 <oproc+0x106> <== NEVER TAKEN
switch (c) {
108b8b: 3c 09 cmp $0x9,%al
108b8d: 74 75 je 108c04 <oproc+0x92>
108b8f: 77 0d ja 108b9e <oproc+0x2c> <== ALWAYS TAKEN
108b91: 3c 08 cmp $0x8,%al <== NOT EXECUTED
108b93: 0f 85 aa 00 00 00 jne 108c43 <oproc+0xd1> <== NOT EXECUTED
108b99: e9 98 00 00 00 jmp 108c36 <oproc+0xc4> <== NOT EXECUTED
108b9e: 3c 0a cmp $0xa,%al
108ba0: 74 0a je 108bac <oproc+0x3a>
108ba2: 3c 0d cmp $0xd,%al
108ba4: 0f 85 99 00 00 00 jne 108c43 <oproc+0xd1> <== ALWAYS TAKEN
108baa: eb 32 jmp 108bde <oproc+0x6c> <== NOT EXECUTED
case '\n':
if (tty->termios.c_oflag & ONLRET)
108bac: f6 c2 20 test $0x20,%dl
108baf: 74 07 je 108bb8 <oproc+0x46> <== ALWAYS TAKEN
tty->column = 0;
108bb1: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
108bb8: 80 e2 04 and $0x4,%dl
108bbb: 0f 84 b7 00 00 00 je 108c78 <oproc+0x106> <== NEVER TAKEN
rtems_termios_puts ("\r", 1, tty);
108bc1: 56 push %esi
108bc2: 53 push %ebx
108bc3: 6a 01 push $0x1
108bc5: 68 64 f0 11 00 push $0x11f064
108bca: e8 83 fe ff ff call 108a52 <rtems_termios_puts>
tty->column = 0;
108bcf: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx)
108bd6: 83 c4 10 add $0x10,%esp
108bd9: e9 9a 00 00 00 jmp 108c78 <oproc+0x106>
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
108bde: f6 c2 10 test $0x10,%dl <== NOT EXECUTED
108be1: 74 0a je 108bed <oproc+0x7b> <== NOT EXECUTED
108be3: 83 7b 28 00 cmpl $0x0,0x28(%ebx) <== NOT EXECUTED
108be7: 0f 84 9b 00 00 00 je 108c88 <oproc+0x116> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
108bed: f6 c2 08 test $0x8,%dl <== NOT EXECUTED
108bf0: 74 09 je 108bfb <oproc+0x89> <== NOT EXECUTED
c = '\n';
108bf2: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
108bf6: 80 e2 20 and $0x20,%dl <== NOT EXECUTED
108bf9: 74 7d je 108c78 <oproc+0x106> <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
108bfb: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED
break;
108c02: eb 74 jmp 108c78 <oproc+0x106> <== NOT EXECUTED
case '\t':
i = 8 - (tty->column & 7);
108c04: 8b 4b 28 mov 0x28(%ebx),%ecx
108c07: 89 ce mov %ecx,%esi
108c09: 83 e6 07 and $0x7,%esi
108c0c: b8 08 00 00 00 mov $0x8,%eax
108c11: 29 f0 sub %esi,%eax
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
108c13: 81 e2 00 18 00 00 and $0x1800,%edx
108c19: 81 fa 00 18 00 00 cmp $0x1800,%edx
108c1f: 8d 14 08 lea (%eax,%ecx,1),%edx
108c22: 75 0d jne 108c31 <oproc+0xbf> <== NEVER TAKEN
tty->column += i;
108c24: 89 53 28 mov %edx,0x28(%ebx)
rtems_termios_puts ( " ", i, tty);
108c27: 51 push %ecx
108c28: 53 push %ebx
108c29: 50 push %eax
108c2a: 68 24 ec 11 00 push $0x11ec24
108c2f: eb 4f jmp 108c80 <oproc+0x10e>
return;
}
tty->column += i;
108c31: 89 53 28 mov %edx,0x28(%ebx) <== NOT EXECUTED
break;
108c34: eb 42 jmp 108c78 <oproc+0x106> <== NOT EXECUTED
case '\b':
if (tty->column > 0)
108c36: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
108c39: 85 c0 test %eax,%eax <== NOT EXECUTED
108c3b: 7e 3b jle 108c78 <oproc+0x106> <== NOT EXECUTED
tty->column--;
108c3d: 48 dec %eax <== NOT EXECUTED
108c3e: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
108c41: eb 35 jmp 108c78 <oproc+0x106> <== NOT EXECUTED
break;
default:
if (tty->termios.c_oflag & OLCUC)
108c43: 80 e2 02 and $0x2,%dl
108c46: 74 1c je 108c64 <oproc+0xf2> <== ALWAYS TAKEN
c = toupper(c);
108c48: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
108c4b: 8b 15 3c 31 12 00 mov 0x12313c,%edx <== NOT EXECUTED
108c51: 0f be 54 02 01 movsbl 0x1(%edx,%eax,1),%edx <== NOT EXECUTED
108c56: 83 e2 03 and $0x3,%edx <== NOT EXECUTED
108c59: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED
108c5c: 75 03 jne 108c61 <oproc+0xef> <== NOT EXECUTED
108c5e: 83 e8 20 sub $0x20,%eax <== NOT EXECUTED
108c61: 88 45 f4 mov %al,-0xc(%ebp) <== NOT EXECUTED
if (!iscntrl(c))
108c64: 0f b6 45 f4 movzbl -0xc(%ebp),%eax
108c68: 8b 15 3c 31 12 00 mov 0x12313c,%edx
108c6e: f6 44 02 01 20 testb $0x20,0x1(%edx,%eax,1)
108c73: 75 03 jne 108c78 <oproc+0x106> <== NEVER TAKEN
tty->column++;
108c75: ff 43 28 incl 0x28(%ebx)
break;
}
}
rtems_termios_puts (&c, 1, tty);
108c78: 52 push %edx
108c79: 53 push %ebx
108c7a: 6a 01 push $0x1
108c7c: 8d 45 f4 lea -0xc(%ebp),%eax
108c7f: 50 push %eax
108c80: e8 cd fd ff ff call 108a52 <rtems_termios_puts>
108c85: 83 c4 10 add $0x10,%esp
}
108c88: 8d 65 f8 lea -0x8(%ebp),%esp
108c8b: 5b pop %ebx
108c8c: 5e pop %esi
108c8d: c9 leave
108c8e: c3 ret
0010ef5c <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
10ef5c: 55 push %ebp
10ef5d: 89 e5 mov %esp,%ebp
10ef5f: 57 push %edi
10ef60: 56 push %esi
10ef61: 53 push %ebx
10ef62: 83 ec 34 sub $0x34,%esp
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
10ef65: 68 ff 01 00 00 push $0x1ff
10ef6a: 68 fc 0d 12 00 push $0x120dfc
10ef6f: e8 58 14 00 00 call 1103cc <rtems_mkdir>
10ef74: 83 c4 10 add $0x10,%esp
return -1;
10ef77: 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)
10ef7e: 85 c0 test %eax,%eax
10ef80: 0f 85 e8 00 00 00 jne 10f06e <pipe_create+0x112> <== NEVER TAKEN
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
10ef86: 8d 5d d9 lea -0x27(%ebp),%ebx
10ef89: be 01 0e 12 00 mov $0x120e01,%esi
10ef8e: b9 0a 00 00 00 mov $0xa,%ecx
10ef93: 89 df mov %ebx,%edi
10ef95: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
10ef97: 0f b7 05 20 60 12 00 movzwl 0x126020,%eax
10ef9e: 8d 50 01 lea 0x1(%eax),%edx
10efa1: 66 89 15 20 60 12 00 mov %dx,0x126020
10efa8: 57 push %edi
10efa9: 50 push %eax
10efaa: 68 0c 0e 12 00 push $0x120e0c
10efaf: 8d 45 e3 lea -0x1d(%ebp),%eax
10efb2: 50 push %eax
10efb3: e8 c0 43 00 00 call 113378 <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
10efb8: 59 pop %ecx
10efb9: 5e pop %esi
10efba: 68 80 01 00 00 push $0x180
10efbf: 53 push %ebx
10efc0: e8 c7 11 00 00 call 11018c <mkfifo>
10efc5: 83 c4 10 add $0x10,%esp
10efc8: 85 c0 test %eax,%eax
10efca: 74 0a je 10efd6 <pipe_create+0x7a>
if (errno != EEXIST){
10efcc: e8 bb 39 00 00 call 11298c <__errno>
10efd1: e9 98 00 00 00 jmp 10f06e <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);
10efd6: 52 push %edx
10efd7: 52 push %edx
10efd8: 68 00 40 00 00 push $0x4000
10efdd: 53 push %ebx
10efde: e8 4d 9e ff ff call 108e30 <open>
10efe3: 8b 55 08 mov 0x8(%ebp),%edx
10efe6: 89 02 mov %eax,(%edx)
if (filsdes[0] < 0) {
10efe8: 83 c4 10 add $0x10,%esp
10efeb: 85 c0 test %eax,%eax
10efed: 79 0d jns 10effc <pipe_create+0xa0>
err = errno;
10efef: e8 98 39 00 00 call 11298c <__errno>
10eff4: 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);
10eff6: 83 ec 0c sub $0xc,%esp
10eff9: 53 push %ebx
10effa: eb 51 jmp 10f04d <pipe_create+0xf1>
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
10effc: 31 d2 xor %edx,%edx
10effe: 3b 05 44 21 12 00 cmp 0x122144,%eax
10f004: 73 09 jae 10f00f <pipe_create+0xb3> <== NEVER TAKEN
10f006: 6b d0 38 imul $0x38,%eax,%edx
10f009: 03 15 20 62 12 00 add 0x126220,%edx
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
10f00f: 83 62 14 fe andl $0xfffffffe,0x14(%edx)
filsdes[1] = open(fifopath, O_WRONLY);
10f013: 50 push %eax
10f014: 50 push %eax
10f015: 6a 01 push $0x1
10f017: 8d 45 d9 lea -0x27(%ebp),%eax
10f01a: 50 push %eax
10f01b: e8 10 9e ff ff call 108e30 <open>
10f020: 8b 55 08 mov 0x8(%ebp),%edx
10f023: 89 42 04 mov %eax,0x4(%edx)
if (filsdes[1] < 0) {
10f026: 83 c4 10 add $0x10,%esp
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
10f029: 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) {
10f02b: 85 c0 test %eax,%eax
10f02d: 79 17 jns 10f046 <pipe_create+0xea>
err = errno;
10f02f: e8 58 39 00 00 call 11298c <__errno>
10f034: 8b 30 mov (%eax),%esi
close(filsdes[0]);
10f036: 83 ec 0c sub $0xc,%esp
10f039: 8b 45 08 mov 0x8(%ebp),%eax
10f03c: ff 30 pushl (%eax)
10f03e: e8 d1 8f ff ff call 108014 <close>
10f043: 83 c4 10 add $0x10,%esp
}
unlink(fifopath);
10f046: 83 ec 0c sub $0xc,%esp
10f049: 8d 45 d9 lea -0x27(%ebp),%eax
10f04c: 50 push %eax
10f04d: e8 7a b9 ff ff call 10a9cc <unlink>
10f052: 83 c4 10 add $0x10,%esp
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
10f055: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
10f05c: 85 f6 test %esi,%esi
10f05e: 74 0e je 10f06e <pipe_create+0x112>
rtems_set_errno_and_return_minus_one(err);
10f060: e8 27 39 00 00 call 11298c <__errno>
10f065: 89 30 mov %esi,(%eax)
10f067: c7 45 d4 ff ff ff ff movl $0xffffffff,-0x2c(%ebp)
return 0;
}
10f06e: 8b 45 d4 mov -0x2c(%ebp),%eax
10f071: 8d 65 f4 lea -0xc(%ebp),%esp
10f074: 5b pop %ebx
10f075: 5e pop %esi
10f076: 5f pop %edi
10f077: c9 leave
10f078: c3 ret
0011025b <pipe_ioctl>:
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
11025b: 55 push %ebp
11025c: 89 e5 mov %esp,%ebp
11025e: 56 push %esi
11025f: 53 push %ebx
110260: 8b 5d 08 mov 0x8(%ebp),%ebx
110263: 8b 75 10 mov 0x10(%ebp),%esi
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
110266: b8 ea ff ff ff mov $0xffffffea,%eax
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
11026b: 81 7d 0c 7f 66 04 40 cmpl $0x4004667f,0xc(%ebp)
110272: 75 36 jne 1102aa <pipe_ioctl+0x4f>
if (buffer == NULL)
return -EFAULT;
110274: b0 f2 mov $0xf2,%al
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
110276: 85 f6 test %esi,%esi
110278: 74 30 je 1102aa <pipe_ioctl+0x4f>
return -EFAULT;
if (! PIPE_LOCK(pipe))
11027a: 51 push %ecx
11027b: 6a 00 push $0x0
11027d: 6a 00 push $0x0
11027f: ff 73 28 pushl 0x28(%ebx)
110282: e8 d9 b9 ff ff call 10bc60 <rtems_semaphore_obtain>
110287: 89 c2 mov %eax,%edx
110289: 83 c4 10 add $0x10,%esp
return -EINTR;
11028c: b8 fc ff ff ff mov $0xfffffffc,%eax
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
if (! PIPE_LOCK(pipe))
110291: 85 d2 test %edx,%edx
110293: 75 15 jne 1102aa <pipe_ioctl+0x4f> <== NEVER TAKEN
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
110295: 8b 43 0c mov 0xc(%ebx),%eax
110298: 89 06 mov %eax,(%esi)
PIPE_UNLOCK(pipe);
11029a: 83 ec 0c sub $0xc,%esp
11029d: ff 73 28 pushl 0x28(%ebx)
1102a0: e8 a7 ba ff ff call 10bd4c <rtems_semaphore_release>
return 0;
1102a5: 83 c4 10 add $0x10,%esp
1102a8: 31 c0 xor %eax,%eax
}
return -EINVAL;
}
1102aa: 8d 65 f8 lea -0x8(%ebp),%esp
1102ad: 5b pop %ebx
1102ae: 5e pop %esi
1102af: c9 leave
1102b0: c3 ret
0010ff4c <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
10ff4c: 55 push %ebp
10ff4d: 89 e5 mov %esp,%ebp
10ff4f: 57 push %edi
10ff50: 56 push %esi
10ff51: 53 push %ebx
10ff52: 83 ec 30 sub $0x30,%esp
10ff55: 8b 5d 08 mov 0x8(%ebp),%ebx
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
10ff58: 6a 00 push $0x0
10ff5a: 6a 00 push $0x0
10ff5c: ff 73 28 pushl 0x28(%ebx)
10ff5f: e8 fc bc ff ff call 10bc60 <rtems_semaphore_obtain>
10ff64: 83 c4 10 add $0x10,%esp
return -EINTR;
10ff67: be fc ff ff ff mov $0xfffffffc,%esi
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
10ff6c: 85 c0 test %eax,%eax
10ff6e: 0f 85 2f 01 00 00 jne 1100a3 <pipe_read+0x157> <== NEVER TAKEN
10ff74: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
10ff7b: e9 f0 00 00 00 jmp 110070 <pipe_read+0x124>
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
10ff80: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10ff84: 0f 84 f2 00 00 00 je 11007c <pipe_read+0x130>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
10ff8a: 8b 45 14 mov 0x14(%ebp),%eax
10ff8d: f6 40 14 01 testb $0x1,0x14(%eax)
10ff91: 0f 85 e9 00 00 00 jne 110080 <pipe_read+0x134>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
10ff97: ff 43 18 incl 0x18(%ebx)
PIPE_UNLOCK(pipe);
10ff9a: 83 ec 0c sub $0xc,%esp
10ff9d: ff 73 28 pushl 0x28(%ebx)
10ffa0: e8 a7 bd ff ff call 10bd4c <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
10ffa5: 5f pop %edi
10ffa6: 58 pop %eax
10ffa7: 6a 00 push $0x0
10ffa9: ff 73 2c pushl 0x2c(%ebx)
10ffac: e8 9f 16 00 00 call 111650 <rtems_barrier_wait>
10ffb1: 83 c4 0c add $0xc,%esp
10ffb4: 83 f8 01 cmp $0x1,%eax
10ffb7: 19 f6 sbb %esi,%esi
10ffb9: f7 d6 not %esi
10ffbb: 83 e6 fc and $0xfffffffc,%esi
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
10ffbe: 6a 00 push $0x0
10ffc0: 6a 00 push $0x0
10ffc2: ff 73 28 pushl 0x28(%ebx)
10ffc5: e8 96 bc ff ff call 10bc60 <rtems_semaphore_obtain>
10ffca: 83 c4 10 add $0x10,%esp
10ffcd: 85 c0 test %eax,%eax
10ffcf: 0f 85 c0 00 00 00 jne 110095 <pipe_read+0x149> <== NEVER TAKEN
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
10ffd5: ff 4b 18 decl 0x18(%ebx)
if (ret != 0)
10ffd8: 85 f6 test %esi,%esi
10ffda: 0f 85 a5 00 00 00 jne 110085 <pipe_read+0x139> <== NEVER TAKEN
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
10ffe0: 8b 53 0c mov 0xc(%ebx),%edx
10ffe3: 85 d2 test %edx,%edx
10ffe5: 74 99 je 10ff80 <pipe_read+0x34>
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
10ffe7: 8b 45 10 mov 0x10(%ebp),%eax
10ffea: 2b 45 d0 sub -0x30(%ebp),%eax
10ffed: 89 55 d4 mov %edx,-0x2c(%ebp)
10fff0: 39 c2 cmp %eax,%edx
10fff2: 76 03 jbe 10fff7 <pipe_read+0xab>
10fff4: 89 45 d4 mov %eax,-0x2c(%ebp)
chunk1 = pipe->Size - pipe->Start;
10fff7: 8b 73 08 mov 0x8(%ebx),%esi
10fffa: 8b 43 04 mov 0x4(%ebx),%eax
10fffd: 29 f0 sub %esi,%eax
if (chunk > chunk1) {
10ffff: 39 45 d4 cmp %eax,-0x2c(%ebp)
110002: 8b 7d 0c mov 0xc(%ebp),%edi
110005: 8b 4d d0 mov -0x30(%ebp),%ecx
110008: 8d 14 0f lea (%edi,%ecx,1),%edx
11000b: 7e 1b jle 110028 <pipe_read+0xdc>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
11000d: 03 33 add (%ebx),%esi
11000f: 89 d7 mov %edx,%edi
110011: 89 c1 mov %eax,%ecx
110013: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
110015: 8b 55 d0 mov -0x30(%ebp),%edx
110018: 01 c2 add %eax,%edx
11001a: 03 55 0c add 0xc(%ebp),%edx
11001d: 8b 4d d4 mov -0x2c(%ebp),%ecx
110020: 29 c1 sub %eax,%ecx
110022: 8b 33 mov (%ebx),%esi
110024: 89 d7 mov %edx,%edi
110026: eb 07 jmp 11002f <pipe_read+0xe3>
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
110028: 03 33 add (%ebx),%esi
11002a: 89 d7 mov %edx,%edi
11002c: 8b 4d d4 mov -0x2c(%ebp),%ecx
11002f: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
pipe->Start += chunk;
110031: 8b 45 d4 mov -0x2c(%ebp),%eax
110034: 03 43 08 add 0x8(%ebx),%eax
pipe->Start %= pipe->Size;
110037: 31 d2 xor %edx,%edx
110039: f7 73 04 divl 0x4(%ebx)
11003c: 89 53 08 mov %edx,0x8(%ebx)
pipe->Length -= chunk;
11003f: 8b 43 0c mov 0xc(%ebx),%eax
110042: 2b 45 d4 sub -0x2c(%ebp),%eax
110045: 89 43 0c mov %eax,0xc(%ebx)
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
110048: 85 c0 test %eax,%eax
11004a: 75 07 jne 110053 <pipe_read+0x107>
pipe->Start = 0;
11004c: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
if (pipe->waitingWriters > 0)
110053: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx)
110057: 74 11 je 11006a <pipe_read+0x11e>
PIPE_WAKEUPWRITERS(pipe);
110059: 56 push %esi
11005a: 56 push %esi
11005b: 8d 45 e4 lea -0x1c(%ebp),%eax
11005e: 50 push %eax
11005f: ff 73 30 pushl 0x30(%ebx)
110062: e8 91 15 00 00 call 1115f8 <rtems_barrier_release>
110067: 83 c4 10 add $0x10,%esp
read += chunk;
11006a: 8b 4d d4 mov -0x2c(%ebp),%ecx
11006d: 01 4d d0 add %ecx,-0x30(%ebp)
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
110070: 8b 7d 10 mov 0x10(%ebp),%edi
110073: 39 7d d0 cmp %edi,-0x30(%ebp)
110076: 0f 82 64 ff ff ff jb 10ffe0 <pipe_read+0x94>
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
11007c: 31 f6 xor %esi,%esi
11007e: eb 05 jmp 110085 <pipe_read+0x139>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
110080: be f5 ff ff ff mov $0xfffffff5,%esi
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
110085: 83 ec 0c sub $0xc,%esp
110088: ff 73 28 pushl 0x28(%ebx)
11008b: e8 bc bc ff ff call 10bd4c <rtems_semaphore_release>
110090: 83 c4 10 add $0x10,%esp
110093: eb 05 jmp 11009a <pipe_read+0x14e>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
110095: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
11009a: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
11009e: 7e 03 jle 1100a3 <pipe_read+0x157>
1100a0: 8b 75 d0 mov -0x30(%ebp),%esi
return read;
return ret;
}
1100a3: 89 f0 mov %esi,%eax
1100a5: 8d 65 f4 lea -0xc(%ebp),%esp
1100a8: 5b pop %ebx
1100a9: 5e pop %esi
1100aa: 5f pop %edi
1100ab: c9 leave
1100ac: c3 ret
0010faf1 <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
10faf1: 55 push %ebp
10faf2: 89 e5 mov %esp,%ebp
10faf4: 57 push %edi
10faf5: 56 push %esi
10faf6: 53 push %ebx
10faf7: 83 ec 1c sub $0x1c,%esp
10fafa: 8b 7d 08 mov 0x8(%ebp),%edi
pipe_control_t *pipe = *pipep;
10fafd: 8b 1f mov (%edi),%ebx
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
10faff: 8b 45 0c mov 0xc(%ebp),%eax
10fb02: 8b 40 14 mov 0x14(%eax),%eax
10fb05: 89 c6 mov %eax,%esi
10fb07: 83 e6 06 and $0x6,%esi
if (mode & LIBIO_FLAGS_READ)
10fb0a: a8 02 test $0x2,%al
10fb0c: 74 03 je 10fb11 <pipe_release+0x20>
pipe->Readers --;
10fb0e: ff 4b 10 decl 0x10(%ebx)
if (mode & LIBIO_FLAGS_WRITE)
10fb11: f7 c6 04 00 00 00 test $0x4,%esi
10fb17: 74 03 je 10fb1c <pipe_release+0x2b>
pipe->Writers --;
10fb19: ff 4b 14 decl 0x14(%ebx)
PIPE_UNLOCK(pipe);
10fb1c: 83 ec 0c sub $0xc,%esp
10fb1f: ff 73 28 pushl 0x28(%ebx)
10fb22: e8 25 c2 ff ff call 10bd4c <rtems_semaphore_release>
if (pipe->Readers == 0 && pipe->Writers == 0) {
10fb27: 8b 43 10 mov 0x10(%ebx),%eax
10fb2a: 83 c4 10 add $0x10,%esp
10fb2d: 85 c0 test %eax,%eax
10fb2f: 75 15 jne 10fb46 <pipe_release+0x55>
10fb31: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fb35: 75 0f jne 10fb46 <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);
10fb37: 89 d8 mov %ebx,%eax
10fb39: e8 78 ff ff ff call 10fab6 <pipe_free>
*pipep = NULL;
10fb3e: c7 07 00 00 00 00 movl $0x0,(%edi)
10fb44: eb 30 jmp 10fb76 <pipe_release+0x85>
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
10fb46: 83 fe 04 cmp $0x4,%esi
10fb49: 74 0f je 10fb5a <pipe_release+0x69>
10fb4b: 85 c0 test %eax,%eax
10fb4d: 75 0b jne 10fb5a <pipe_release+0x69> <== NEVER TAKEN
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
10fb4f: 57 push %edi
10fb50: 57 push %edi
10fb51: 8d 45 e4 lea -0x1c(%ebp),%eax
10fb54: 50 push %eax
10fb55: ff 73 30 pushl 0x30(%ebx)
10fb58: eb 14 jmp 10fb6e <pipe_release+0x7d>
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
10fb5a: 83 fe 02 cmp $0x2,%esi
10fb5d: 74 17 je 10fb76 <pipe_release+0x85> <== NEVER TAKEN
10fb5f: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fb63: 75 11 jne 10fb76 <pipe_release+0x85> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
10fb65: 56 push %esi
10fb66: 56 push %esi
10fb67: 8d 45 e4 lea -0x1c(%ebp),%eax
10fb6a: 50 push %eax
10fb6b: ff 73 2c pushl 0x2c(%ebx)
10fb6e: e8 85 1a 00 00 call 1115f8 <rtems_barrier_release>
10fb73: 83 c4 10 add $0x10,%esp
pipe_unlock();
10fb76: e8 25 ff ff ff call 10faa0 <pipe_unlock>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
10fb7b: 8d 65 f4 lea -0xc(%ebp),%esp
10fb7e: 5b pop %ebx
10fb7f: 5e pop %esi
10fb80: 5f pop %edi
10fb81: c9 leave
10fb82: c3 ret
001100ad <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
1100ad: 55 push %ebp
1100ae: 89 e5 mov %esp,%ebp
1100b0: 57 push %edi
1100b1: 56 push %esi
1100b2: 53 push %ebx
1100b3: 83 ec 2c sub $0x2c,%esp
1100b6: 8b 5d 08 mov 0x8(%ebp),%ebx
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
1100b9: 31 f6 xor %esi,%esi
)
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
1100bb: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
1100bf: 0f 84 8c 01 00 00 je 110251 <pipe_write+0x1a4> <== NEVER TAKEN
return 0;
if (! PIPE_LOCK(pipe))
1100c5: 52 push %edx
1100c6: 6a 00 push $0x0
1100c8: 6a 00 push $0x0
1100ca: ff 73 28 pushl 0x28(%ebx)
1100cd: e8 8e bb ff ff call 10bc60 <rtems_semaphore_obtain>
1100d2: 83 c4 10 add $0x10,%esp
return -EINTR;
1100d5: be fc ff ff ff mov $0xfffffffc,%esi
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
1100da: 85 c0 test %eax,%eax
1100dc: 0f 85 6f 01 00 00 jne 110251 <pipe_write+0x1a4> <== NEVER TAKEN
return -EINTR;
if (pipe->Readers == 0) {
1100e2: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
1100e6: 0f 84 16 01 00 00 je 110202 <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;
1100ec: bf 01 00 00 00 mov $0x1,%edi
1100f1: 8b 45 10 mov 0x10(%ebp),%eax
1100f4: 3b 43 04 cmp 0x4(%ebx),%eax
1100f7: 77 02 ja 1100fb <pipe_write+0x4e> <== NEVER TAKEN
1100f9: 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;
1100fb: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
110102: e9 eb 00 00 00 jmp 1101f2 <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)) {
110107: 8b 4d 14 mov 0x14(%ebp),%ecx
11010a: f6 41 14 01 testb $0x1,0x14(%ecx)
11010e: 0f 85 fc 00 00 00 jne 110210 <pipe_write+0x163>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
110114: ff 43 1c incl 0x1c(%ebx)
PIPE_UNLOCK(pipe);
110117: 83 ec 0c sub $0xc,%esp
11011a: ff 73 28 pushl 0x28(%ebx)
11011d: e8 2a bc ff ff call 10bd4c <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
110122: 5e pop %esi
110123: 58 pop %eax
110124: 6a 00 push $0x0
110126: ff 73 30 pushl 0x30(%ebx)
110129: e8 22 15 00 00 call 111650 <rtems_barrier_wait>
11012e: 83 c4 0c add $0xc,%esp
110131: 83 f8 01 cmp $0x1,%eax
110134: 19 f6 sbb %esi,%esi
110136: f7 d6 not %esi
110138: 83 e6 fc and $0xfffffffc,%esi
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
11013b: 6a 00 push $0x0
11013d: 6a 00 push $0x0
11013f: ff 73 28 pushl 0x28(%ebx)
110142: e8 19 bb ff ff call 10bc60 <rtems_semaphore_obtain>
110147: 83 c4 10 add $0x10,%esp
11014a: 85 c0 test %eax,%eax
11014c: 0f 85 f1 00 00 00 jne 110243 <pipe_write+0x196> <== NEVER TAKEN
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
110152: ff 4b 1c decl 0x1c(%ebx)
if (ret != 0)
110155: 85 f6 test %esi,%esi
110157: 0f 85 bf 00 00 00 jne 11021c <pipe_write+0x16f> <== NEVER TAKEN
goto out_locked;
if (pipe->Readers == 0) {
11015d: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
110161: 0f 84 b0 00 00 00 je 110217 <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) {
110167: 8b 73 04 mov 0x4(%ebx),%esi
11016a: 8b 43 0c mov 0xc(%ebx),%eax
11016d: 89 f1 mov %esi,%ecx
11016f: 29 c1 sub %eax,%ecx
110171: 39 f9 cmp %edi,%ecx
110173: 72 92 jb 110107 <pipe_write+0x5a>
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
110175: 8b 55 10 mov 0x10(%ebp),%edx
110178: 2b 55 d4 sub -0x2c(%ebp),%edx
11017b: 89 4d d0 mov %ecx,-0x30(%ebp)
11017e: 39 d1 cmp %edx,%ecx
110180: 76 03 jbe 110185 <pipe_write+0xd8>
110182: 89 55 d0 mov %edx,-0x30(%ebp)
chunk1 = pipe->Size - PIPE_WSTART(pipe);
110185: 03 43 08 add 0x8(%ebx),%eax
110188: 31 d2 xor %edx,%edx
11018a: f7 f6 div %esi
11018c: 29 d6 sub %edx,%esi
11018e: 89 75 cc mov %esi,-0x34(%ebp)
if (chunk > chunk1) {
110191: 39 75 d0 cmp %esi,-0x30(%ebp)
110194: 8b 4d 0c mov 0xc(%ebp),%ecx
110197: 8b 45 d4 mov -0x2c(%ebp),%eax
11019a: 8d 34 01 lea (%ecx,%eax,1),%esi
11019d: 7e 20 jle 1101bf <pipe_write+0x112>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
11019f: 8b 03 mov (%ebx),%eax
1101a1: 01 d0 add %edx,%eax
1101a3: 89 c7 mov %eax,%edi
1101a5: 8b 4d cc mov -0x34(%ebp),%ecx
1101a8: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
1101aa: 8b 03 mov (%ebx),%eax
1101ac: 8b 4d d0 mov -0x30(%ebp),%ecx
1101af: 2b 4d cc sub -0x34(%ebp),%ecx
1101b2: 8b 75 cc mov -0x34(%ebp),%esi
1101b5: 03 75 d4 add -0x2c(%ebp),%esi
1101b8: 03 75 0c add 0xc(%ebp),%esi
1101bb: 89 c7 mov %eax,%edi
1101bd: eb 09 jmp 1101c8 <pipe_write+0x11b>
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
1101bf: 8b 03 mov (%ebx),%eax
1101c1: 01 d0 add %edx,%eax
1101c3: 89 c7 mov %eax,%edi
1101c5: 8b 4d d0 mov -0x30(%ebp),%ecx
1101c8: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
pipe->Length += chunk;
1101ca: 8b 45 d0 mov -0x30(%ebp),%eax
1101cd: 01 43 0c add %eax,0xc(%ebx)
if (pipe->waitingReaders > 0)
1101d0: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
1101d4: 74 11 je 1101e7 <pipe_write+0x13a>
PIPE_WAKEUPREADERS(pipe);
1101d6: 51 push %ecx
1101d7: 51 push %ecx
1101d8: 8d 4d e4 lea -0x1c(%ebp),%ecx
1101db: 51 push %ecx
1101dc: ff 73 2c pushl 0x2c(%ebx)
1101df: e8 14 14 00 00 call 1115f8 <rtems_barrier_release>
1101e4: 83 c4 10 add $0x10,%esp
written += chunk;
1101e7: 8b 45 d0 mov -0x30(%ebp),%eax
1101ea: 01 45 d4 add %eax,-0x2c(%ebp)
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
1101ed: 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) {
1101f2: 8b 4d 10 mov 0x10(%ebp),%ecx
1101f5: 39 4d d4 cmp %ecx,-0x2c(%ebp)
1101f8: 0f 82 69 ff ff ff jb 110167 <pipe_write+0xba>
1101fe: 31 f6 xor %esi,%esi
110200: eb 1a jmp 11021c <pipe_write+0x16f>
if (! PIPE_LOCK(pipe))
return -EINTR;
if (pipe->Readers == 0) {
ret = -EPIPE;
110202: 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;
110207: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
11020e: eb 0c jmp 11021c <pipe_write+0x16f>
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
110210: be f5 ff ff ff mov $0xfffffff5,%esi
110215: eb 05 jmp 11021c <pipe_write+0x16f>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
110217: 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);
11021c: 83 ec 0c sub $0xc,%esp
11021f: ff 73 28 pushl 0x28(%ebx)
110222: e8 25 bb ff ff call 10bd4c <rtems_semaphore_release>
110227: 83 c4 10 add $0x10,%esp
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
11022a: 83 fe e0 cmp $0xffffffe0,%esi
11022d: 75 19 jne 110248 <pipe_write+0x19b>
kill(getpid(), SIGPIPE);
11022f: e8 24 07 00 00 call 110958 <getpid>
110234: 52 push %edx
110235: 52 push %edx
110236: 6a 0d push $0xd
110238: 50 push %eax
110239: e8 a2 09 00 00 call 110be0 <kill>
11023e: 83 c4 10 add $0x10,%esp
110241: eb 05 jmp 110248 <pipe_write+0x19b>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
110243: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
110248: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
11024c: 7e 03 jle 110251 <pipe_write+0x1a4>
11024e: 8b 75 d4 mov -0x2c(%ebp),%esi
return written;
return ret;
}
110251: 89 f0 mov %esi,%eax
110253: 8d 65 f4 lea -0xc(%ebp),%esp
110256: 5b pop %ebx
110257: 5e pop %esi
110258: 5f pop %edi
110259: c9 leave
11025a: c3 ret
0010a888 <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
10a888: 55 push %ebp
10a889: 89 e5 mov %esp,%ebp
10a88b: 53 push %ebx
10a88c: 83 ec 04 sub $0x4,%esp
10a88f: 8b 45 0c mov 0xc(%ebp),%eax
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
10a892: ff 05 44 bb 12 00 incl 0x12bb44
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
10a898: 8d 58 ff lea -0x1(%eax),%ebx
10a89b: 85 c3 test %eax,%ebx
10a89d: 75 0d jne 10a8ac <posix_memalign+0x24> <== NEVER TAKEN
10a89f: 83 f8 03 cmp $0x3,%eax
10a8a2: 76 08 jbe 10a8ac <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 );
}
10a8a4: 59 pop %ecx
10a8a5: 5b pop %ebx
10a8a6: c9 leave
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
10a8a7: e9 74 01 00 00 jmp 10aa20 <rtems_memalign>
}
10a8ac: b8 16 00 00 00 mov $0x16,%eax
10a8b1: 5a pop %edx
10a8b2: 5b pop %ebx
10a8b3: c9 leave
10a8b4: c3 ret
0010efd8 <pthread_attr_getdetachstate>:
int pthread_attr_getdetachstate(
const pthread_attr_t *attr,
int *detachstate
)
{
10efd8: 55 push %ebp
10efd9: 89 e5 mov %esp,%ebp
10efdb: 8b 55 08 mov 0x8(%ebp),%edx
10efde: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized || !detachstate )
return EINVAL;
10efe1: b8 16 00 00 00 mov $0x16,%eax
int pthread_attr_getdetachstate(
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
10efe6: 85 d2 test %edx,%edx
10efe8: 74 17 je 10f001 <pthread_attr_getdetachstate+0x29><== NEVER TAKEN
10efea: 85 c9 test %ecx,%ecx
10efec: 74 0e je 10effc <pthread_attr_getdetachstate+0x24>
10efee: 83 3a 00 cmpl $0x0,(%edx)
10eff1: 74 09 je 10effc <pthread_attr_getdetachstate+0x24>
return EINVAL;
*detachstate = attr->detachstate;
10eff3: 8b 42 3c mov 0x3c(%edx),%eax
10eff6: 89 01 mov %eax,(%ecx)
return 0;
10eff8: 31 c0 xor %eax,%eax
10effa: eb 05 jmp 10f001 <pthread_attr_getdetachstate+0x29>
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
return EINVAL;
10effc: b8 16 00 00 00 mov $0x16,%eax
*detachstate = attr->detachstate;
return 0;
}
10f001: c9 leave
10f002: c3 ret
0010f24c <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
10f24c: 55 push %ebp
10f24d: 89 e5 mov %esp,%ebp
10f24f: 8b 55 08 mov 0x8(%ebp),%edx
10f252: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10f255: b8 16 00 00 00 mov $0x16,%eax
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
10f25a: 85 d2 test %edx,%edx
10f25c: 74 1e je 10f27c <pthread_attr_setschedpolicy+0x30>
10f25e: 83 3a 00 cmpl $0x0,(%edx)
10f261: 74 19 je 10f27c <pthread_attr_setschedpolicy+0x30>
return EINVAL;
switch ( policy ) {
10f263: 83 f9 04 cmp $0x4,%ecx
10f266: 77 0f ja 10f277 <pthread_attr_setschedpolicy+0x2b>
10f268: b0 01 mov $0x1,%al
10f26a: d3 e0 shl %cl,%eax
10f26c: a8 17 test $0x17,%al
10f26e: 74 07 je 10f277 <pthread_attr_setschedpolicy+0x2b><== NEVER TAKEN
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
10f270: 89 4a 14 mov %ecx,0x14(%edx)
return 0;
10f273: 31 c0 xor %eax,%eax
10f275: eb 05 jmp 10f27c <pthread_attr_setschedpolicy+0x30>
default:
return ENOTSUP;
10f277: b8 86 00 00 00 mov $0x86,%eax
}
}
10f27c: c9 leave
10f27d: c3 ret
0010a56c <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
10a56c: 55 push %ebp
10a56d: 89 e5 mov %esp,%ebp
10a56f: 57 push %edi
10a570: 56 push %esi
10a571: 53 push %ebx
10a572: 83 ec 1c sub $0x1c,%esp
10a575: 8b 5d 08 mov 0x8(%ebp),%ebx
10a578: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Error check parameters
*/
if ( !barrier )
return EINVAL;
10a57b: b8 16 00 00 00 mov $0x16,%eax
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
10a580: 85 db test %ebx,%ebx
10a582: 0f 84 96 00 00 00 je 10a61e <pthread_barrier_init+0xb2>
return EINVAL;
if ( count == 0 )
10a588: 85 f6 test %esi,%esi
10a58a: 0f 84 8e 00 00 00 je 10a61e <pthread_barrier_init+0xb2>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10a590: 8b 7d 0c mov 0xc(%ebp),%edi
10a593: 85 ff test %edi,%edi
10a595: 75 0f jne 10a5a6 <pthread_barrier_init+0x3a>
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
10a597: 83 ec 0c sub $0xc,%esp
10a59a: 8d 7d d8 lea -0x28(%ebp),%edi
10a59d: 57 push %edi
10a59e: e8 19 ff ff ff call 10a4bc <pthread_barrierattr_init>
10a5a3: 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;
10a5a6: 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 )
10a5ab: 83 3f 00 cmpl $0x0,(%edi)
10a5ae: 74 6e je 10a61e <pthread_barrier_init+0xb2>
return EINVAL;
switch ( the_attr->process_shared ) {
10a5b0: 83 7f 04 00 cmpl $0x0,0x4(%edi)
10a5b4: 75 68 jne 10a61e <pthread_barrier_init+0xb2><== NEVER TAKEN
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
10a5b6: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
the_attributes.maximum_count = count;
10a5bd: 89 75 e4 mov %esi,-0x1c(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a5c0: a1 50 63 12 00 mov 0x126350,%eax
10a5c5: 40 inc %eax
10a5c6: 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 );
10a5cb: 83 ec 0c sub $0xc,%esp
10a5ce: 68 f4 66 12 00 push $0x1266f4
10a5d3: e8 0c 1e 00 00 call 10c3e4 <_Objects_Allocate>
10a5d8: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
10a5da: 83 c4 10 add $0x10,%esp
10a5dd: 85 c0 test %eax,%eax
10a5df: 75 0c jne 10a5ed <pthread_barrier_init+0x81>
_Thread_Enable_dispatch();
10a5e1: e8 dc 2c 00 00 call 10d2c2 <_Thread_Enable_dispatch>
return EAGAIN;
10a5e6: b8 0b 00 00 00 mov $0xb,%eax
10a5eb: eb 31 jmp 10a61e <pthread_barrier_init+0xb2>
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
10a5ed: 50 push %eax
10a5ee: 50 push %eax
10a5ef: 8d 45 e0 lea -0x20(%ebp),%eax
10a5f2: 50 push %eax
10a5f3: 8d 46 10 lea 0x10(%esi),%eax
10a5f6: 50 push %eax
10a5f7: e8 a8 14 00 00 call 10baa4 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10a5fc: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a5ff: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a602: 8b 15 10 67 12 00 mov 0x126710,%edx
10a608: 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;
10a60b: 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;
10a612: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10a614: e8 a9 2c 00 00 call 10d2c2 <_Thread_Enable_dispatch>
return 0;
10a619: 83 c4 10 add $0x10,%esp
10a61c: 31 c0 xor %eax,%eax
}
10a61e: 8d 65 f4 lea -0xc(%ebp),%esp
10a621: 5b pop %ebx
10a622: 5e pop %esi
10a623: 5f pop %edi
10a624: c9 leave
10a625: c3 ret
00109f20 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
109f20: 55 push %ebp
109f21: 89 e5 mov %esp,%ebp
109f23: 56 push %esi
109f24: 53 push %ebx
109f25: 8b 5d 08 mov 0x8(%ebp),%ebx
109f28: 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 )
109f2b: 85 db test %ebx,%ebx
109f2d: 74 4b je 109f7a <pthread_cleanup_push+0x5a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
109f2f: a1 48 63 12 00 mov 0x126348,%eax
109f34: 40 inc %eax
109f35: a3 48 63 12 00 mov %eax,0x126348
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
109f3a: 83 ec 0c sub $0xc,%esp
109f3d: 6a 10 push $0x10
109f3f: e8 3e 3c 00 00 call 10db82 <_Workspace_Allocate>
if ( handler ) {
109f44: 83 c4 10 add $0x10,%esp
109f47: 85 c0 test %eax,%eax
109f49: 74 24 je 109f6f <pthread_cleanup_push+0x4f><== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
109f4b: 8b 15 70 68 12 00 mov 0x126870,%edx
handler_stack = &thread_support->Cancellation_Handlers;
109f51: 8b 92 ec 00 00 00 mov 0xec(%edx),%edx
109f57: 81 c2 e4 00 00 00 add $0xe4,%edx
handler->routine = routine;
109f5d: 89 58 08 mov %ebx,0x8(%eax)
handler->arg = arg;
109f60: 89 70 0c mov %esi,0xc(%eax)
_Chain_Append( handler_stack, &handler->Node );
109f63: 51 push %ecx
109f64: 51 push %ecx
109f65: 50 push %eax
109f66: 52 push %edx
109f67: e8 84 15 00 00 call 10b4f0 <_Chain_Append>
109f6c: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
}
109f6f: 8d 65 f8 lea -0x8(%ebp),%esp
109f72: 5b pop %ebx
109f73: 5e pop %esi
109f74: c9 leave
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
109f75: e9 3c 2d 00 00 jmp 10ccb6 <_Thread_Enable_dispatch>
}
109f7a: 8d 65 f8 lea -0x8(%ebp),%esp
109f7d: 5b pop %ebx
109f7e: 5e pop %esi
109f7f: c9 leave
109f80: c3 ret
0010ac94 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
10ac94: 55 push %ebp
10ac95: 89 e5 mov %esp,%ebp
10ac97: 56 push %esi
10ac98: 53 push %ebx
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
10ac99: 8b 5d 0c mov 0xc(%ebp),%ebx
10ac9c: 85 db test %ebx,%ebx
10ac9e: 75 05 jne 10aca5 <pthread_cond_init+0x11>
else the_attr = &_POSIX_Condition_variables_Default_attributes;
10aca0: bb b4 15 12 00 mov $0x1215b4,%ebx
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return EINVAL;
10aca5: 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 )
10acaa: 83 7b 04 01 cmpl $0x1,0x4(%ebx)
10acae: 74 76 je 10ad26 <pthread_cond_init+0x92><== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
10acb0: 83 3b 00 cmpl $0x0,(%ebx)
10acb3: 74 71 je 10ad26 <pthread_cond_init+0x92>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10acb5: a1 60 73 12 00 mov 0x127360,%eax
10acba: 40 inc %eax
10acbb: 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 );
10acc0: 83 ec 0c sub $0xc,%esp
10acc3: 68 9c 77 12 00 push $0x12779c
10acc8: e8 f7 22 00 00 call 10cfc4 <_Objects_Allocate>
10accd: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
10accf: 83 c4 10 add $0x10,%esp
10acd2: 85 c0 test %eax,%eax
10acd4: 75 0c jne 10ace2 <pthread_cond_init+0x4e>
_Thread_Enable_dispatch();
10acd6: e8 c7 31 00 00 call 10dea2 <_Thread_Enable_dispatch>
return ENOMEM;
10acdb: b8 0c 00 00 00 mov $0xc,%eax
10ace0: eb 44 jmp 10ad26 <pthread_cond_init+0x92>
}
the_cond->process_shared = the_attr->process_shared;
10ace2: 8b 43 04 mov 0x4(%ebx),%eax
10ace5: 89 46 10 mov %eax,0x10(%esi)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
10ace8: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
_Thread_queue_Initialize(
10acef: 6a 74 push $0x74
10acf1: 68 00 08 00 10 push $0x10000800
10acf6: 6a 00 push $0x0
10acf8: 8d 46 18 lea 0x18(%esi),%eax
10acfb: 50 push %eax
10acfc: e8 5f 38 00 00 call 10e560 <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10ad01: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10ad04: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10ad07: 8b 15 b8 77 12 00 mov 0x1277b8,%edx
10ad0d: 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;
10ad10: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
10ad17: 8b 55 08 mov 0x8(%ebp),%edx
10ad1a: 89 02 mov %eax,(%edx)
_Thread_Enable_dispatch();
10ad1c: e8 81 31 00 00 call 10dea2 <_Thread_Enable_dispatch>
return 0;
10ad21: 83 c4 10 add $0x10,%esp
10ad24: 31 c0 xor %eax,%eax
}
10ad26: 8d 65 f8 lea -0x8(%ebp),%esp
10ad29: 5b pop %ebx
10ad2a: 5e pop %esi
10ad2b: c9 leave
10ad2c: c3 ret
0010ab48 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
10ab48: 55 push %ebp
10ab49: 89 e5 mov %esp,%ebp
10ab4b: 8b 55 08 mov 0x8(%ebp),%edx
if ( !attr || attr->is_initialized == false )
return EINVAL;
10ab4e: b8 16 00 00 00 mov $0x16,%eax
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
10ab53: 85 d2 test %edx,%edx
10ab55: 74 0d je 10ab64 <pthread_condattr_destroy+0x1c>
10ab57: 83 3a 00 cmpl $0x0,(%edx)
10ab5a: 74 08 je 10ab64 <pthread_condattr_destroy+0x1c><== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
10ab5c: c7 02 00 00 00 00 movl $0x0,(%edx)
return 0;
10ab62: 30 c0 xor %al,%al
}
10ab64: c9 leave
10ab65: c3 ret
0010a27c <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
10a27c: 55 push %ebp
10a27d: 89 e5 mov %esp,%ebp
10a27f: 57 push %edi
10a280: 56 push %esi
10a281: 53 push %ebx
10a282: 83 ec 5c sub $0x5c,%esp
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
10a285: 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 )
10a28c: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a290: 0f 84 0f 02 00 00 je 10a4a5 <pthread_create+0x229>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
10a296: 8b 5d 0c mov 0xc(%ebp),%ebx
10a299: 85 db test %ebx,%ebx
10a29b: 75 05 jne 10a2a2 <pthread_create+0x26>
10a29d: bb 40 02 12 00 mov $0x120240,%ebx
if ( !the_attr->is_initialized )
return EINVAL;
10a2a2: 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 )
10a2a9: 83 3b 00 cmpl $0x0,(%ebx)
10a2ac: 0f 84 f3 01 00 00 je 10a4a5 <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) )
10a2b2: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a2b6: 74 0e je 10a2c6 <pthread_create+0x4a>
10a2b8: a1 44 22 12 00 mov 0x122244,%eax
10a2bd: 39 43 08 cmp %eax,0x8(%ebx)
10a2c0: 0f 82 df 01 00 00 jb 10a4a5 <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 ) {
10a2c6: 8b 43 10 mov 0x10(%ebx),%eax
10a2c9: 83 f8 01 cmp $0x1,%eax
10a2cc: 74 0b je 10a2d9 <pthread_create+0x5d>
10a2ce: 83 f8 02 cmp $0x2,%eax
10a2d1: 0f 85 c7 01 00 00 jne 10a49e <pthread_create+0x222>
10a2d7: eb 1f jmp 10a2f8 <pthread_create+0x7c>
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a2d9: a1 78 68 12 00 mov 0x126878,%eax
10a2de: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi
schedpolicy = api->schedpolicy;
10a2e4: 8b 86 84 00 00 00 mov 0x84(%esi),%eax
10a2ea: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = api->schedparam;
10a2ed: 8d 7d c4 lea -0x3c(%ebp),%edi
10a2f0: 81 c6 88 00 00 00 add $0x88,%esi
10a2f6: eb 0c jmp 10a304 <pthread_create+0x88>
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
10a2f8: 8b 43 14 mov 0x14(%ebx),%eax
10a2fb: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = the_attr->schedparam;
10a2fe: 8d 7d c4 lea -0x3c(%ebp),%edi
10a301: 8d 73 18 lea 0x18(%ebx),%esi
10a304: b9 07 00 00 00 mov $0x7,%ecx
10a309: 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;
10a30b: 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 )
10a312: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10a316: 0f 85 89 01 00 00 jne 10a4a5 <pthread_create+0x229>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
10a31c: 83 ec 0c sub $0xc,%esp
10a31f: ff 75 c4 pushl -0x3c(%ebp)
10a322: e8 2d 59 00 00 call 10fc54 <_POSIX_Priority_Is_valid>
10a327: 83 c4 10 add $0x10,%esp
return EINVAL;
10a32a: 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 ) )
10a331: 84 c0 test %al,%al
10a333: 0f 84 6c 01 00 00 je 10a4a5 <pthread_create+0x229> <== NEVER TAKEN
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
10a339: 8b 45 c4 mov -0x3c(%ebp),%eax
10a33c: 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);
10a33f: 0f b6 3d 48 22 12 00 movzbl 0x122248,%edi
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
10a346: 8d 45 e0 lea -0x20(%ebp),%eax
10a349: 50 push %eax
10a34a: 8d 45 e4 lea -0x1c(%ebp),%eax
10a34d: 50 push %eax
10a34e: 8d 45 c4 lea -0x3c(%ebp),%eax
10a351: 50 push %eax
10a352: ff 75 ac pushl -0x54(%ebp)
10a355: e8 1a 59 00 00 call 10fc74 <_POSIX_Thread_Translate_sched_param>
10a35a: 89 45 b4 mov %eax,-0x4c(%ebp)
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
10a35d: 83 c4 10 add $0x10,%esp
10a360: 85 c0 test %eax,%eax
10a362: 0f 85 3d 01 00 00 jne 10a4a5 <pthread_create+0x229>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10a368: 83 ec 0c sub $0xc,%esp
10a36b: ff 35 f4 63 12 00 pushl 0x1263f4
10a371: e8 4e 15 00 00 call 10b8c4 <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
10a376: c7 04 24 74 65 12 00 movl $0x126574,(%esp)
10a37d: e8 a2 1e 00 00 call 10c224 <_Objects_Allocate>
10a382: 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 ) {
10a385: 83 c4 10 add $0x10,%esp
10a388: 85 c0 test %eax,%eax
10a38a: 75 05 jne 10a391 <pthread_create+0x115>
_RTEMS_Unlock_allocator();
10a38c: 83 ec 0c sub $0xc,%esp
10a38f: eb 53 jmp 10a3e4 <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(
10a391: 8b 4d e0 mov -0x20(%ebp),%ecx
10a394: 8b 75 e4 mov -0x1c(%ebp),%esi
10a397: 8b 53 08 mov 0x8(%ebx),%edx
10a39a: a1 44 22 12 00 mov 0x122244,%eax
10a39f: d1 e0 shl %eax
10a3a1: 39 d0 cmp %edx,%eax
10a3a3: 73 02 jae 10a3a7 <pthread_create+0x12b>
10a3a5: 89 d0 mov %edx,%eax
10a3a7: 52 push %edx
10a3a8: 6a 00 push $0x0
10a3aa: 6a 00 push $0x0
10a3ac: 51 push %ecx
10a3ad: 56 push %esi
10a3ae: 6a 01 push $0x1
10a3b0: 81 e7 ff 00 00 00 and $0xff,%edi
10a3b6: 2b 7d a8 sub -0x58(%ebp),%edi
10a3b9: 57 push %edi
10a3ba: 6a 01 push $0x1
10a3bc: 50 push %eax
10a3bd: ff 73 04 pushl 0x4(%ebx)
10a3c0: ff 75 b0 pushl -0x50(%ebp)
10a3c3: 68 74 65 12 00 push $0x126574
10a3c8: e8 cb 2d 00 00 call 10d198 <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
10a3cd: 83 c4 30 add $0x30,%esp
10a3d0: 84 c0 test %al,%al
10a3d2: 75 2a jne 10a3fe <pthread_create+0x182>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
10a3d4: 56 push %esi
10a3d5: 56 push %esi
10a3d6: ff 75 b0 pushl -0x50(%ebp)
10a3d9: 68 74 65 12 00 push $0x126574
10a3de: e8 35 21 00 00 call 10c518 <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
10a3e3: 5b pop %ebx
10a3e4: ff 35 f4 63 12 00 pushl 0x1263f4
10a3ea: e8 1d 15 00 00 call 10b90c <_API_Mutex_Unlock>
return EAGAIN;
10a3ef: 83 c4 10 add $0x10,%esp
10a3f2: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp)
10a3f9: e9 a7 00 00 00 jmp 10a4a5 <pthread_create+0x229>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10a3fe: 8b 45 b0 mov -0x50(%ebp),%eax
10a401: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
api->Attributes = *the_attr;
10a407: b9 10 00 00 00 mov $0x10,%ecx
10a40c: 89 d7 mov %edx,%edi
10a40e: 89 de mov %ebx,%esi
10a410: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
api->detachstate = the_attr->detachstate;
10a412: 8b 43 3c mov 0x3c(%ebx),%eax
10a415: 89 42 40 mov %eax,0x40(%edx)
api->schedpolicy = schedpolicy;
10a418: 8b 45 ac mov -0x54(%ebp),%eax
10a41b: 89 82 84 00 00 00 mov %eax,0x84(%edx)
api->schedparam = schedparam;
10a421: 8d ba 88 00 00 00 lea 0x88(%edx),%edi
10a427: 8d 75 c4 lea -0x3c(%ebp),%esi
10a42a: b1 07 mov $0x7,%cl
10a42c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
10a42e: 83 ec 0c sub $0xc,%esp
10a431: 6a 00 push $0x0
10a433: ff 75 14 pushl 0x14(%ebp)
10a436: ff 75 10 pushl 0x10(%ebp)
10a439: 6a 01 push $0x1
10a43b: ff 75 b0 pushl -0x50(%ebp)
10a43e: 89 55 a4 mov %edx,-0x5c(%ebp)
10a441: e8 72 35 00 00 call 10d9b8 <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
10a446: 83 c4 20 add $0x20,%esp
10a449: 83 7d ac 04 cmpl $0x4,-0x54(%ebp)
10a44d: 8b 55 a4 mov -0x5c(%ebp),%edx
10a450: 75 2e jne 10a480 <pthread_create+0x204>
_Watchdog_Insert_ticks(
10a452: 83 ec 0c sub $0xc,%esp
&api->Sporadic_timer,
_Timespec_To_ticks( &api->schedparam.sched_ss_repl_period )
10a455: 8d 82 90 00 00 00 lea 0x90(%edx),%eax
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
10a45b: 50 push %eax
10a45c: e8 a7 36 00 00 call 10db08 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a461: 8b 55 a4 mov -0x5c(%ebp),%edx
10a464: 89 82 b4 00 00 00 mov %eax,0xb4(%edx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a46a: 58 pop %eax
10a46b: 59 pop %ecx
10a46c: 81 c2 a8 00 00 00 add $0xa8,%edx
10a472: 52 push %edx
10a473: 68 14 64 12 00 push $0x126414
10a478: e8 3f 39 00 00 call 10ddbc <_Watchdog_Insert>
10a47d: 83 c4 10 add $0x10,%esp
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
10a480: 8b 45 b0 mov -0x50(%ebp),%eax
10a483: 8b 50 08 mov 0x8(%eax),%edx
10a486: 8b 45 08 mov 0x8(%ebp),%eax
10a489: 89 10 mov %edx,(%eax)
_RTEMS_Unlock_allocator();
10a48b: 83 ec 0c sub $0xc,%esp
10a48e: ff 35 f4 63 12 00 pushl 0x1263f4
10a494: e8 73 14 00 00 call 10b90c <_API_Mutex_Unlock>
return 0;
10a499: 83 c4 10 add $0x10,%esp
10a49c: eb 07 jmp 10a4a5 <pthread_create+0x229>
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
10a49e: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
10a4a5: 8b 45 b4 mov -0x4c(%ebp),%eax
10a4a8: 8d 65 f4 lea -0xc(%ebp),%esp
10a4ab: 5b pop %ebx
10a4ac: 5e pop %esi
10a4ad: 5f pop %edi
10a4ae: c9 leave
10a4af: c3 ret
00110d4c <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
110d4c: 55 push %ebp
110d4d: 89 e5 mov %esp,%ebp
110d4f: 83 ec 10 sub $0x10,%esp
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
110d52: ff 75 08 pushl 0x8(%ebp)
110d55: ff 35 68 58 12 00 pushl 0x125868
110d5b: e8 88 ff ff ff call 110ce8 <_POSIX_Thread_Exit>
110d60: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
110d63: c9 leave <== NOT EXECUTED
110d64: c3 ret <== NOT EXECUTED
001222a4 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
1222a4: 55 push %ebp
1222a5: 89 e5 mov %esp,%ebp
1222a7: 57 push %edi
1222a8: 56 push %esi
1222a9: 53 push %ebx
1222aa: 83 ec 1c sub $0x1c,%esp
1222ad: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
1222b0: 85 db test %ebx,%ebx
1222b2: 74 08 je 1222bc <pthread_kill+0x18> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
1222b4: 8d 7b ff lea -0x1(%ebx),%edi
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
1222b7: 83 ff 1f cmp $0x1f,%edi
1222ba: 76 0d jbe 1222c9 <pthread_kill+0x25>
rtems_set_errno_and_return_minus_one( EINVAL );
1222bc: e8 0f 37 ff ff call 1159d0 <__errno>
1222c1: c7 00 16 00 00 00 movl $0x16,(%eax)
1222c7: eb 73 jmp 12233c <pthread_kill+0x98>
the_thread = _Thread_Get( thread, &location );
1222c9: 52 push %edx
1222ca: 52 push %edx
1222cb: 8d 45 e4 lea -0x1c(%ebp),%eax
1222ce: 50 push %eax
1222cf: ff 75 08 pushl 0x8(%ebp)
1222d2: e8 05 e7 fe ff call 1109dc <_Thread_Get>
1222d7: 89 c6 mov %eax,%esi
switch ( location ) {
1222d9: 83 c4 10 add $0x10,%esp
1222dc: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
1222e0: 75 4f jne 122331 <pthread_kill+0x8d> <== NEVER TAKEN
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
1222e2: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
1222e8: 6b c3 0c imul $0xc,%ebx,%eax
1222eb: 83 b8 18 ba 12 00 01 cmpl $0x1,0x12ba18(%eax)
1222f2: 74 34 je 122328 <pthread_kill+0x84> <== NEVER TAKEN
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
1222f4: b8 01 00 00 00 mov $0x1,%eax
1222f9: 89 f9 mov %edi,%ecx
1222fb: d3 e0 shl %cl,%eax
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
1222fd: 09 82 d4 00 00 00 or %eax,0xd4(%edx)
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
122303: 50 push %eax
122304: 6a 00 push $0x0
122306: 53 push %ebx
122307: 56 push %esi
122308: e8 93 fe ff ff call 1221a0 <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
12230d: 83 c4 10 add $0x10,%esp
122310: 83 3d d8 b9 12 00 00 cmpl $0x0,0x12b9d8
122317: 74 0f je 122328 <pthread_kill+0x84>
122319: 3b 35 dc b9 12 00 cmp 0x12b9dc,%esi
12231f: 75 07 jne 122328 <pthread_kill+0x84>
_Thread_Dispatch_necessary = true;
122321: c6 05 e8 b9 12 00 01 movb $0x1,0x12b9e8
}
_Thread_Enable_dispatch();
122328: e8 8d e6 fe ff call 1109ba <_Thread_Enable_dispatch>
return 0;
12232d: 31 c0 xor %eax,%eax
12232f: eb 0e jmp 12233f <pthread_kill+0x9b>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
122331: e8 9a 36 ff ff call 1159d0 <__errno> <== NOT EXECUTED
122336: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED
12233c: 83 c8 ff or $0xffffffff,%eax
}
12233f: 8d 65 f4 lea -0xc(%ebp),%esp
122342: 5b pop %ebx
122343: 5e pop %esi
122344: 5f pop %edi
122345: c9 leave
122346: c3 ret
0010bf78 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
10bf78: 55 push %ebp
10bf79: 89 e5 mov %esp,%ebp
10bf7b: 53 push %ebx
10bf7c: 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 );
10bf7f: 8d 45 f4 lea -0xc(%ebp),%eax
10bf82: 50 push %eax
10bf83: ff 75 0c pushl 0xc(%ebp)
10bf86: e8 b9 00 00 00 call 10c044 <_POSIX_Absolute_timeout_to_ticks>
10bf8b: 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,
10bf8d: 83 c4 0c add $0xc,%esp
10bf90: 83 f8 03 cmp $0x3,%eax
10bf93: 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 );
10bf96: ff 75 f4 pushl -0xc(%ebp)
10bf99: 0f b6 c2 movzbl %dl,%eax
10bf9c: 50 push %eax
10bf9d: ff 75 08 pushl 0x8(%ebp)
10bfa0: 88 55 e4 mov %dl,-0x1c(%ebp)
10bfa3: e8 e8 fe ff ff call 10be90 <_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) ) {
10bfa8: 83 c4 10 add $0x10,%esp
10bfab: 8a 55 e4 mov -0x1c(%ebp),%dl
10bfae: 84 d2 test %dl,%dl
10bfb0: 75 1d jne 10bfcf <pthread_mutex_timedlock+0x57>
10bfb2: 83 f8 10 cmp $0x10,%eax
10bfb5: 75 18 jne 10bfcf <pthread_mutex_timedlock+0x57><== NEVER TAKEN
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10bfb7: 85 db test %ebx,%ebx
10bfb9: 74 08 je 10bfc3 <pthread_mutex_timedlock+0x4b><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10bfbb: 4b dec %ebx
10bfbc: 83 fb 01 cmp $0x1,%ebx
10bfbf: 77 0e ja 10bfcf <pthread_mutex_timedlock+0x57><== NEVER TAKEN
10bfc1: eb 07 jmp 10bfca <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;
10bfc3: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED
10bfc8: eb 05 jmp 10bfcf <pthread_mutex_timedlock+0x57><== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10bfca: b8 74 00 00 00 mov $0x74,%eax
}
return lock_status;
}
10bfcf: 8b 5d fc mov -0x4(%ebp),%ebx
10bfd2: c9 leave
10bfd3: c3 ret
0010bbf0 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
10bbf0: 55 push %ebp
10bbf1: 89 e5 mov %esp,%ebp
10bbf3: 8b 55 08 mov 0x8(%ebp),%edx
10bbf6: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10bbf9: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
10bbfe: 85 d2 test %edx,%edx
10bc00: 74 0f je 10bc11 <pthread_mutexattr_setpshared+0x21>
10bc02: 83 3a 00 cmpl $0x0,(%edx)
10bc05: 74 0a je 10bc11 <pthread_mutexattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10bc07: 83 f9 01 cmp $0x1,%ecx
10bc0a: 77 05 ja 10bc11 <pthread_mutexattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10bc0c: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10bc0f: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10bc11: c9 leave
10bc12: c3 ret
00109e18 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
109e18: 55 push %ebp
109e19: 89 e5 mov %esp,%ebp
109e1b: 8b 55 08 mov 0x8(%ebp),%edx
109e1e: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
109e21: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
109e26: 85 d2 test %edx,%edx
109e28: 74 0f je 109e39 <pthread_mutexattr_settype+0x21>
109e2a: 83 3a 00 cmpl $0x0,(%edx)
109e2d: 74 0a je 109e39 <pthread_mutexattr_settype+0x21><== NEVER TAKEN
return EINVAL;
switch ( type ) {
109e2f: 83 f9 03 cmp $0x3,%ecx
109e32: 77 05 ja 109e39 <pthread_mutexattr_settype+0x21>
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
109e34: 89 4a 10 mov %ecx,0x10(%edx)
return 0;
109e37: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
109e39: c9 leave
109e3a: c3 ret
0010a8c8 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
10a8c8: 55 push %ebp
10a8c9: 89 e5 mov %esp,%ebp
10a8cb: 56 push %esi
10a8cc: 53 push %ebx
10a8cd: 83 ec 10 sub $0x10,%esp
10a8d0: 8b 5d 08 mov 0x8(%ebp),%ebx
10a8d3: 8b 75 0c mov 0xc(%ebp),%esi
if ( !once_control || !init_routine )
10a8d6: 85 f6 test %esi,%esi
10a8d8: 74 51 je 10a92b <pthread_once+0x63>
10a8da: 85 db test %ebx,%ebx
10a8dc: 74 4d je 10a92b <pthread_once+0x63>
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
10a8de: 31 c0 xor %eax,%eax
)
{
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
10a8e0: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a8e4: 75 4a jne 10a930 <pthread_once+0x68>
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
10a8e6: 52 push %edx
10a8e7: 8d 45 f4 lea -0xc(%ebp),%eax
10a8ea: 50 push %eax
10a8eb: 68 00 01 00 00 push $0x100
10a8f0: 68 00 01 00 00 push $0x100
10a8f5: e8 9e 0a 00 00 call 10b398 <rtems_task_mode>
if ( !once_control->init_executed ) {
10a8fa: 83 c4 10 add $0x10,%esp
10a8fd: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a901: 75 0f jne 10a912 <pthread_once+0x4a> <== NEVER TAKEN
once_control->is_initialized = true;
10a903: c7 03 01 00 00 00 movl $0x1,(%ebx)
once_control->init_executed = true;
10a909: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
(*init_routine)();
10a910: ff d6 call *%esi
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
10a912: 50 push %eax
10a913: 8d 45 f4 lea -0xc(%ebp),%eax
10a916: 50 push %eax
10a917: 68 00 01 00 00 push $0x100
10a91c: ff 75 f4 pushl -0xc(%ebp)
10a91f: e8 74 0a 00 00 call 10b398 <rtems_task_mode>
10a924: 83 c4 10 add $0x10,%esp
}
return 0;
10a927: 31 c0 xor %eax,%eax
10a929: eb 05 jmp 10a930 <pthread_once+0x68>
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
10a92b: b8 16 00 00 00 mov $0x16,%eax
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
10a930: 8d 65 f8 lea -0x8(%ebp),%esp
10a933: 5b pop %ebx
10a934: 5e pop %esi
10a935: c9 leave
10a936: c3 ret
0010b0f4 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
10b0f4: 55 push %ebp
10b0f5: 89 e5 mov %esp,%ebp
10b0f7: 56 push %esi
10b0f8: 53 push %ebx
10b0f9: 83 ec 10 sub $0x10,%esp
10b0fc: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Error check parameters
*/
if ( !rwlock )
return EINVAL;
10b0ff: b8 16 00 00 00 mov $0x16,%eax
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
10b104: 85 db test %ebx,%ebx
10b106: 0f 84 8b 00 00 00 je 10b197 <pthread_rwlock_init+0xa3>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10b10c: 8b 75 0c mov 0xc(%ebp),%esi
10b10f: 85 f6 test %esi,%esi
10b111: 75 0f jne 10b122 <pthread_rwlock_init+0x2e>
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
10b113: 83 ec 0c sub $0xc,%esp
10b116: 8d 75 ec lea -0x14(%ebp),%esi
10b119: 56 push %esi
10b11a: e8 5d 09 00 00 call 10ba7c <pthread_rwlockattr_init>
10b11f: 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;
10b122: 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 )
10b127: 83 3e 00 cmpl $0x0,(%esi)
10b12a: 74 6b je 10b197 <pthread_rwlock_init+0xa3><== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
10b12c: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10b130: 75 65 jne 10b197 <pthread_rwlock_init+0xa3><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
10b132: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b139: a1 50 83 12 00 mov 0x128350,%eax
10b13e: 40 inc %eax
10b13f: 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 );
10b144: 83 ec 0c sub $0xc,%esp
10b147: 68 34 85 12 00 push $0x128534
10b14c: e8 33 23 00 00 call 10d484 <_Objects_Allocate>
10b151: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
10b153: 83 c4 10 add $0x10,%esp
10b156: 85 c0 test %eax,%eax
10b158: 75 0c jne 10b166 <pthread_rwlock_init+0x72>
_Thread_Enable_dispatch();
10b15a: e8 03 32 00 00 call 10e362 <_Thread_Enable_dispatch>
return EAGAIN;
10b15f: b8 0b 00 00 00 mov $0xb,%eax
10b164: eb 31 jmp 10b197 <pthread_rwlock_init+0xa3>
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
10b166: 50 push %eax
10b167: 50 push %eax
10b168: 8d 45 f4 lea -0xc(%ebp),%eax
10b16b: 50 push %eax
10b16c: 8d 46 10 lea 0x10(%esi),%eax
10b16f: 50 push %eax
10b170: e8 7b 1b 00 00 call 10ccf0 <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b175: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10b178: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b17b: 8b 15 50 85 12 00 mov 0x128550,%edx
10b181: 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;
10b184: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
10b18b: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10b18d: e8 d0 31 00 00 call 10e362 <_Thread_Enable_dispatch>
return 0;
10b192: 83 c4 10 add $0x10,%esp
10b195: 31 c0 xor %eax,%eax
}
10b197: 8d 65 f8 lea -0x8(%ebp),%esp
10b19a: 5b pop %ebx
10b19b: 5e pop %esi
10b19c: c9 leave
10b19d: c3 ret
0010b208 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10b208: 55 push %ebp
10b209: 89 e5 mov %esp,%ebp
10b20b: 57 push %edi
10b20c: 56 push %esi
10b20d: 53 push %ebx
10b20e: 83 ec 2c sub $0x2c,%esp
10b211: 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;
10b214: 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 )
10b219: 85 ff test %edi,%edi
10b21b: 0f 84 87 00 00 00 je 10b2a8 <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 );
10b221: 50 push %eax
10b222: 50 push %eax
10b223: 8d 45 e0 lea -0x20(%ebp),%eax
10b226: 50 push %eax
10b227: ff 75 0c pushl 0xc(%ebp)
10b22a: e8 65 59 00 00 call 110b94 <_POSIX_Absolute_timeout_to_ticks>
10b22f: 89 c6 mov %eax,%esi
10b231: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b234: 8d 45 e4 lea -0x1c(%ebp),%eax
10b237: 50 push %eax
10b238: ff 37 pushl (%edi)
10b23a: 68 34 85 12 00 push $0x128534
10b23f: e8 6c 26 00 00 call 10d8b0 <_Objects_Get>
switch ( location ) {
10b244: 83 c4 10 add $0x10,%esp
10b247: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b24b: 75 5b jne 10b2a8 <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,
10b24d: 83 fe 03 cmp $0x3,%esi
10b250: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
10b253: 83 ec 0c sub $0xc,%esp
10b256: 6a 00 push $0x0
10b258: ff 75 e0 pushl -0x20(%ebp)
10b25b: 0f b6 ca movzbl %dl,%ecx
10b25e: 51 push %ecx
10b25f: ff 37 pushl (%edi)
10b261: 83 c0 10 add $0x10,%eax
10b264: 50 push %eax
10b265: 88 55 d4 mov %dl,-0x2c(%ebp)
10b268: e8 b7 1a 00 00 call 10cd24 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b26d: 83 c4 20 add $0x20,%esp
10b270: e8 ed 30 00 00 call 10e362 <_Thread_Enable_dispatch>
if ( !do_wait ) {
10b275: 8a 55 d4 mov -0x2c(%ebp),%dl
10b278: 84 d2 test %dl,%dl
10b27a: 75 17 jne 10b293 <pthread_rwlock_timedrdlock+0x8b>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
10b27c: a1 78 88 12 00 mov 0x128878,%eax
10b281: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b285: 75 0c jne 10b293 <pthread_rwlock_timedrdlock+0x8b>
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10b287: 85 f6 test %esi,%esi
10b289: 74 1d je 10b2a8 <pthread_rwlock_timedrdlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b28b: 4e dec %esi
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10b28c: 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 ||
10b28e: 83 fe 01 cmp $0x1,%esi
10b291: 76 15 jbe 10b2a8 <pthread_rwlock_timedrdlock+0xa0><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b293: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b296: a1 78 88 12 00 mov 0x128878,%eax
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b29b: ff 70 34 pushl 0x34(%eax)
10b29e: e8 bd 00 00 00 call 10b360 <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b2a3: 89 c3 mov %eax,%ebx
10b2a5: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b2a8: 89 d8 mov %ebx,%eax
10b2aa: 8d 65 f4 lea -0xc(%ebp),%esp
10b2ad: 5b pop %ebx
10b2ae: 5e pop %esi
10b2af: 5f pop %edi
10b2b0: c9 leave
10b2b1: c3 ret
0010b2b4 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10b2b4: 55 push %ebp
10b2b5: 89 e5 mov %esp,%ebp
10b2b7: 57 push %edi
10b2b8: 56 push %esi
10b2b9: 53 push %ebx
10b2ba: 83 ec 2c sub $0x2c,%esp
10b2bd: 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;
10b2c0: 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 )
10b2c5: 85 ff test %edi,%edi
10b2c7: 0f 84 87 00 00 00 je 10b354 <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 );
10b2cd: 50 push %eax
10b2ce: 50 push %eax
10b2cf: 8d 45 e0 lea -0x20(%ebp),%eax
10b2d2: 50 push %eax
10b2d3: ff 75 0c pushl 0xc(%ebp)
10b2d6: e8 b9 58 00 00 call 110b94 <_POSIX_Absolute_timeout_to_ticks>
10b2db: 89 c6 mov %eax,%esi
10b2dd: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b2e0: 8d 45 e4 lea -0x1c(%ebp),%eax
10b2e3: 50 push %eax
10b2e4: ff 37 pushl (%edi)
10b2e6: 68 34 85 12 00 push $0x128534
10b2eb: e8 c0 25 00 00 call 10d8b0 <_Objects_Get>
switch ( location ) {
10b2f0: 83 c4 10 add $0x10,%esp
10b2f3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b2f7: 75 5b jne 10b354 <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,
10b2f9: 83 fe 03 cmp $0x3,%esi
10b2fc: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
10b2ff: 83 ec 0c sub $0xc,%esp
10b302: 6a 00 push $0x0
10b304: ff 75 e0 pushl -0x20(%ebp)
10b307: 0f b6 ca movzbl %dl,%ecx
10b30a: 51 push %ecx
10b30b: ff 37 pushl (%edi)
10b30d: 83 c0 10 add $0x10,%eax
10b310: 50 push %eax
10b311: 88 55 d4 mov %dl,-0x2c(%ebp)
10b314: e8 c3 1a 00 00 call 10cddc <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b319: 83 c4 20 add $0x20,%esp
10b31c: e8 41 30 00 00 call 10e362 <_Thread_Enable_dispatch>
if ( !do_wait &&
10b321: 8a 55 d4 mov -0x2c(%ebp),%dl
10b324: 84 d2 test %dl,%dl
10b326: 75 17 jne 10b33f <pthread_rwlock_timedwrlock+0x8b>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
10b328: a1 78 88 12 00 mov 0x128878,%eax
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
10b32d: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b331: 75 0c jne 10b33f <pthread_rwlock_timedwrlock+0x8b>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10b333: 85 f6 test %esi,%esi
10b335: 74 1d je 10b354 <pthread_rwlock_timedwrlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b337: 4e dec %esi
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10b338: 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 ||
10b33a: 83 fe 01 cmp $0x1,%esi
10b33d: 76 15 jbe 10b354 <pthread_rwlock_timedwrlock+0xa0><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b33f: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b342: 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(
10b347: ff 70 34 pushl 0x34(%eax)
10b34a: e8 11 00 00 00 call 10b360 <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b34f: 89 c3 mov %eax,%ebx
10b351: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b354: 89 d8 mov %ebx,%eax
10b356: 8d 65 f4 lea -0xc(%ebp),%esp
10b359: 5b pop %ebx
10b35a: 5e pop %esi
10b35b: 5f pop %edi
10b35c: c9 leave
10b35d: c3 ret
0010ba9c <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
10ba9c: 55 push %ebp
10ba9d: 89 e5 mov %esp,%ebp
10ba9f: 8b 55 08 mov 0x8(%ebp),%edx
10baa2: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr )
return EINVAL;
10baa5: b8 16 00 00 00 mov $0x16,%eax
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
10baaa: 85 d2 test %edx,%edx
10baac: 74 0f je 10babd <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
if ( !attr->is_initialized )
10baae: 83 3a 00 cmpl $0x0,(%edx)
10bab1: 74 0a je 10babd <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10bab3: 83 f9 01 cmp $0x1,%ecx
10bab6: 77 05 ja 10babd <pthread_rwlockattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10bab8: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10babb: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10babd: c9 leave
10babe: c3 ret
0010c798 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
10c798: 55 push %ebp
10c799: 89 e5 mov %esp,%ebp
10c79b: 57 push %edi
10c79c: 56 push %esi
10c79d: 53 push %ebx
10c79e: 83 ec 2c sub $0x2c,%esp
10c7a1: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
10c7a4: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp)
int rc;
/*
* Check all the parameters
*/
if ( !param )
10c7ab: 85 f6 test %esi,%esi
10c7ad: 0f 84 fc 00 00 00 je 10c8af <pthread_setschedparam+0x117>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
10c7b3: 8d 45 e0 lea -0x20(%ebp),%eax
10c7b6: 50 push %eax
10c7b7: 8d 45 e4 lea -0x1c(%ebp),%eax
10c7ba: 50 push %eax
10c7bb: 56 push %esi
10c7bc: ff 75 0c pushl 0xc(%ebp)
10c7bf: e8 20 53 00 00 call 111ae4 <_POSIX_Thread_Translate_sched_param>
10c7c4: 89 45 d4 mov %eax,-0x2c(%ebp)
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
10c7c7: 83 c4 10 add $0x10,%esp
10c7ca: 85 c0 test %eax,%eax
10c7cc: 0f 85 dd 00 00 00 jne 10c8af <pthread_setschedparam+0x117>
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
10c7d2: 53 push %ebx
10c7d3: 53 push %ebx
10c7d4: 8d 45 dc lea -0x24(%ebp),%eax
10c7d7: 50 push %eax
10c7d8: ff 75 08 pushl 0x8(%ebp)
10c7db: e8 54 27 00 00 call 10ef34 <_Thread_Get>
10c7e0: 89 c2 mov %eax,%edx
switch ( location ) {
10c7e2: 83 c4 10 add $0x10,%esp
10c7e5: 83 7d dc 00 cmpl $0x0,-0x24(%ebp)
10c7e9: 0f 85 b9 00 00 00 jne 10c8a8 <pthread_setschedparam+0x110>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10c7ef: 8b 98 ec 00 00 00 mov 0xec(%eax),%ebx
if ( api->schedpolicy == SCHED_SPORADIC )
10c7f5: 83 bb 84 00 00 00 04 cmpl $0x4,0x84(%ebx)
10c7fc: 75 18 jne 10c816 <pthread_setschedparam+0x7e>
(void) _Watchdog_Remove( &api->Sporadic_timer );
10c7fe: 83 ec 0c sub $0xc,%esp
10c801: 8d 83 a8 00 00 00 lea 0xa8(%ebx),%eax
10c807: 50 push %eax
10c808: 89 55 d0 mov %edx,-0x30(%ebp)
10c80b: e8 68 35 00 00 call 10fd78 <_Watchdog_Remove>
10c810: 83 c4 10 add $0x10,%esp
10c813: 8b 55 d0 mov -0x30(%ebp),%edx
api->schedpolicy = policy;
10c816: 8b 45 0c mov 0xc(%ebp),%eax
10c819: 89 83 84 00 00 00 mov %eax,0x84(%ebx)
api->schedparam = *param;
10c81f: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi
10c825: b9 07 00 00 00 mov $0x7,%ecx
10c82a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_thread->budget_algorithm = budget_algorithm;
10c82c: 8b 45 e4 mov -0x1c(%ebp),%eax
10c82f: 89 42 7c mov %eax,0x7c(%edx)
the_thread->budget_callout = budget_callout;
10c832: 8b 45 e0 mov -0x20(%ebp),%eax
10c835: 89 82 80 00 00 00 mov %eax,0x80(%edx)
switch ( api->schedpolicy ) {
10c83b: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10c83f: 78 60 js 10c8a1 <pthread_setschedparam+0x109><== NEVER TAKEN
10c841: 83 7d 0c 02 cmpl $0x2,0xc(%ebp)
10c845: 7e 08 jle 10c84f <pthread_setschedparam+0xb7>
10c847: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
10c84b: 75 54 jne 10c8a1 <pthread_setschedparam+0x109><== NEVER TAKEN
10c84d: eb 24 jmp 10c873 <pthread_setschedparam+0xdb>
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c84f: a1 c0 a3 12 00 mov 0x12a3c0,%eax
10c854: 89 42 78 mov %eax,0x78(%edx)
10c857: 0f b6 05 88 62 12 00 movzbl 0x126288,%eax
10c85e: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax
the_thread->real_priority =
10c864: 89 42 18 mov %eax,0x18(%edx)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
10c867: 51 push %ecx
10c868: 6a 01 push $0x1
10c86a: 50 push %eax
10c86b: 52 push %edx
10c86c: e8 cb 22 00 00 call 10eb3c <_Thread_Change_priority>
10c871: eb 2b jmp 10c89e <pthread_setschedparam+0x106>
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
10c873: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax
10c879: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
_Watchdog_Remove( &api->Sporadic_timer );
10c87f: 83 ec 0c sub $0xc,%esp
10c882: 81 c3 a8 00 00 00 add $0xa8,%ebx
10c888: 53 push %ebx
10c889: 89 55 d0 mov %edx,-0x30(%ebp)
10c88c: e8 e7 34 00 00 call 10fd78 <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
10c891: 58 pop %eax
10c892: 5a pop %edx
10c893: 8b 55 d0 mov -0x30(%ebp),%edx
10c896: 52 push %edx
10c897: 6a 00 push $0x0
10c899: e8 e5 fd ff ff call 10c683 <_POSIX_Threads_Sporadic_budget_TSR>
break;
10c89e: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10c8a1: e8 6c 26 00 00 call 10ef12 <_Thread_Enable_dispatch>
return 0;
10c8a6: eb 07 jmp 10c8af <pthread_setschedparam+0x117>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
10c8a8: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp)
}
10c8af: 8b 45 d4 mov -0x2c(%ebp),%eax
10c8b2: 8d 65 f4 lea -0xc(%ebp),%esp
10c8b5: 5b pop %ebx
10c8b6: 5e pop %esi
10c8b7: 5f pop %edi
10c8b8: c9 leave
10c8b9: c3 ret
0010a690 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
10a690: 55 push %ebp
10a691: 89 e5 mov %esp,%ebp
10a693: 53 push %ebx
10a694: 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() )
10a697: 83 3d 6c 68 12 00 00 cmpl $0x0,0x12686c
10a69e: 75 48 jne 10a6e8 <pthread_testcancel+0x58><== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a6a0: a1 70 68 12 00 mov 0x126870,%eax
10a6a5: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
10a6ab: 8b 15 48 63 12 00 mov 0x126348,%edx
10a6b1: 42 inc %edx
10a6b2: 89 15 48 63 12 00 mov %edx,0x126348
*/
void pthread_testcancel( void )
{
POSIX_API_Control *thread_support;
bool cancel = false;
10a6b8: 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 &&
10a6ba: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax)
10a6c1: 75 0a jne 10a6cd <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));
10a6c3: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax)
10a6ca: 0f 95 c3 setne %bl
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
10a6cd: e8 e4 25 00 00 call 10ccb6 <_Thread_Enable_dispatch>
if ( cancel )
10a6d2: 84 db test %bl,%bl
10a6d4: 74 12 je 10a6e8 <pthread_testcancel+0x58>
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
10a6d6: 50 push %eax
10a6d7: 50 push %eax
10a6d8: 6a ff push $0xffffffff
10a6da: ff 35 70 68 12 00 pushl 0x126870
10a6e0: e8 bf 52 00 00 call 10f9a4 <_POSIX_Thread_Exit>
10a6e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
10a6e8: 8b 5d fc mov -0x4(%ebp),%ebx
10a6eb: c9 leave
10a6ec: c3 ret
0011d114 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
11d114: 55 push %ebp
11d115: 89 e5 mov %esp,%ebp
11d117: 56 push %esi
11d118: 53 push %ebx
11d119: 8b 5d 08 mov 0x8(%ebp),%ebx
11d11c: 8b 55 0c mov 0xc(%ebp),%edx
11d11f: 8b 4d 10 mov 0x10(%ebp),%ecx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11d122: 3b 1d 44 11 12 00 cmp 0x121144,%ebx
11d128: 73 14 jae 11d13e <read+0x2a> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
11d12a: 6b db 38 imul $0x38,%ebx,%ebx
11d12d: 03 1d f8 51 12 00 add 0x1251f8,%ebx
rtems_libio_check_is_open( iop );
11d133: 8b 73 14 mov 0x14(%ebx),%esi
11d136: f7 c6 00 01 00 00 test $0x100,%esi
11d13c: 75 0d jne 11d14b <read+0x37>
11d13e: e8 f5 3f ff ff call 111138 <__errno>
11d143: c7 00 09 00 00 00 movl $0x9,(%eax)
11d149: eb 1a jmp 11d165 <read+0x51>
rtems_libio_check_buffer( buffer );
11d14b: 85 d2 test %edx,%edx
11d14d: 74 0b je 11d15a <read+0x46> <== NEVER TAKEN
rtems_libio_check_count( count );
11d14f: 31 c0 xor %eax,%eax
11d151: 85 c9 test %ecx,%ecx
11d153: 74 31 je 11d186 <read+0x72>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
11d155: 83 e6 02 and $0x2,%esi
11d158: 75 10 jne 11d16a <read+0x56>
11d15a: e8 d9 3f ff ff call 111138 <__errno>
11d15f: c7 00 16 00 00 00 movl $0x16,(%eax)
11d165: 83 c8 ff or $0xffffffff,%eax
11d168: eb 1c jmp 11d186 <read+0x72>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
11d16a: 50 push %eax
11d16b: 8b 43 20 mov 0x20(%ebx),%eax
11d16e: 51 push %ecx
11d16f: 52 push %edx
11d170: 53 push %ebx
11d171: ff 50 08 call *0x8(%eax)
if ( rc > 0 )
11d174: 83 c4 10 add $0x10,%esp
11d177: 85 c0 test %eax,%eax
11d179: 7e 0b jle 11d186 <read+0x72>
iop->offset += rc;
11d17b: 89 c1 mov %eax,%ecx
11d17d: c1 f9 1f sar $0x1f,%ecx
11d180: 01 43 0c add %eax,0xc(%ebx)
11d183: 11 4b 10 adc %ecx,0x10(%ebx)
return rc;
}
11d186: 8d 65 f8 lea -0x8(%ebp),%esp
11d189: 5b pop %ebx
11d18a: 5e pop %esi
11d18b: c9 leave
11d18c: c3 ret
00109ef8 <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
109ef8: 55 push %ebp
109ef9: 89 e5 mov %esp,%ebp
109efb: 57 push %edi
109efc: 56 push %esi
109efd: 53 push %ebx
109efe: 83 ec 2c sub $0x2c,%esp
109f01: 8b 55 08 mov 0x8(%ebp),%edx
109f04: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
109f07: 85 db test %ebx,%ebx
109f09: 75 10 jne 109f1b <readlink+0x23>
rtems_set_errno_and_return_minus_one( EFAULT );
109f0b: e8 34 99 00 00 call 113844 <__errno>
109f10: c7 00 0e 00 00 00 movl $0xe,(%eax)
109f16: 83 cf ff or $0xffffffff,%edi
109f19: eb 69 jmp 109f84 <readlink+0x8c>
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
109f1b: 31 c0 xor %eax,%eax
109f1d: 83 c9 ff or $0xffffffff,%ecx
109f20: 89 d7 mov %edx,%edi
109f22: f2 ae repnz scas %es:(%edi),%al
109f24: f7 d1 not %ecx
109f26: 49 dec %ecx
109f27: 83 ec 0c sub $0xc,%esp
109f2a: 6a 00 push $0x0
109f2c: 8d 75 d4 lea -0x2c(%ebp),%esi
109f2f: 56 push %esi
109f30: 6a 00 push $0x0
109f32: 51 push %ecx
109f33: 52 push %edx
109f34: e8 49 f0 ff ff call 108f82 <rtems_filesystem_evaluate_path>
0, &loc, false );
if ( result != 0 )
109f39: 83 c4 20 add $0x20,%esp
return -1;
109f3c: 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 )
109f3f: 85 c0 test %eax,%eax
109f41: 75 41 jne 109f84 <readlink+0x8c> <== NEVER TAKEN
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
109f43: 83 ec 0c sub $0xc,%esp
109f46: 56 push %esi
109f47: 8b 45 e0 mov -0x20(%ebp),%eax
109f4a: ff 50 10 call *0x10(%eax)
109f4d: 83 c4 10 add $0x10,%esp
109f50: 83 f8 04 cmp $0x4,%eax
109f53: 74 16 je 109f6b <readlink+0x73>
rtems_filesystem_freenode( &loc );
109f55: 83 ec 0c sub $0xc,%esp
109f58: 56 push %esi
109f59: e8 e2 f0 ff ff call 109040 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EINVAL );
109f5e: e8 e1 98 00 00 call 113844 <__errno>
109f63: c7 00 16 00 00 00 movl $0x16,(%eax)
109f69: eb 16 jmp 109f81 <readlink+0x89>
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
109f6b: 50 push %eax
109f6c: ff 75 10 pushl 0x10(%ebp)
109f6f: 53 push %ebx
109f70: 56 push %esi
109f71: 8b 45 e0 mov -0x20(%ebp),%eax
109f74: ff 50 3c call *0x3c(%eax)
109f77: 89 c7 mov %eax,%edi
rtems_filesystem_freenode( &loc );
109f79: 89 34 24 mov %esi,(%esp)
109f7c: e8 bf f0 ff ff call 109040 <rtems_filesystem_freenode>
return result;
109f81: 83 c4 10 add $0x10,%esp
}
109f84: 89 f8 mov %edi,%eax
109f86: 8d 65 f4 lea -0xc(%ebp),%esp
109f89: 5b pop %ebx
109f8a: 5e pop %esi
109f8b: 5f pop %edi
109f8c: c9 leave
109f8d: c3 ret
00108ca8 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
108ca8: 55 push %ebp
108ca9: 89 e5 mov %esp,%ebp
108cab: 57 push %edi
108cac: 56 push %esi
108cad: 53 push %ebx
108cae: 83 ec 2c sub $0x2c,%esp
108cb1: 8b 75 08 mov 0x8(%ebp),%esi
108cb4: 8b 7d 0c mov 0xc(%ebp),%edi
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
108cb7: 3b 35 44 21 12 00 cmp 0x122144,%esi
108cbd: 73 11 jae 108cd0 <readv+0x28>
iop = rtems_libio_iop( fd );
108cbf: 6b f6 38 imul $0x38,%esi,%esi
108cc2: 03 35 f8 61 12 00 add 0x1261f8,%esi
rtems_libio_check_is_open( iop );
108cc8: 8b 46 14 mov 0x14(%esi),%eax
108ccb: f6 c4 01 test $0x1,%ah
108cce: 75 10 jne 108ce0 <readv+0x38>
108cd0: e8 33 90 00 00 call 111d08 <__errno>
108cd5: c7 00 09 00 00 00 movl $0x9,(%eax)
108cdb: e9 a4 00 00 00 jmp 108d84 <readv+0xdc>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
108ce0: a8 02 test $0x2,%al
108ce2: 74 35 je 108d19 <readv+0x71> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
108ce4: 85 ff test %edi,%edi
108ce6: 74 31 je 108d19 <readv+0x71>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
108ce8: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
108cec: 7e 2b jle 108d19 <readv+0x71>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
108cee: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp)
108cf5: 7f 22 jg 108d19 <readv+0x71> <== NEVER TAKEN
108cf7: b2 01 mov $0x1,%dl
108cf9: 31 c0 xor %eax,%eax
108cfb: 31 c9 xor %ecx,%ecx
108cfd: 89 75 d4 mov %esi,-0x2c(%ebp)
108d00: eb 03 jmp 108d05 <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;
108d02: 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 )
108d05: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8)
108d09: 74 0e je 108d19 <readv+0x71>
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
108d0b: 8b 5c c7 04 mov 0x4(%edi,%eax,8),%ebx
108d0f: 8d 34 19 lea (%ecx,%ebx,1),%esi
108d12: 89 75 e4 mov %esi,-0x1c(%ebp)
if ( total < old )
108d15: 39 ce cmp %ecx,%esi
108d17: 7d 0d jge 108d26 <readv+0x7e>
rtems_set_errno_and_return_minus_one( EINVAL );
108d19: e8 ea 8f 00 00 call 111d08 <__errno>
108d1e: c7 00 16 00 00 00 movl $0x16,(%eax)
108d24: eb 5e jmp 108d84 <readv+0xdc>
if ( iov[v].iov_len )
all_zeros = false;
108d26: 85 db test %ebx,%ebx
108d28: 0f 94 c1 sete %cl
108d2b: f7 d9 neg %ecx
108d2d: 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++ ) {
108d2f: 40 inc %eax
108d30: 3b 45 10 cmp 0x10(%ebp),%eax
108d33: 7c cd jl 108d02 <readv+0x5a>
108d35: 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;
108d38: 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 ) {
108d3a: 84 d2 test %dl,%dl
108d3c: 75 49 jne 108d87 <readv+0xdf>
108d3e: 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)(
108d45: 50 push %eax
108d46: 8b 46 20 mov 0x20(%esi),%eax
108d49: 8b 55 e4 mov -0x1c(%ebp),%edx
108d4c: ff 74 d7 04 pushl 0x4(%edi,%edx,8)
108d50: ff 34 d7 pushl (%edi,%edx,8)
108d53: 56 push %esi
108d54: ff 50 08 call *0x8(%eax)
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
108d57: 83 c4 10 add $0x10,%esp
108d5a: 83 f8 00 cmp $0x0,%eax
108d5d: 7c 25 jl 108d84 <readv+0xdc> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
108d5f: 74 0d je 108d6e <readv+0xc6> <== NEVER TAKEN
iop->offset += bytes;
108d61: 89 c1 mov %eax,%ecx
108d63: c1 f9 1f sar $0x1f,%ecx
108d66: 01 46 0c add %eax,0xc(%esi)
108d69: 11 4e 10 adc %ecx,0x10(%esi)
total += bytes;
108d6c: 01 c3 add %eax,%ebx
}
if (bytes != iov[ v ].iov_len)
108d6e: 8b 55 e4 mov -0x1c(%ebp),%edx
108d71: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax
108d75: 75 10 jne 108d87 <readv+0xdf> <== NEVER TAKEN
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
108d77: 42 inc %edx
108d78: 89 55 e4 mov %edx,-0x1c(%ebp)
108d7b: 8b 45 10 mov 0x10(%ebp),%eax
108d7e: 39 c2 cmp %eax,%edx
108d80: 7c c3 jl 108d45 <readv+0x9d>
108d82: eb 03 jmp 108d87 <readv+0xdf>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
108d84: 83 cb ff or $0xffffffff,%ebx
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
108d87: 89 d8 mov %ebx,%eax
108d89: 8d 65 f4 lea -0xc(%ebp),%esp
108d8c: 5b pop %ebx
108d8d: 5e pop %esi
108d8e: 5f pop %edi
108d8f: c9 leave
108d90: c3 ret
0011d218 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
11d218: 55 push %ebp
11d219: 89 e5 mov %esp,%ebp
11d21b: 57 push %edi
11d21c: 56 push %esi
11d21d: 53 push %ebx
11d21e: 83 ec 2c sub $0x2c,%esp
11d221: 8b 5d 08 mov 0x8(%ebp),%ebx
11d224: 8b 75 0c mov 0xc(%ebp),%esi
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
11d227: 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())) {
11d22d: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c
11d234: 75 1a jne 11d250 <realloc+0x38> <== NEVER TAKEN
if (_Thread_Dispatch_disable_level > 0)
11d236: a1 40 53 12 00 mov 0x125340,%eax
11d23b: 85 c0 test %eax,%eax
11d23d: 0f 85 ad 00 00 00 jne 11d2f0 <realloc+0xd8> <== NEVER TAKEN
return (void *) 0;
if (_ISR_Nest_level > 0)
11d243: 83 3d 64 58 12 00 00 cmpl $0x0,0x125864
11d24a: 0f 85 a0 00 00 00 jne 11d2f0 <realloc+0xd8> <== NEVER TAKEN
}
/*
* Continue with realloc().
*/
if ( !ptr )
11d250: 85 db test %ebx,%ebx
11d252: 75 13 jne 11d267 <realloc+0x4f>
return malloc( size );
11d254: 83 ec 0c sub $0xc,%esp
11d257: 56 push %esi
11d258: e8 b7 a3 fe ff call 107614 <malloc>
11d25d: 89 c3 mov %eax,%ebx
11d25f: 83 c4 10 add $0x10,%esp
11d262: e9 8b 00 00 00 jmp 11d2f2 <realloc+0xda>
if ( !size ) {
11d267: 85 f6 test %esi,%esi
11d269: 75 0e jne 11d279 <realloc+0x61> <== ALWAYS TAKEN
free( ptr );
11d26b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
11d26e: 53 push %ebx <== NOT EXECUTED
11d26f: e8 04 a1 fe ff call 107378 <free> <== NOT EXECUTED
return (void *) 0;
11d274: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
11d277: eb 77 jmp 11d2f0 <realloc+0xd8> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
11d279: 52 push %edx
11d27a: 8d 45 e4 lea -0x1c(%ebp),%eax
11d27d: 50 push %eax
11d27e: 53 push %ebx
11d27f: ff 35 80 11 12 00 pushl 0x121180
11d285: e8 ee 00 00 00 call 11d378 <_Protected_heap_Get_block_size>
11d28a: 83 c4 10 add $0x10,%esp
11d28d: 84 c0 test %al,%al
11d28f: 75 0d jne 11d29e <realloc+0x86>
errno = EINVAL;
11d291: e8 a2 3e ff ff call 111138 <__errno>
11d296: c7 00 16 00 00 00 movl $0x16,(%eax)
11d29c: eb 52 jmp 11d2f0 <realloc+0xd8>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
11d29e: 50 push %eax
11d29f: 56 push %esi
11d2a0: 53 push %ebx
11d2a1: ff 35 80 11 12 00 pushl 0x121180
11d2a7: e8 04 01 00 00 call 11d3b0 <_Protected_heap_Resize_block>
11d2ac: 83 c4 10 add $0x10,%esp
11d2af: 84 c0 test %al,%al
11d2b1: 75 3f jne 11d2f2 <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 );
11d2b3: 83 ec 0c sub $0xc,%esp
11d2b6: 56 push %esi
11d2b7: e8 58 a3 fe ff call 107614 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
11d2bc: ff 0d 14 52 12 00 decl 0x125214
if ( !new_area ) {
11d2c2: 83 c4 10 add $0x10,%esp
11d2c5: 85 c0 test %eax,%eax
11d2c7: 74 27 je 11d2f0 <realloc+0xd8>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
11d2c9: 8b 55 e4 mov -0x1c(%ebp),%edx
11d2cc: 89 f1 mov %esi,%ecx
11d2ce: 39 d6 cmp %edx,%esi
11d2d0: 76 02 jbe 11d2d4 <realloc+0xbc> <== NEVER TAKEN
11d2d2: 89 d1 mov %edx,%ecx
11d2d4: 89 c7 mov %eax,%edi
11d2d6: 89 de mov %ebx,%esi
11d2d8: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
free( ptr );
11d2da: 83 ec 0c sub $0xc,%esp
11d2dd: 53 push %ebx
11d2de: 89 45 d4 mov %eax,-0x2c(%ebp)
11d2e1: e8 92 a0 fe ff call 107378 <free>
return new_area;
11d2e6: 83 c4 10 add $0x10,%esp
11d2e9: 8b 45 d4 mov -0x2c(%ebp),%eax
11d2ec: 89 c3 mov %eax,%ebx
11d2ee: eb 02 jmp 11d2f2 <realloc+0xda>
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
11d2f0: 31 db xor %ebx,%ebx
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
11d2f2: 89 d8 mov %ebx,%eax
11d2f4: 8d 65 f4 lea -0xc(%ebp),%esp
11d2f7: 5b pop %ebx
11d2f8: 5e pop %esi
11d2f9: 5f pop %edi
11d2fa: c9 leave
11d2fb: c3 ret
001083e4 <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
1083e4: 55 push %ebp
1083e5: 89 e5 mov %esp,%ebp
1083e7: 57 push %edi
1083e8: 56 push %esi
1083e9: 53 push %ebx
1083ea: 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 );
1083ed: ff 75 08 pushl 0x8(%ebp)
1083f0: e8 da f2 ff ff call 1076cf <rtems_filesystem_dirname>
1083f5: 89 45 b4 mov %eax,-0x4c(%ebp)
if ( parentpathlen == 0 )
1083f8: 83 c4 10 add $0x10,%esp
1083fb: 85 c0 test %eax,%eax
1083fd: 8d 45 d0 lea -0x30(%ebp),%eax
108400: 75 15 jne 108417 <rmdir+0x33>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
108402: 51 push %ecx
108403: 50 push %eax
108404: 8d 45 e4 lea -0x1c(%ebp),%eax
108407: 50 push %eax
108408: ff 75 08 pushl 0x8(%ebp)
10840b: e8 08 01 00 00 call 108518 <rtems_filesystem_get_start_loc>
108410: 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;
108413: 31 db xor %ebx,%ebx
108415: eb 25 jmp 10843c <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,
108417: 83 ec 0c sub $0xc,%esp
10841a: 6a 00 push $0x0
10841c: 50 push %eax
10841d: 6a 02 push $0x2
10841f: ff 75 b4 pushl -0x4c(%ebp)
108422: ff 75 08 pushl 0x8(%ebp)
108425: e8 64 f2 ff ff call 10768e <rtems_filesystem_evaluate_path>
10842a: 89 c2 mov %eax,%edx
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
10842c: 83 c4 20 add $0x20,%esp
return -1;
10842f: 83 c8 ff or $0xffffffff,%eax
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
108432: 85 d2 test %edx,%edx
108434: 0f 85 d6 00 00 00 jne 108510 <rmdir+0x12c> <== NEVER TAKEN
return -1;
free_parentloc = true;
10843a: b3 01 mov $0x1,%bl
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
10843c: 8d 7d bc lea -0x44(%ebp),%edi
10843f: 8d 75 d0 lea -0x30(%ebp),%esi
108442: b9 05 00 00 00 mov $0x5,%ecx
108447: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = pathname + parentpathlen;
108449: 8b 75 08 mov 0x8(%ebp),%esi
10844c: 03 75 b4 add -0x4c(%ebp),%esi
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
10844f: 83 c9 ff or $0xffffffff,%ecx
108452: 89 f7 mov %esi,%edi
108454: 31 c0 xor %eax,%eax
108456: f2 ae repnz scas %es:(%edi),%al
108458: f7 d1 not %ecx
10845a: 49 dec %ecx
10845b: 52 push %edx
10845c: 52 push %edx
10845d: 51 push %ecx
10845e: 56 push %esi
10845f: e8 aa f2 ff ff call 10770e <rtems_filesystem_prefix_separators>
108464: 01 c6 add %eax,%esi
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
108466: 83 c9 ff or $0xffffffff,%ecx
108469: 89 f7 mov %esi,%edi
10846b: 31 c0 xor %eax,%eax
10846d: f2 ae repnz scas %es:(%edi),%al
10846f: f7 d1 not %ecx
108471: 49 dec %ecx
108472: c7 04 24 00 00 00 00 movl $0x0,(%esp)
108479: 8d 7d bc lea -0x44(%ebp),%edi
10847c: 57 push %edi
10847d: 6a 00 push $0x0
10847f: 51 push %ecx
108480: 56 push %esi
108481: e8 aa f1 ff ff call 107630 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
108486: 83 c4 20 add $0x20,%esp
108489: 85 c0 test %eax,%eax
10848b: 74 13 je 1084a0 <rmdir+0xbc>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
10848d: 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 )
108490: 84 db test %bl,%bl
108492: 74 7c je 108510 <rmdir+0x12c>
rtems_filesystem_freenode( &parentloc );
108494: 83 ec 0c sub $0xc,%esp
108497: 8d 55 d0 lea -0x30(%ebp),%edx
10849a: 52 push %edx
10849b: 89 45 b0 mov %eax,-0x50(%ebp)
10849e: eb 65 jmp 108505 <rmdir+0x121>
}
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
1084a0: 83 ec 0c sub $0xc,%esp
1084a3: 57 push %edi
1084a4: 8b 45 c8 mov -0x38(%ebp),%eax
1084a7: ff 50 10 call *0x10(%eax)
1084aa: 83 c4 10 add $0x10,%esp
1084ad: 48 dec %eax
1084ae: 74 2f je 1084df <rmdir+0xfb>
rtems_filesystem_freenode( &loc );
1084b0: 83 ec 0c sub $0xc,%esp
1084b3: 57 push %edi
1084b4: e8 93 f2 ff ff call 10774c <rtems_filesystem_freenode>
if ( free_parentloc )
1084b9: 83 c4 10 add $0x10,%esp
1084bc: 84 db test %bl,%bl
1084be: 74 0f je 1084cf <rmdir+0xeb> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
1084c0: 83 ec 0c sub $0xc,%esp
1084c3: 8d 45 d0 lea -0x30(%ebp),%eax
1084c6: 50 push %eax
1084c7: e8 80 f2 ff ff call 10774c <rtems_filesystem_freenode>
1084cc: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( ENOTDIR );
1084cf: e8 04 94 00 00 call 1118d8 <__errno>
1084d4: c7 00 14 00 00 00 movl $0x14,(%eax)
1084da: 83 c8 ff or $0xffffffff,%eax
1084dd: eb 31 jmp 108510 <rmdir+0x12c>
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
1084df: 50 push %eax
1084e0: 50 push %eax
1084e1: 57 push %edi
1084e2: 8d 75 d0 lea -0x30(%ebp),%esi
1084e5: 56 push %esi
1084e6: 8b 45 c4 mov -0x3c(%ebp),%eax
1084e9: ff 50 34 call *0x34(%eax)
rtems_filesystem_freenode( &loc );
1084ec: 89 3c 24 mov %edi,(%esp)
1084ef: 89 45 b0 mov %eax,-0x50(%ebp)
1084f2: e8 55 f2 ff ff call 10774c <rtems_filesystem_freenode>
if ( free_parentloc )
1084f7: 83 c4 10 add $0x10,%esp
1084fa: 84 db test %bl,%bl
1084fc: 8b 45 b0 mov -0x50(%ebp),%eax
1084ff: 74 0f je 108510 <rmdir+0x12c>
rtems_filesystem_freenode( &parentloc );
108501: 83 ec 0c sub $0xc,%esp
108504: 56 push %esi
108505: e8 42 f2 ff ff call 10774c <rtems_filesystem_freenode>
10850a: 83 c4 10 add $0x10,%esp
10850d: 8b 45 b0 mov -0x50(%ebp),%eax
return result;
}
108510: 8d 65 f4 lea -0xc(%ebp),%esp
108513: 5b pop %ebx
108514: 5e pop %esi
108515: 5f pop %edi
108516: c9 leave
108517: c3 ret
0010af85 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
10af85: 55 push %ebp
10af86: 89 e5 mov %esp,%ebp
10af88: 57 push %edi
10af89: 56 push %esi
10af8a: 53 push %ebx
10af8b: 83 ec 58 sub $0x58,%esp
10af8e: 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);
10af91: 68 d8 72 12 00 push $0x1272d8
10af96: e8 c5 08 00 00 call 10b860 <pthread_mutex_lock>
10af9b: 89 45 b4 mov %eax,-0x4c(%ebp)
if (result != 0) {
10af9e: 83 c4 10 add $0x10,%esp
10afa1: 85 c0 test %eax,%eax
10afa3: 74 0e je 10afb3 <rtems_aio_enqueue+0x2e><== ALWAYS TAKEN
free (req);
10afa5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10afa8: 53 push %ebx <== NOT EXECUTED
10afa9: e8 c2 cd ff ff call 107d70 <free> <== NOT EXECUTED
10afae: e9 c6 01 00 00 jmp 10b179 <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);
10afb3: e8 a4 10 00 00 call 10c05c <pthread_self>
10afb8: 57 push %edi
10afb9: 8d 55 c4 lea -0x3c(%ebp),%edx
10afbc: 52 push %edx
10afbd: 8d 55 e0 lea -0x20(%ebp),%edx
10afc0: 52 push %edx
10afc1: 50 push %eax
10afc2: e8 9d 0c 00 00 call 10bc64 <pthread_getschedparam>
req->caller_thread = pthread_self ();
10afc7: e8 90 10 00 00 call 10c05c <pthread_self>
10afcc: 89 43 10 mov %eax,0x10(%ebx)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
10afcf: 8b 43 14 mov 0x14(%ebx),%eax
10afd2: 8b 55 c4 mov -0x3c(%ebp),%edx
10afd5: 2b 50 14 sub 0x14(%eax),%edx
10afd8: 89 53 0c mov %edx,0xc(%ebx)
req->policy = policy;
10afdb: 8b 55 e0 mov -0x20(%ebp),%edx
10afde: 89 53 08 mov %edx,0x8(%ebx)
req->aiocbp->error_code = EINPROGRESS;
10afe1: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax)
req->aiocbp->return_value = 0;
10afe8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
if ((aio_request_queue.idle_threads == 0) &&
10afef: 83 c4 10 add $0x10,%esp
10aff2: 83 3d 40 73 12 00 00 cmpl $0x0,0x127340
10aff9: 0f 85 b7 00 00 00 jne 10b0b6 <rtems_aio_enqueue+0x131><== NEVER TAKEN
10afff: 83 3d 3c 73 12 00 04 cmpl $0x4,0x12733c
10b006: 0f 8f aa 00 00 00 jg 10b0b6 <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);
10b00c: 56 push %esi
10b00d: 6a 01 push $0x1
10b00f: ff 30 pushl (%eax)
10b011: 68 20 73 12 00 push $0x127320
10b016: e8 81 fb ff ff call 10ab9c <rtems_aio_search_fd>
10b01b: 89 c6 mov %eax,%esi
if (r_chain->new_fd == 1) {
10b01d: 83 c4 10 add $0x10,%esp
10b020: 83 78 18 01 cmpl $0x1,0x18(%eax)
10b024: 8d 50 08 lea 0x8(%eax),%edx
10b027: 8d 78 1c lea 0x1c(%eax),%edi
10b02a: 8d 40 20 lea 0x20(%eax),%eax
10b02d: 89 45 b0 mov %eax,-0x50(%ebp)
10b030: 75 66 jne 10b098 <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);
10b032: 51 push %ecx
10b033: 51 push %ecx
10b034: 53 push %ebx
10b035: 52 push %edx
10b036: e8 c1 1f 00 00 call 10cffc <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
10b03b: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
pthread_mutex_init (&r_chain->mutex, NULL);
10b042: 5b pop %ebx
10b043: 58 pop %eax
10b044: 6a 00 push $0x0
10b046: 57 push %edi
10b047: e8 f4 06 00 00 call 10b740 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10b04c: 5a pop %edx
10b04d: 59 pop %ecx
10b04e: 6a 00 push $0x0
10b050: ff 75 b0 pushl -0x50(%ebp)
10b053: e8 a8 03 00 00 call 10b400 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
10b058: 56 push %esi
10b059: 68 78 ac 10 00 push $0x10ac78
10b05e: 68 e0 72 12 00 push $0x1272e0
10b063: 8d 45 e4 lea -0x1c(%ebp),%eax
10b066: 50 push %eax
10b067: e8 c4 09 00 00 call 10ba30 <pthread_create>
10b06c: 89 c3 mov %eax,%ebx
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
10b06e: 83 c4 20 add $0x20,%esp
10b071: 85 c0 test %eax,%eax
10b073: 74 18 je 10b08d <rtems_aio_enqueue+0x108><== ALWAYS TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
10b075: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b078: 68 d8 72 12 00 push $0x1272d8 <== NOT EXECUTED
10b07d: e8 5e 08 00 00 call 10b8e0 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10b082: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b085: 89 5d b4 mov %ebx,-0x4c(%ebp) <== NOT EXECUTED
10b088: e9 ef 00 00 00 jmp 10b17c <rtems_aio_enqueue+0x1f7><== NOT EXECUTED
}
++aio_request_queue.active_threads;
10b08d: ff 05 3c 73 12 00 incl 0x12733c
10b093: e9 d4 00 00 00 jmp 10b16c <rtems_aio_enqueue+0x1e7>
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
10b098: 83 ec 0c sub $0xc,%esp
10b09b: 57 push %edi
10b09c: 89 55 ac mov %edx,-0x54(%ebp)
10b09f: e8 bc 07 00 00 call 10b860 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10b0a4: 5e pop %esi
10b0a5: 58 pop %eax
10b0a6: 53 push %ebx
10b0a7: 8b 55 ac mov -0x54(%ebp),%edx
10b0aa: 52 push %edx
10b0ab: e8 ec fd ff ff call 10ae9c <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10b0b0: 5b pop %ebx
10b0b1: ff 75 b0 pushl -0x50(%ebp)
10b0b4: eb 36 jmp 10b0ec <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,
10b0b6: 51 push %ecx
10b0b7: 6a 00 push $0x0
10b0b9: ff 30 pushl (%eax)
10b0bb: 68 20 73 12 00 push $0x127320
10b0c0: e8 d7 fa ff ff call 10ab9c <rtems_aio_search_fd>
10b0c5: 89 c6 mov %eax,%esi
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
10b0c7: 83 c4 10 add $0x10,%esp
10b0ca: 85 c0 test %eax,%eax
10b0cc: 74 2d je 10b0fb <rtems_aio_enqueue+0x176>
{
pthread_mutex_lock (&r_chain->mutex);
10b0ce: 8d 78 1c lea 0x1c(%eax),%edi
10b0d1: 83 ec 0c sub $0xc,%esp
10b0d4: 57 push %edi
10b0d5: e8 86 07 00 00 call 10b860 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10b0da: 58 pop %eax
10b0db: 5a pop %edx
10b0dc: 53 push %ebx
10b0dd: 8d 46 08 lea 0x8(%esi),%eax
10b0e0: 50 push %eax
10b0e1: e8 b6 fd ff ff call 10ae9c <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10b0e6: 83 c6 20 add $0x20,%esi
10b0e9: 89 34 24 mov %esi,(%esp)
10b0ec: e8 ab 03 00 00 call 10b49c <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
10b0f1: 89 3c 24 mov %edi,(%esp)
10b0f4: e8 e7 07 00 00 call 10b8e0 <pthread_mutex_unlock>
10b0f9: eb 6e jmp 10b169 <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);
10b0fb: 56 push %esi
10b0fc: 6a 01 push $0x1
10b0fe: 8b 43 14 mov 0x14(%ebx),%eax
10b101: ff 30 pushl (%eax)
10b103: 68 2c 73 12 00 push $0x12732c
10b108: e8 8f fa ff ff call 10ab9c <rtems_aio_search_fd>
10b10d: 89 c6 mov %eax,%esi
if (r_chain->new_fd == 1) {
10b10f: 83 c4 10 add $0x10,%esp
10b112: 83 78 18 01 cmpl $0x1,0x18(%eax)
10b116: 8d 40 08 lea 0x8(%eax),%eax
10b119: 75 2c jne 10b147 <rtems_aio_enqueue+0x1c2>
10b11b: 51 push %ecx
10b11c: 51 push %ecx
10b11d: 53 push %ebx
10b11e: 50 push %eax
10b11f: e8 d8 1e 00 00 call 10cffc <_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;
10b124: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
pthread_mutex_init (&r_chain->mutex, NULL);
10b12b: 58 pop %eax
10b12c: 5a pop %edx
10b12d: 6a 00 push $0x0
10b12f: 8d 46 1c lea 0x1c(%esi),%eax
10b132: 50 push %eax
10b133: e8 08 06 00 00 call 10b740 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10b138: 5b pop %ebx
10b139: 5f pop %edi
10b13a: 6a 00 push $0x0
10b13c: 83 c6 20 add $0x20,%esi
10b13f: 56 push %esi
10b140: e8 bb 02 00 00 call 10b400 <pthread_cond_init>
10b145: eb 09 jmp 10b150 <rtems_aio_enqueue+0x1cb>
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
10b147: 51 push %ecx
10b148: 51 push %ecx
10b149: 53 push %ebx
10b14a: 50 push %eax
10b14b: e8 4c fd ff ff call 10ae9c <rtems_aio_insert_prio>
10b150: 83 c4 10 add $0x10,%esp
if (aio_request_queue.idle_threads > 0)
10b153: 83 3d 40 73 12 00 00 cmpl $0x0,0x127340
10b15a: 7e 10 jle 10b16c <rtems_aio_enqueue+0x1e7><== ALWAYS TAKEN
pthread_cond_signal (&aio_request_queue.new_req);
10b15c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b15f: 68 dc 72 12 00 push $0x1272dc <== NOT EXECUTED
10b164: e8 33 03 00 00 call 10b49c <pthread_cond_signal> <== NOT EXECUTED
10b169: 83 c4 10 add $0x10,%esp
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
10b16c: 83 ec 0c sub $0xc,%esp
10b16f: 68 d8 72 12 00 push $0x1272d8
10b174: e8 67 07 00 00 call 10b8e0 <pthread_mutex_unlock>
return 0;
10b179: 83 c4 10 add $0x10,%esp
}
10b17c: 8b 45 b4 mov -0x4c(%ebp),%eax
10b17f: 8d 65 f4 lea -0xc(%ebp),%esp
10b182: 5b pop %ebx
10b183: 5e pop %esi
10b184: 5f pop %edi
10b185: c9 leave
10b186: c3 ret
0010ac78 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
10ac78: 55 push %ebp
10ac79: 89 e5 mov %esp,%ebp
10ac7b: 57 push %edi
10ac7c: 56 push %esi
10ac7d: 53 push %ebx
10ac7e: 83 ec 4c sub $0x4c,%esp
rtems_aio_request_chain *r_chain = arg;
10ac81: 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);
10ac84: 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);
10ac87: 8d 43 1c lea 0x1c(%ebx),%eax
10ac8a: 89 45 b4 mov %eax,-0x4c(%ebp)
10ac8d: 83 ec 0c sub $0xc,%esp
10ac90: 50 push %eax
10ac91: e8 ca 0b 00 00 call 10b860 <pthread_mutex_lock>
if (result != 0)
10ac96: 83 c4 10 add $0x10,%esp
10ac99: 85 c0 test %eax,%eax
10ac9b: 0f 85 f1 01 00 00 jne 10ae92 <rtems_aio_handle+0x21a><== NEVER TAKEN
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aca1: 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 );
10aca4: 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)) {
10aca7: 39 c6 cmp %eax,%esi
10aca9: 0f 84 cd 00 00 00 je 10ad7c <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);
10acaf: e8 a8 13 00 00 call 10c05c <pthread_self>
10acb4: 52 push %edx
10acb5: 8d 55 c0 lea -0x40(%ebp),%edx
10acb8: 52 push %edx
10acb9: 8d 4d e4 lea -0x1c(%ebp),%ecx
10acbc: 51 push %ecx
10acbd: 50 push %eax
10acbe: e8 a1 0f 00 00 call 10bc64 <pthread_getschedparam>
param.sched_priority = req->priority;
10acc3: 8b 46 0c mov 0xc(%esi),%eax
10acc6: 89 45 c0 mov %eax,-0x40(%ebp)
pthread_setschedparam (pthread_self(), req->policy, ¶m);
10acc9: 8b 56 08 mov 0x8(%esi),%edx
10accc: 89 55 b0 mov %edx,-0x50(%ebp)
10accf: e8 88 13 00 00 call 10c05c <pthread_self>
10acd4: 83 c4 0c add $0xc,%esp
10acd7: 8d 4d c0 lea -0x40(%ebp),%ecx
10acda: 51 push %ecx
10acdb: 8b 55 b0 mov -0x50(%ebp),%edx
10acde: 52 push %edx
10acdf: 50 push %eax
10ace0: e8 87 13 00 00 call 10c06c <pthread_setschedparam>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10ace5: 89 34 24 mov %esi,(%esp)
10ace8: e8 d3 22 00 00 call 10cfc0 <_Chain_Extract>
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
10aced: 59 pop %ecx
10acee: ff 75 b4 pushl -0x4c(%ebp)
10acf1: e8 ea 0b 00 00 call 10b8e0 <pthread_mutex_unlock>
switch (req->aiocbp->aio_lio_opcode) {
10acf6: 8b 46 14 mov 0x14(%esi),%eax
10acf9: 83 c4 10 add $0x10,%esp
10acfc: 8b 50 2c mov 0x2c(%eax),%edx
10acff: 83 fa 02 cmp $0x2,%edx
10ad02: 74 20 je 10ad24 <rtems_aio_handle+0xac>
10ad04: 83 fa 03 cmp $0x3,%edx
10ad07: 74 36 je 10ad3f <rtems_aio_handle+0xc7> <== NEVER TAKEN
10ad09: 4a dec %edx
10ad0a: 75 45 jne 10ad51 <rtems_aio_handle+0xd9> <== NEVER TAKEN
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
10ad0c: 83 ec 0c sub $0xc,%esp
10ad0f: ff 70 08 pushl 0x8(%eax)
10ad12: ff 70 04 pushl 0x4(%eax)
10ad15: ff 70 10 pushl 0x10(%eax)
10ad18: ff 70 0c pushl 0xc(%eax)
10ad1b: ff 30 pushl (%eax)
10ad1d: e8 fe 93 00 00 call 114120 <pread>
10ad22: eb 16 jmp 10ad3a <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,
10ad24: 83 ec 0c sub $0xc,%esp
10ad27: ff 70 08 pushl 0x8(%eax)
10ad2a: ff 70 04 pushl 0x4(%eax)
10ad2d: ff 70 10 pushl 0x10(%eax)
10ad30: ff 70 0c pushl 0xc(%eax)
10ad33: ff 30 pushl (%eax)
10ad35: e8 9a 94 00 00 call 1141d4 <pwrite>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10ad3a: 83 c4 20 add $0x20,%esp
10ad3d: eb 0d jmp 10ad4c <rtems_aio_handle+0xd4>
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
10ad3f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ad42: ff 30 pushl (%eax) <== NOT EXECUTED
10ad44: e8 33 5d 00 00 call 110a7c <fsync> <== NOT EXECUTED
break;
10ad49: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
10ad4c: 83 f8 ff cmp $0xffffffff,%eax
10ad4f: 75 19 jne 10ad6a <rtems_aio_handle+0xf2> <== ALWAYS TAKEN
req->aiocbp->return_value = -1;
10ad51: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED
10ad54: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED
req->aiocbp->error_code = errno;
10ad5b: e8 88 89 00 00 call 1136e8 <__errno> <== NOT EXECUTED
10ad60: 8b 00 mov (%eax),%eax <== NOT EXECUTED
10ad62: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED
10ad65: e9 1d ff ff ff jmp 10ac87 <rtems_aio_handle+0xf> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
10ad6a: 8b 56 14 mov 0x14(%esi),%edx
10ad6d: 89 42 34 mov %eax,0x34(%edx)
req->aiocbp->error_code = 0;
10ad70: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx)
10ad77: e9 0b ff ff ff jmp 10ac87 <rtems_aio_handle+0xf>
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
10ad7c: 83 ec 0c sub $0xc,%esp
10ad7f: ff 75 b4 pushl -0x4c(%ebp)
10ad82: e8 59 0b 00 00 call 10b8e0 <pthread_mutex_unlock>
pthread_mutex_lock (&aio_request_queue.mutex);
10ad87: c7 04 24 d8 72 12 00 movl $0x1272d8,(%esp)
10ad8e: e8 cd 0a 00 00 call 10b860 <pthread_mutex_lock>
if (rtems_chain_is_empty (chain))
10ad93: 83 c4 10 add $0x10,%esp
10ad96: 39 73 08 cmp %esi,0x8(%ebx)
10ad99: 0f 85 de 00 00 00 jne 10ae7d <rtems_aio_handle+0x205><== NEVER TAKEN
{
clock_gettime (CLOCK_REALTIME, &timeout);
10ad9f: 52 push %edx
10ada0: 52 push %edx
10ada1: 57 push %edi
10ada2: 6a 01 push $0x1
10ada4: e8 47 05 00 00 call 10b2f0 <clock_gettime>
timeout.tv_sec += 3;
10ada9: 83 45 dc 03 addl $0x3,-0x24(%ebp)
timeout.tv_nsec = 0;
10adad: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
result = pthread_cond_timedwait (&r_chain->cond,
10adb4: 8d 73 20 lea 0x20(%ebx),%esi
10adb7: 83 c4 0c add $0xc,%esp
10adba: 57 push %edi
10adbb: 68 d8 72 12 00 push $0x1272d8
10adc0: 56 push %esi
10adc1: e8 46 07 00 00 call 10b50c <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) {
10adc6: 83 c4 10 add $0x10,%esp
10adc9: 83 f8 74 cmp $0x74,%eax
10adcc: 0f 85 ab 00 00 00 jne 10ae7d <rtems_aio_handle+0x205><== NEVER TAKEN
10add2: 83 ec 0c sub $0xc,%esp
10add5: 53 push %ebx
10add6: e8 e5 21 00 00 call 10cfc0 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
10addb: 58 pop %eax
10addc: ff 75 b4 pushl -0x4c(%ebp)
10addf: e8 5c 08 00 00 call 10b640 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
10ade4: 89 34 24 mov %esi,(%esp)
10ade7: e8 60 05 00 00 call 10b34c <pthread_cond_destroy>
free (r_chain);
10adec: 89 1c 24 mov %ebx,(%esp)
10adef: e8 7c cf ff ff call 107d70 <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)) {
10adf4: 83 c4 10 add $0x10,%esp
10adf7: 81 3d 2c 73 12 00 30 cmpl $0x127330,0x12732c
10adfe: 73 12 00
10ae01: 75 54 jne 10ae57 <rtems_aio_handle+0x1df>
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
10ae03: ff 05 40 73 12 00 incl 0x127340
--aio_request_queue.active_threads;
10ae09: ff 0d 3c 73 12 00 decl 0x12733c
clock_gettime (CLOCK_REALTIME, &timeout);
10ae0f: 53 push %ebx
10ae10: 53 push %ebx
10ae11: 57 push %edi
10ae12: 6a 01 push $0x1
10ae14: e8 d7 04 00 00 call 10b2f0 <clock_gettime>
timeout.tv_sec += 3;
10ae19: 83 45 dc 03 addl $0x3,-0x24(%ebp)
timeout.tv_nsec = 0;
10ae1d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
result = pthread_cond_timedwait (&aio_request_queue.new_req,
10ae24: 83 c4 0c add $0xc,%esp
10ae27: 57 push %edi
10ae28: 68 d8 72 12 00 push $0x1272d8
10ae2d: 68 dc 72 12 00 push $0x1272dc
10ae32: e8 d5 06 00 00 call 10b50c <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) {
10ae37: 83 c4 10 add $0x10,%esp
10ae3a: 83 f8 74 cmp $0x74,%eax
10ae3d: 75 18 jne 10ae57 <rtems_aio_handle+0x1df><== NEVER TAKEN
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
10ae3f: ff 0d 40 73 12 00 decl 0x127340
pthread_mutex_unlock (&aio_request_queue.mutex);
10ae45: 83 ec 0c sub $0xc,%esp
10ae48: 68 d8 72 12 00 push $0x1272d8
10ae4d: e8 8e 0a 00 00 call 10b8e0 <pthread_mutex_unlock>
return NULL;
10ae52: 83 c4 10 add $0x10,%esp
10ae55: eb 3b jmp 10ae92 <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;
10ae57: ff 0d 40 73 12 00 decl 0x127340
++aio_request_queue.active_threads;
10ae5d: ff 05 3c 73 12 00 incl 0x12733c
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae63: 8b 1d 2c 73 12 00 mov 0x12732c,%ebx
10ae69: 83 ec 0c sub $0xc,%esp
10ae6c: 53 push %ebx
10ae6d: e8 4e 21 00 00 call 10cfc0 <_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);
10ae72: 89 1c 24 mov %ebx,(%esp)
10ae75: e8 cd fd ff ff call 10ac47 <rtems_aio_move_to_work>
10ae7a: 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);
10ae7d: 83 ec 0c sub $0xc,%esp
10ae80: 68 d8 72 12 00 push $0x1272d8
10ae85: e8 56 0a 00 00 call 10b8e0 <pthread_mutex_unlock>
10ae8a: 83 c4 10 add $0x10,%esp
10ae8d: e9 f5 fd ff ff jmp 10ac87 <rtems_aio_handle+0xf>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae92: 31 c0 xor %eax,%eax
10ae94: 8d 65 f4 lea -0xc(%ebp),%esp
10ae97: 5b pop %ebx
10ae98: 5e pop %esi
10ae99: 5f pop %edi
10ae9a: c9 leave
10ae9b: c3 ret
0010aaa0 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
10aaa0: 55 push %ebp
10aaa1: 89 e5 mov %esp,%ebp
10aaa3: 53 push %ebx
10aaa4: 83 ec 10 sub $0x10,%esp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
10aaa7: 68 e0 72 12 00 push $0x1272e0
10aaac: e8 33 0f 00 00 call 10b9e4 <pthread_attr_init>
10aab1: 89 c3 mov %eax,%ebx
if (result != 0)
10aab3: 83 c4 10 add $0x10,%esp
10aab6: 85 c0 test %eax,%eax
10aab8: 0f 85 d7 00 00 00 jne 10ab95 <rtems_aio_init+0xf5> <== NEVER TAKEN
return result;
result =
10aabe: 51 push %ecx
10aabf: 51 push %ecx
10aac0: 6a 00 push $0x0
10aac2: 68 e0 72 12 00 push $0x1272e0
10aac7: e8 40 0f 00 00 call 10ba0c <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
10aacc: 83 c4 10 add $0x10,%esp
10aacf: 85 c0 test %eax,%eax
10aad1: 74 10 je 10aae3 <rtems_aio_init+0x43> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
10aad3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aad6: 68 e0 72 12 00 push $0x1272e0 <== NOT EXECUTED
10aadb: e8 e4 0e 00 00 call 10b9c4 <pthread_attr_destroy> <== NOT EXECUTED
10aae0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
10aae3: 52 push %edx
10aae4: 52 push %edx
10aae5: 6a 00 push $0x0
10aae7: 68 d8 72 12 00 push $0x1272d8
10aaec: e8 4f 0c 00 00 call 10b740 <pthread_mutex_init>
if (result != 0)
10aaf1: 83 c4 10 add $0x10,%esp
10aaf4: 85 c0 test %eax,%eax
10aaf6: 74 10 je 10ab08 <rtems_aio_init+0x68> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
10aaf8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aafb: 68 e0 72 12 00 push $0x1272e0 <== NOT EXECUTED
10ab00: e8 bf 0e 00 00 call 10b9c4 <pthread_attr_destroy> <== NOT EXECUTED
10ab05: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
10ab08: 50 push %eax
10ab09: 50 push %eax
10ab0a: 6a 00 push $0x0
10ab0c: 68 dc 72 12 00 push $0x1272dc
10ab11: e8 ea 08 00 00 call 10b400 <pthread_cond_init>
10ab16: 89 c3 mov %eax,%ebx
if (result != 0) {
10ab18: 83 c4 10 add $0x10,%esp
10ab1b: 85 c0 test %eax,%eax
10ab1d: 74 1c je 10ab3b <rtems_aio_init+0x9b> <== ALWAYS TAKEN
pthread_mutex_destroy (&aio_request_queue.mutex);
10ab1f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ab22: 68 d8 72 12 00 push $0x1272d8 <== NOT EXECUTED
10ab27: e8 14 0b 00 00 call 10b640 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
10ab2c: c7 04 24 e0 72 12 00 movl $0x1272e0,(%esp) <== NOT EXECUTED
10ab33: e8 8c 0e 00 00 call 10b9c4 <pthread_attr_destroy> <== NOT EXECUTED
10ab38: 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;
10ab3b: c7 05 20 73 12 00 24 movl $0x127324,0x127320
10ab42: 73 12 00
head->previous = NULL;
10ab45: c7 05 24 73 12 00 00 movl $0x0,0x127324
10ab4c: 00 00 00
tail->previous = head;
10ab4f: c7 05 28 73 12 00 20 movl $0x127320,0x127328
10ab56: 73 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10ab59: c7 05 2c 73 12 00 30 movl $0x127330,0x12732c
10ab60: 73 12 00
head->previous = NULL;
10ab63: c7 05 30 73 12 00 00 movl $0x0,0x127330
10ab6a: 00 00 00
tail->previous = head;
10ab6d: c7 05 34 73 12 00 2c movl $0x12732c,0x127334
10ab74: 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;
10ab77: c7 05 3c 73 12 00 00 movl $0x0,0x12733c
10ab7e: 00 00 00
aio_request_queue.idle_threads = 0;
10ab81: c7 05 40 73 12 00 00 movl $0x0,0x127340
10ab88: 00 00 00
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
10ab8b: c7 05 38 73 12 00 0b movl $0xb00b,0x127338
10ab92: b0 00 00
return result;
}
10ab95: 89 d8 mov %ebx,%eax
10ab97: 8b 5d fc mov -0x4(%ebp),%ebx
10ab9a: c9 leave
10ab9b: c3 ret
0010ae9c <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
10ae9c: 55 push %ebp
10ae9d: 89 e5 mov %esp,%ebp
10ae9f: 56 push %esi
10aea0: 53 push %ebx
10aea1: 8b 4d 08 mov 0x8(%ebp),%ecx
10aea4: 8b 55 0c mov 0xc(%ebp),%edx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aea7: 8b 01 mov (%ecx),%eax
10aea9: 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)) {
10aeac: 39 d8 cmp %ebx,%eax
10aeae: 74 27 je 10aed7 <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;
10aeb0: 8b 48 14 mov 0x14(%eax),%ecx
10aeb3: 8b 49 14 mov 0x14(%ecx),%ecx
while (req->aiocbp->aio_reqprio > prio &&
10aeb6: 8b 72 14 mov 0x14(%edx),%esi
10aeb9: 8b 76 14 mov 0x14(%esi),%esi
10aebc: eb 08 jmp 10aec6 <rtems_aio_insert_prio+0x2a>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aebe: 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;
10aec0: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED
10aec3: 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 &&
10aec6: 39 ce cmp %ecx,%esi
10aec8: 7e 04 jle 10aece <rtems_aio_insert_prio+0x32><== ALWAYS TAKEN
10aeca: 39 d8 cmp %ebx,%eax <== NOT EXECUTED
10aecc: 75 f0 jne 10aebe <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 );
10aece: 89 55 0c mov %edx,0xc(%ebp)
10aed1: 8b 40 04 mov 0x4(%eax),%eax
10aed4: 89 45 08 mov %eax,0x8(%ebp)
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
10aed7: 5b pop %ebx
10aed8: 5e pop %esi
10aed9: c9 leave
10aeda: e9 1d 21 00 00 jmp 10cffc <_Chain_Insert>
0010ac47 <rtems_aio_move_to_work>:
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
10ac47: 55 push %ebp
10ac48: 89 e5 mov %esp,%ebp
10ac4a: 83 ec 08 sub $0x8,%esp
10ac4d: 8b 55 08 mov 0x8(%ebp),%edx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ac50: 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 &&
10ac55: 8b 4a 14 mov 0x14(%edx),%ecx
10ac58: eb 02 jmp 10ac5c <rtems_aio_move_to_work+0x15>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ac5a: 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 &&
10ac5c: 39 48 14 cmp %ecx,0x14(%eax)
10ac5f: 7d 07 jge 10ac68 <rtems_aio_move_to_work+0x21>
10ac61: 3d 24 73 12 00 cmp $0x127324,%eax
10ac66: 75 f2 jne 10ac5a <rtems_aio_move_to_work+0x13><== ALWAYS TAKEN
10ac68: 51 push %ecx
10ac69: 51 push %ecx
10ac6a: 52 push %edx
10ac6b: ff 70 04 pushl 0x4(%eax)
10ac6e: e8 89 23 00 00 call 10cffc <_Chain_Insert>
10ac73: 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);
}
10ac76: c9 leave
10ac77: c3 ret
0010af28 <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)
{
10af28: 55 push %ebp
10af29: 89 e5 mov %esp,%ebp
10af2b: 53 push %ebx
10af2c: 83 ec 04 sub $0x4,%esp
10af2f: 8b 55 08 mov 0x8(%ebp),%edx
10af32: 8b 4d 0c mov 0xc(%ebp),%ecx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10af35: 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 );
10af37: 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;
10af3a: 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))
10af3f: 39 d3 cmp %edx,%ebx
10af41: 75 08 jne 10af4b <rtems_aio_remove_req+0x23>
10af43: eb 3b jmp 10af80 <rtems_aio_remove_req+0x58>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10af45: 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) {
10af47: 39 d3 cmp %edx,%ebx <== NOT EXECUTED
10af49: 74 30 je 10af7b <rtems_aio_remove_req+0x53><== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
10af4b: 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) {
10af4d: 39 4b 14 cmp %ecx,0x14(%ebx)
10af50: 75 f3 jne 10af45 <rtems_aio_remove_req+0x1d><== NEVER TAKEN
10af52: 83 ec 0c sub $0xc,%esp
10af55: 53 push %ebx
10af56: e8 65 20 00 00 call 10cfc0 <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
10af5b: 8b 43 14 mov 0x14(%ebx),%eax
10af5e: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax)
current->aiocbp->return_value = -1;
10af65: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax)
free (current);
10af6c: 89 1c 24 mov %ebx,(%esp)
10af6f: e8 fc cd ff ff call 107d70 <free>
}
return AIO_CANCELED;
10af74: 83 c4 10 add $0x10,%esp
10af77: 31 c0 xor %eax,%eax
10af79: eb 05 jmp 10af80 <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;
10af7b: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10af80: 8b 5d fc mov -0x4(%ebp),%ebx
10af83: c9 leave
10af84: c3 ret
0010acc8 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
10acc8: 55 push %ebp
10acc9: 89 e5 mov %esp,%ebp
10accb: 57 push %edi
10accc: 56 push %esi
10accd: 53 push %ebx
10acce: 83 ec 1c sub $0x1c,%esp
10acd1: 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(
10acd4: 8d 75 e4 lea -0x1c(%ebp),%esi
10acd7: eb 13 jmp 10acec <rtems_chain_get_with_wait+0x24>
10acd9: 56 push %esi
10acda: ff 75 10 pushl 0x10(%ebp)
10acdd: 6a 00 push $0x0
10acdf: 57 push %edi
10ace0: e8 0f f5 ff ff call 10a1f4 <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
10ace5: 83 c4 10 add $0x10,%esp
10ace8: 85 c0 test %eax,%eax
10acea: 75 16 jne 10ad02 <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 );
10acec: 83 ec 0c sub $0xc,%esp
10acef: ff 75 08 pushl 0x8(%ebp)
10acf2: e8 a5 04 00 00 call 10b19c <_Chain_Get>
10acf7: 89 c3 mov %eax,%ebx
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10acf9: 83 c4 10 add $0x10,%esp
10acfc: 85 c0 test %eax,%eax
10acfe: 74 d9 je 10acd9 <rtems_chain_get_with_wait+0x11>
10ad00: 31 c0 xor %eax,%eax
timeout,
&out
);
}
*node_ptr = node;
10ad02: 8b 55 14 mov 0x14(%ebp),%edx
10ad05: 89 1a mov %ebx,(%edx)
return sc;
}
10ad07: 8d 65 f4 lea -0xc(%ebp),%esp
10ad0a: 5b pop %ebx
10ad0b: 5e pop %esi
10ad0c: 5f pop %edi
10ad0d: c9 leave
10ad0e: c3 ret
001076c8 <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
1076c8: 55 push %ebp
1076c9: 89 e5 mov %esp,%ebp
1076cb: 57 push %edi
1076cc: 56 push %esi
1076cd: 53 push %ebx
1076ce: 83 ec 6c sub $0x6c,%esp
Timestamp_Control uptime, total, ran, uptime_at_last_reset;
#else
uint32_t total_units = 0;
#endif
if ( !print )
1076d1: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
1076d5: 0f 84 74 01 00 00 je 10784f <rtems_cpu_usage_report_with_plugin+0x187><== 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__
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
1076db: a1 60 96 12 00 mov 0x129660,%eax
1076e0: 8b 15 64 96 12 00 mov 0x129664,%edx
1076e6: 89 45 c0 mov %eax,-0x40(%ebp)
1076e9: 89 55 c4 mov %edx,-0x3c(%ebp)
}
}
}
#endif
(*print)(
1076ec: 53 push %ebx
1076ed: 53 push %ebx
1076ee: 68 a1 14 12 00 push $0x1214a1
1076f3: ff 75 08 pushl 0x8(%ebp)
1076f6: ff 55 0c call *0xc(%ebp)
1076f9: 83 c4 10 add $0x10,%esp
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
1076fc: bf 01 00 00 00 mov $0x1,%edi
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
107701: 8b 04 bd 9c 90 12 00 mov 0x12909c(,%edi,4),%eax
107708: 8b 70 04 mov 0x4(%eax),%esi
if ( information ) {
10770b: 85 f6 test %esi,%esi
10770d: 0f 84 14 01 00 00 je 107827 <rtems_cpu_usage_report_with_plugin+0x15f><== NEVER TAKEN
107713: c7 45 94 01 00 00 00 movl $0x1,-0x6c(%ebp)
10771a: e9 fb 00 00 00 jmp 10781a <rtems_cpu_usage_report_with_plugin+0x152>
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
10771f: 8b 46 1c mov 0x1c(%esi),%eax
107722: 8b 4d 94 mov -0x6c(%ebp),%ecx
107725: 8b 14 88 mov (%eax,%ecx,4),%edx
if ( !the_thread )
107728: 85 d2 test %edx,%edx
10772a: 0f 84 e7 00 00 00 je 107817 <rtems_cpu_usage_report_with_plugin+0x14f><== NEVER TAKEN
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
107730: 51 push %ecx
107731: 8d 5d a3 lea -0x5d(%ebp),%ebx
107734: 53 push %ebx
107735: 6a 0d push $0xd
107737: ff 72 08 pushl 0x8(%edx)
10773a: 89 55 90 mov %edx,-0x70(%ebp)
10773d: e8 fa 39 00 00 call 10b13c <rtems_object_get_name>
(*print)(
107742: 53 push %ebx
107743: 8b 55 90 mov -0x70(%ebp),%edx
107746: ff 72 08 pushl 0x8(%edx)
107749: 68 13 16 12 00 push $0x121613
10774e: ff 75 08 pushl 0x8(%ebp)
107751: 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;
107754: 8b 55 90 mov -0x70(%ebp),%edx
107757: 8b 8a 84 00 00 00 mov 0x84(%edx),%ecx
10775d: 8b 9a 88 00 00 00 mov 0x88(%edx),%ebx
107763: 89 4d c8 mov %ecx,-0x38(%ebp)
107766: 89 5d cc mov %ebx,-0x34(%ebp)
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
107769: 83 c4 20 add $0x20,%esp
10776c: a1 2c 96 12 00 mov 0x12962c,%eax
107771: 8b 5a 08 mov 0x8(%edx),%ebx
107774: 39 58 08 cmp %ebx,0x8(%eax)
107777: 75 45 jne 1077be <rtems_cpu_usage_report_with_plugin+0xf6>
Timestamp_Control used;
Timestamp_Control last = _Thread_Time_of_last_context_switch;
107779: a1 74 91 12 00 mov 0x129174,%eax
10777e: 8b 15 78 91 12 00 mov 0x129178,%edx
107784: 89 45 b0 mov %eax,-0x50(%ebp)
107787: 89 55 b4 mov %edx,-0x4c(%ebp)
_TOD_Get_uptime( &uptime );
10778a: 83 ec 0c sub $0xc,%esp
10778d: 8d 45 d8 lea -0x28(%ebp),%eax
107790: 50 push %eax
107791: e8 1a 4b 00 00 call 10c2b0 <_TOD_Get_uptime>
_Timestamp_Subtract( &last, &uptime, &used );
107796: 83 c4 0c add $0xc,%esp
107799: 8d 45 b8 lea -0x48(%ebp),%eax
10779c: 50 push %eax
10779d: 8d 55 d8 lea -0x28(%ebp),%edx
1077a0: 52 push %edx
1077a1: 8d 55 b0 lea -0x50(%ebp),%edx
1077a4: 52 push %edx
1077a5: 89 45 90 mov %eax,-0x70(%ebp)
1077a8: e8 f7 6a 00 00 call 10e2a4 <_Timespec_Subtract>
_Timestamp_Add_to( &ran, &used );
1077ad: 58 pop %eax
1077ae: 5a pop %edx
1077af: 8b 45 90 mov -0x70(%ebp),%eax
1077b2: 50 push %eax
1077b3: 8d 45 c8 lea -0x38(%ebp),%eax
1077b6: 50 push %eax
1077b7: e8 fc 69 00 00 call 10e1b8 <_Timespec_Add_to>
1077bc: eb 0c jmp 1077ca <rtems_cpu_usage_report_with_plugin+0x102>
} else {
_TOD_Get_uptime( &uptime );
1077be: 83 ec 0c sub $0xc,%esp
1077c1: 8d 4d d8 lea -0x28(%ebp),%ecx
1077c4: 51 push %ecx
1077c5: e8 e6 4a 00 00 call 10c2b0 <_TOD_Get_uptime>
1077ca: 83 c4 0c add $0xc,%esp
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
1077cd: 8d 5d d0 lea -0x30(%ebp),%ebx
1077d0: 53 push %ebx
1077d1: 8d 45 d8 lea -0x28(%ebp),%eax
1077d4: 50 push %eax
1077d5: 8d 55 c0 lea -0x40(%ebp),%edx
1077d8: 52 push %edx
1077d9: e8 c6 6a 00 00 call 10e2a4 <_Timespec_Subtract>
_Timestamp_Divide( &ran, &total, &ival, &fval );
1077de: 8d 4d e0 lea -0x20(%ebp),%ecx
1077e1: 51 push %ecx
1077e2: 8d 45 e4 lea -0x1c(%ebp),%eax
1077e5: 50 push %eax
1077e6: 53 push %ebx
1077e7: 8d 45 c8 lea -0x38(%ebp),%eax
1077ea: 50 push %eax
1077eb: e8 f8 69 00 00 call 10e1e8 <_Timespec_Divide>
/*
* Print the information
*/
(*print)( context,
1077f0: 83 c4 18 add $0x18,%esp
1077f3: ff 75 e0 pushl -0x20(%ebp)
1077f6: ff 75 e4 pushl -0x1c(%ebp)
1077f9: 8b 45 cc mov -0x34(%ebp),%eax
1077fc: b9 e8 03 00 00 mov $0x3e8,%ecx
107801: 31 d2 xor %edx,%edx
107803: f7 f1 div %ecx
107805: 50 push %eax
107806: ff 75 c8 pushl -0x38(%ebp)
107809: 68 26 16 12 00 push $0x121626
10780e: ff 75 08 pushl 0x8(%ebp)
107811: ff 55 0c call *0xc(%ebp)
107814: 83 c4 20 add $0x20,%esp
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
107817: ff 45 94 incl -0x6c(%ebp)
10781a: 0f b7 46 10 movzwl 0x10(%esi),%eax
10781e: 39 45 94 cmp %eax,-0x6c(%ebp)
107821: 0f 86 f8 fe ff ff jbe 10771f <rtems_cpu_usage_report_with_plugin+0x57>
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
107827: 47 inc %edi
107828: 83 ff 04 cmp $0x4,%edi
10782b: 0f 85 d0 fe ff ff jne 107701 <rtems_cpu_usage_report_with_plugin+0x39>
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
107831: 8b 45 d4 mov -0x2c(%ebp),%eax
107834: b9 e8 03 00 00 mov $0x3e8,%ecx
107839: 31 d2 xor %edx,%edx
10783b: f7 f1 div %ecx
10783d: 50 push %eax
10783e: ff 75 d0 pushl -0x30(%ebp)
107841: 68 3e 16 12 00 push $0x12163e
107846: ff 75 08 pushl 0x8(%ebp)
107849: ff 55 0c call *0xc(%ebp)
10784c: 83 c4 10 add $0x10,%esp
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
10784f: 8d 65 f4 lea -0xc(%ebp),%esp
107852: 5b pop %ebx
107853: 5e pop %esi
107854: 5f pop %edi
107855: c9 leave
107856: c3 ret
001110b8 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
1110b8: 55 push %ebp
1110b9: 89 e5 mov %esp,%ebp
1110bb: 53 push %ebx
1110bc: 83 ec 04 sub $0x4,%esp
1110bf: 8b 55 08 mov 0x8(%ebp),%edx
if (sc == RTEMS_SUCCESSFUL) {
return 0;
1110c2: 31 c0 xor %eax,%eax
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
1110c4: 85 d2 test %edx,%edx
1110c6: 74 1b je 1110e3 <rtems_deviceio_errno+0x2b>
return 0;
} else {
int eno = EINVAL;
1110c8: bb 16 00 00 00 mov $0x16,%ebx
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
1110cd: 83 fa 1c cmp $0x1c,%edx
1110d0: 77 07 ja 1110d9 <rtems_deviceio_errno+0x21><== NEVER TAKEN
eno = status_code_to_errno [sc];
1110d2: 8b 1c 95 54 f7 11 00 mov 0x11f754(,%edx,4),%ebx
}
errno = eno;
1110d9: e8 5a 00 00 00 call 111138 <__errno>
1110de: 89 18 mov %ebx,(%eax)
return -1;
1110e0: 83 c8 ff or $0xffffffff,%eax
}
}
1110e3: 5a pop %edx
1110e4: 5b pop %ebx
1110e5: c9 leave
1110e6: c3 ret
0010e4a7 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
10e4a7: 55 push %ebp
10e4a8: 89 e5 mov %esp,%ebp
10e4aa: 83 ec 18 sub $0x18,%esp
10e4ad: 8b 45 08 mov 0x8(%ebp),%eax
find_arg fa = {
10e4b0: 89 45 f0 mov %eax,-0x10(%ebp)
10e4b3: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
10e4ba: 85 c0 test %eax,%eax
10e4bc: 74 13 je 10e4d1 <rtems_filesystem_get_mount_handler+0x2a><== NEVER TAKEN
rtems_filesystem_iterate( find_handler, &fa );
10e4be: 50 push %eax
10e4bf: 50 push %eax
10e4c0: 8d 45 f0 lea -0x10(%ebp),%eax
10e4c3: 50 push %eax
10e4c4: 68 d0 e3 10 00 push $0x10e3d0
10e4c9: e8 62 ff ff ff call 10e430 <rtems_filesystem_iterate>
10e4ce: 83 c4 10 add $0x10,%esp
}
return fa.mount_h;
}
10e4d1: 8b 45 f4 mov -0xc(%ebp),%eax
10e4d4: c9 leave
10e4d5: c3 ret
0010712c <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 )
{
10712c: 55 push %ebp
10712d: 89 e5 mov %esp,%ebp
10712f: 57 push %edi
107130: 56 push %esi
107131: 53 push %ebx
107132: 83 ec 2c sub $0x2c,%esp
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
107135: a1 80 30 12 00 mov 0x123080,%eax
10713a: c7 40 2c 12 00 00 00 movl $0x12,0x2c(%eax)
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
107141: 83 3d e0 d7 11 00 00 cmpl $0x0,0x11d7e0
107148: 75 0a jne 107154 <rtems_filesystem_initialize+0x28><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0001 );
10714a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10714d: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED
107152: eb 28 jmp 10717c <rtems_filesystem_initialize+0x50><== NOT EXECUTED
mt = &rtems_filesystem_mount_table[0];
107154: a1 4c 11 12 00 mov 0x12114c,%eax
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
107159: 83 ec 0c sub $0xc,%esp
10715c: 6a 00 push $0x0
10715e: ff 70 04 pushl 0x4(%eax)
107161: ff 30 pushl (%eax)
107163: ff 70 0c pushl 0xc(%eax)
107166: ff 70 08 pushl 0x8(%eax)
107169: e8 9b 06 00 00 call 107809 <mount>
if ( status == -1 )
10716e: 83 c4 20 add $0x20,%esp
107171: 40 inc %eax
107172: 75 0d jne 107181 <rtems_filesystem_initialize+0x55><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0002 );
107174: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107177: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED
10717c: e8 07 36 00 00 call 10a788 <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_filesystem_link_counts = 0;
107181: a1 80 30 12 00 mov 0x123080,%eax
107186: 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);
10718c: 83 ec 0c sub $0xc,%esp
10718f: 6a 00 push $0x0
107191: 8d 5d d4 lea -0x2c(%ebp),%ebx
107194: 53 push %ebx
107195: 6a 00 push $0x0
107197: 6a 01 push $0x1
107199: 68 80 ef 11 00 push $0x11ef80
10719e: e8 03 01 00 00 call 1072a6 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
1071a3: 8b 3d 80 30 12 00 mov 0x123080,%edi
1071a9: 83 c7 18 add $0x18,%edi
1071ac: b9 05 00 00 00 mov $0x5,%ecx
1071b1: 89 de mov %ebx,%esi
1071b3: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
1071b5: 83 c4 14 add $0x14,%esp
1071b8: 6a 00 push $0x0
1071ba: 53 push %ebx
1071bb: 6a 00 push $0x0
1071bd: 6a 01 push $0x1
1071bf: 68 80 ef 11 00 push $0x11ef80
1071c4: e8 dd 00 00 00 call 1072a6 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
1071c9: 8b 3d 80 30 12 00 mov 0x123080,%edi
1071cf: 83 c7 04 add $0x4,%edi
1071d2: b9 05 00 00 00 mov $0x5,%ecx
1071d7: 89 de mov %ebx,%esi
1071d9: 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);
1071db: 83 c4 18 add $0x18,%esp
1071de: 68 ff 01 00 00 push $0x1ff
1071e3: 68 82 ef 11 00 push $0x11ef82
1071e8: e8 c3 04 00 00 call 1076b0 <mkdir>
if ( status != 0 )
1071ed: 83 c4 10 add $0x10,%esp
1071f0: 85 c0 test %eax,%eax
1071f2: 74 0d je 107201 <rtems_filesystem_initialize+0xd5><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0003 );
1071f4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1071f7: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED
1071fc: e9 7b ff ff ff jmp 10717c <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.
*/
}
107201: 8d 65 f4 lea -0xc(%ebp),%esp
107204: 5b pop %ebx
107205: 5e pop %esi
107206: 5f pop %edi
107207: c9 leave
107208: c3 ret
0010e430 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
10e430: 55 push %ebp
10e431: 89 e5 mov %esp,%ebp
10e433: 57 push %edi
10e434: 56 push %esi
10e435: 53 push %ebx
10e436: 83 ec 1c sub $0x1c,%esp
10e439: 8b 75 08 mov 0x8(%ebp),%esi
10e43c: 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;
10e43f: 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];
10e441: bb c0 d7 11 00 mov $0x11d7c0,%ebx
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
10e446: eb 0c jmp 10e454 <rtems_filesystem_iterate+0x24>
stop = (*routine)( table_entry, routine_arg );
10e448: 51 push %ecx
10e449: 51 push %ecx
10e44a: 57 push %edi
10e44b: 53 push %ebx
10e44c: ff d6 call *%esi
++table_entry;
10e44e: 83 c3 08 add $0x8,%ebx
10e451: 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 ) {
10e454: 83 3b 00 cmpl $0x0,(%ebx)
10e457: 74 06 je 10e45f <rtems_filesystem_iterate+0x2f>
10e459: 84 c0 test %al,%al
10e45b: 74 eb je 10e448 <rtems_filesystem_iterate+0x18>
10e45d: eb 40 jmp 10e49f <rtems_filesystem_iterate+0x6f>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
10e45f: 84 c0 test %al,%al
10e461: 75 3c jne 10e49f <rtems_filesystem_iterate+0x6f>
rtems_libio_lock();
10e463: 88 45 e4 mov %al,-0x1c(%ebp)
10e466: e8 95 ff ff ff call 10e400 <rtems_libio_lock>
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
10e46b: 8b 1d a8 30 12 00 mov 0x1230a8,%ebx
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
10e471: 8a 55 e4 mov -0x1c(%ebp),%dl
10e474: eb 10 jmp 10e486 <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 );
10e476: 52 push %edx
10e477: 52 push %edx
10e478: 57 push %edi
10e479: 8d 43 08 lea 0x8(%ebx),%eax
10e47c: 50 push %eax
10e47d: ff d6 call *%esi
10e47f: 88 c2 mov %al,%dl
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
10e481: 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 )
10e483: 83 c4 10 add $0x10,%esp
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
10e486: 81 fb ac 30 12 00 cmp $0x1230ac,%ebx
10e48c: 74 04 je 10e492 <rtems_filesystem_iterate+0x62>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
10e48e: 84 d2 test %dl,%dl
10e490: 74 e4 je 10e476 <rtems_filesystem_iterate+0x46><== ALWAYS TAKEN
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
10e492: 88 55 e4 mov %dl,-0x1c(%ebp)
10e495: e8 80 ff ff ff call 10e41a <rtems_libio_unlock>
10e49a: 8a 55 e4 mov -0x1c(%ebp),%dl
10e49d: 88 d0 mov %dl,%al
}
return stop;
}
10e49f: 8d 65 f4 lea -0xc(%ebp),%esp
10e4a2: 5b pop %ebx
10e4a3: 5e pop %esi
10e4a4: 5f pop %edi
10e4a5: c9 leave
10e4a6: c3 ret
001077c1 <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
1077c1: 55 push %ebp
1077c2: 89 e5 mov %esp,%ebp
1077c4: 57 push %edi
1077c5: 56 push %esi
1077c6: 53 push %ebx
1077c7: 83 ec 1c sub $0x1c,%esp
1077ca: 8b 7d 08 mov 0x8(%ebp),%edi
1077cd: 8b 75 0c mov 0xc(%ebp),%esi
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
1077d0: e8 bc ff ff ff call 107791 <rtems_libio_lock>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
1077d5: 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;
1077db: 31 c0 xor %eax,%eax
rtems_libio_lock();
for (
1077dd: eb 0b jmp 1077ea <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 );
1077df: 50 push %eax
1077e0: 50 push %eax
1077e1: 56 push %esi
1077e2: 53 push %ebx
1077e3: ff d7 call *%edi
}
rtems_libio_unlock();
return stop;
}
1077e5: 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 )
1077e7: 83 c4 10 add $0x10,%esp
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
1077ea: 81 fb 68 2f 12 00 cmp $0x122f68,%ebx
1077f0: 74 04 je 1077f6 <rtems_filesystem_mount_iterate+0x35>
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
1077f2: 84 c0 test %al,%al
1077f4: 74 e9 je 1077df <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();
1077f6: 88 45 e4 mov %al,-0x1c(%ebp)
1077f9: e8 ad ff ff ff call 1077ab <rtems_libio_unlock>
return stop;
}
1077fe: 8a 45 e4 mov -0x1c(%ebp),%al
107801: 8d 65 f4 lea -0xc(%ebp),%esp
107804: 5b pop %ebx
107805: 5e pop %esi
107806: 5f pop %edi
107807: c9 leave
107808: c3 ret
00107326 <rtems_filesystem_prefix_separators>:
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
107326: 55 push %ebp
107327: 89 e5 mov %esp,%ebp
107329: 57 push %edi
10732a: 56 push %esi
10732b: 53 push %ebx
10732c: 83 ec 0c sub $0xc,%esp
10732f: 8b 7d 08 mov 0x8(%ebp),%edi
107332: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
107335: 31 db xor %ebx,%ebx
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
107337: eb 01 jmp 10733a <rtems_filesystem_prefix_separators+0x14>
{
pathname++;
pathnamelen--;
stripped++;
107339: 43 inc %ebx
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
10733a: 8a 04 1f mov (%edi,%ebx,1),%al
10733d: 39 de cmp %ebx,%esi
10733f: 74 17 je 107358 <rtems_filesystem_prefix_separators+0x32><== NEVER TAKEN
107341: 84 c0 test %al,%al
107343: 74 13 je 107358 <rtems_filesystem_prefix_separators+0x32><== NEVER TAKEN
107345: 83 ec 0c sub $0xc,%esp
107348: 0f be c0 movsbl %al,%eax
10734b: 50 push %eax
10734c: e8 03 0d 00 00 call 108054 <rtems_filesystem_is_separator>
107351: 83 c4 10 add $0x10,%esp
107354: 85 c0 test %eax,%eax
107356: 75 e1 jne 107339 <rtems_filesystem_prefix_separators+0x13>
pathname++;
pathnamelen--;
stripped++;
}
return stripped;
}
107358: 89 d8 mov %ebx,%eax
10735a: 8d 65 f4 lea -0xc(%ebp),%esp
10735d: 5b pop %ebx
10735e: 5e pop %esi
10735f: 5f pop %edi
107360: c9 leave
107361: c3 ret
00107bed <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
107bed: 55 push %ebp
107bee: 89 e5 mov %esp,%ebp
107bf0: 56 push %esi
107bf1: 53 push %ebx
107bf2: 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 ) );
107bf5: 83 ec 0c sub $0xc,%esp
107bf8: 6a 08 push $0x8
107bfa: e8 89 03 00 00 call 107f88 <malloc>
107bff: 89 c3 mov %eax,%ebx
*key = new_key;
107c01: 8b 45 08 mov 0x8(%ebp),%eax
107c04: 89 18 mov %ebx,(%eax)
new_key->val = NULL;
107c06: c7 03 00 00 00 00 movl $0x0,(%ebx)
new_key->dtor = dtor;
107c0c: 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 );
107c0f: 83 c4 0c add $0xc,%esp
107c12: 56 push %esi
107c13: 53 push %ebx
107c14: 6a 00 push $0x0
107c16: e8 41 34 00 00 call 10b05c <rtems_task_variable_add>
107c1b: 89 c2 mov %eax,%edx
if ( status == RTEMS_SUCCESSFUL )
107c1d: 83 c4 10 add $0x10,%esp
return 0;
107c20: 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 )
107c22: 85 d2 test %edx,%edx
107c24: 74 0f je 107c35 <rtems_gxx_key_create+0x48><== ALWAYS TAKEN
return 0;
free( new_key );
107c26: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107c29: 53 push %ebx <== NOT EXECUTED
107c2a: e8 79 fe ff ff call 107aa8 <free> <== NOT EXECUTED
return -1;
107c2f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107c32: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
}
107c35: 8d 65 f8 lea -0x8(%ebp),%esp
107c38: 5b pop %ebx
107c39: 5e pop %esi
107c3a: c9 leave
107c3b: c3 ret
00107c4c <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
107c4c: 55 push %ebp
107c4d: 89 e5 mov %esp,%ebp
107c4f: 53 push %ebx
107c50: 83 ec 0c sub $0xc,%esp
107c53: 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 );
107c56: 53 push %ebx
107c57: 6a 00 push $0x0
107c59: e8 92 34 00 00 call 10b0f0 <rtems_task_variable_delete>
if ( status == RTEMS_SUCCESSFUL ) {
107c5e: 83 c4 10 add $0x10,%esp
107c61: 85 c0 test %eax,%eax
107c63: 75 11 jne 107c76 <rtems_gxx_key_delete+0x2a><== NEVER TAKEN
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
107c65: 85 db test %ebx,%ebx
107c67: 74 0d je 107c76 <rtems_gxx_key_delete+0x2a><== NEVER TAKEN
107c69: 83 ec 0c sub $0xc,%esp
107c6c: ff 33 pushl (%ebx)
107c6e: e8 35 fe ff ff call 107aa8 <free>
107c73: 83 c4 10 add $0x10,%esp
return 0;
}
key = NULL;
return 0;
}
107c76: 31 c0 xor %eax,%eax
107c78: 8b 5d fc mov -0x4(%ebp),%ebx
107c7b: c9 leave
107c7c: c3 ret
00107b94 <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))
{
107b94: 55 push %ebp
107b95: 89 e5 mov %esp,%ebp
107b97: 56 push %esi
107b98: 53 push %ebx
107b99: 83 ec 10 sub $0x10,%esp
107b9c: 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 ) {
107b9f: 8b 03 mov (%ebx),%eax
107ba1: 85 c0 test %eax,%eax
107ba3: 75 3f jne 107be4 <rtems_gxx_once+0x50>
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
107ba5: 52 push %edx
107ba6: 8d 45 f4 lea -0xc(%ebp),%eax
107ba9: 50 push %eax
107baa: 68 00 01 00 00 push $0x100
107baf: 68 00 01 00 00 push $0x100
107bb4: e8 23 33 00 00 call 10aedc <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
107bb9: 8b 33 mov (%ebx),%esi
107bbb: 83 c4 10 add $0x10,%esp
107bbe: 85 f6 test %esi,%esi
107bc0: 75 06 jne 107bc8 <rtems_gxx_once+0x34> <== NEVER TAKEN
*(volatile __gthread_once_t *)once = 1;
107bc2: c7 03 01 00 00 00 movl $0x1,(%ebx)
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
107bc8: 50 push %eax
107bc9: 8d 45 f4 lea -0xc(%ebp),%eax
107bcc: 50 push %eax
107bcd: 68 00 01 00 00 push $0x100
107bd2: ff 75 f4 pushl -0xc(%ebp)
107bd5: e8 02 33 00 00 call 10aedc <rtems_task_mode>
if ( o == 0 )
107bda: 83 c4 10 add $0x10,%esp
107bdd: 85 f6 test %esi,%esi
107bdf: 75 03 jne 107be4 <rtems_gxx_once+0x50> <== NEVER TAKEN
(*func)();
107be1: ff 55 0c call *0xc(%ebp)
}
return 0;
}
107be4: 31 c0 xor %eax,%eax
107be6: 8d 65 f8 lea -0x8(%ebp),%esp
107be9: 5b pop %ebx
107bea: 5e pop %esi
107beb: c9 leave
107bec: c3 ret
00107cd5 <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
107cd5: 55 push %ebp
107cd6: 89 e5 mov %esp,%ebp
107cd8: 53 push %ebx
107cd9: 83 ec 08 sub $0x8,%esp
107cdc: 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 );
107cdf: ff 73 04 pushl 0x4(%ebx)
107ce2: 53 push %ebx
107ce3: 6a 00 push $0x0
107ce5: e8 72 33 00 00 call 10b05c <rtems_task_variable_add>
107cea: 89 c2 mov %eax,%edx
if ( status == RTEMS_SUCCESSFUL ) {
107cec: 83 c4 10 add $0x10,%esp
/* now let's set the proper value */
key->val = (void *)ptr;
return 0;
}
return -1;
107cef: 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 ) {
107cf2: 85 d2 test %edx,%edx
107cf4: 75 07 jne 107cfd <rtems_gxx_setspecific+0x28><== NEVER TAKEN
/* now let's set the proper value */
key->val = (void *)ptr;
107cf6: 8b 45 0c mov 0xc(%ebp),%eax
107cf9: 89 03 mov %eax,(%ebx)
return 0;
107cfb: 31 c0 xor %eax,%eax
}
return -1;
}
107cfd: 8b 5d fc mov -0x4(%ebp),%ebx
107d00: c9 leave
107d01: c3 ret
0010a9e4 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
10a9e4: 55 push %ebp
10a9e5: 89 e5 mov %esp,%ebp
10a9e7: 83 ec 08 sub $0x8,%esp
if (
10a9ea: 83 3d c8 bd 12 00 03 cmpl $0x3,0x12bdc8
10a9f1: 75 0d jne 10aa00 <rtems_heap_allocate_aligned_with_boundary+0x1c><== NEVER TAKEN
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
10a9f3: e8 10 f1 ff ff call 109b08 <malloc_is_system_state_OK>
10a9f8: 88 c2 mov %al,%dl
) {
return NULL;
10a9fa: 31 c0 xor %eax,%eax
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
10a9fc: 84 d2 test %dl,%dl
10a9fe: 74 1c je 10aa1c <rtems_heap_allocate_aligned_with_boundary+0x38>
) {
return NULL;
}
malloc_deferred_frees_process();
10aa00: e8 41 f1 ff ff call 109b46 <malloc_deferred_frees_process>
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
10aa05: ff 75 10 pushl 0x10(%ebp)
10aa08: ff 75 0c pushl 0xc(%ebp)
10aa0b: ff 75 08 pushl 0x8(%ebp)
10aa0e: ff 35 80 71 12 00 pushl 0x127180
10aa14: e8 ef 43 00 00 call 10ee08 <_Protected_heap_Allocate_aligned_with_boundary>
10aa19: 83 c4 10 add $0x10,%esp
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
10aa1c: c9 leave
10aa1d: c3 ret
00107052 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
107052: 55 push %ebp
107053: 89 e5 mov %esp,%ebp
107055: 57 push %edi
107056: 56 push %esi
107057: 53 push %ebx
107058: 83 ec 48 sub $0x48,%esp
10705b: 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(
10705e: 31 c0 xor %eax,%eax
107060: 83 c9 ff or $0xffffffff,%ecx
107063: 89 f7 mov %esi,%edi
107065: f2 ae repnz scas %es:(%edi),%al
107067: f7 d1 not %ecx
107069: 49 dec %ecx
10706a: 6a 01 push $0x1
10706c: 8d 55 d4 lea -0x2c(%ebp),%edx
10706f: 52 push %edx
107070: 6a 00 push $0x0
107072: 51 push %ecx
107073: 56 push %esi
107074: 89 55 c4 mov %edx,-0x3c(%ebp)
107077: e8 2a 02 00 00 call 1072a6 <rtems_filesystem_evaluate_path>
10707c: 89 c7 mov %eax,%edi
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
10707e: 8b 5d d4 mov -0x2c(%ebp),%ebx
node_type = (*loc.ops->node_type_h)( &loc );
107081: 83 c4 14 add $0x14,%esp
107084: 8b 55 c4 mov -0x3c(%ebp),%edx
107087: 52 push %edx
107088: 8b 45 e0 mov -0x20(%ebp),%eax
10708b: ff 50 10 call *0x10(%eax)
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
10708e: 83 c4 10 add $0x10,%esp
107091: 83 f8 02 cmp $0x2,%eax
107094: 8b 55 c4 mov -0x3c(%ebp),%edx
107097: 75 07 jne 1070a0 <rtems_io_lookup_name+0x4e>
107099: 85 ff test %edi,%edi
10709b: 0f 95 c0 setne %al
10709e: 74 16 je 1070b6 <rtems_io_lookup_name+0x64><== ALWAYS TAKEN
rtems_filesystem_freenode( &loc );
1070a0: 83 ec 0c sub $0xc,%esp
1070a3: 8d 45 d4 lea -0x2c(%ebp),%eax
1070a6: 50 push %eax
1070a7: e8 b8 02 00 00 call 107364 <rtems_filesystem_freenode>
return RTEMS_UNSATISFIED;
1070ac: 83 c4 10 add $0x10,%esp
1070af: b8 0d 00 00 00 mov $0xd,%eax
1070b4: eb 32 jmp 1070e8 <rtems_io_lookup_name+0x96>
}
device_info->device_name = (char *) name;
1070b6: 8b 4d 0c mov 0xc(%ebp),%ecx
1070b9: 89 31 mov %esi,(%ecx)
device_info->device_name_length = strlen( name );
1070bb: 83 c9 ff or $0xffffffff,%ecx
1070be: 89 f7 mov %esi,%edi
1070c0: f2 ae repnz scas %es:(%edi),%al
1070c2: f7 d1 not %ecx
1070c4: 49 dec %ecx
1070c5: 8b 45 0c mov 0xc(%ebp),%eax
1070c8: 89 48 04 mov %ecx,0x4(%eax)
device_info->major = the_jnode->info.device.major;
1070cb: 8b 43 50 mov 0x50(%ebx),%eax
1070ce: 8b 4d 0c mov 0xc(%ebp),%ecx
1070d1: 89 41 08 mov %eax,0x8(%ecx)
device_info->minor = the_jnode->info.device.minor;
1070d4: 8b 43 54 mov 0x54(%ebx),%eax
1070d7: 89 41 0c mov %eax,0xc(%ecx)
rtems_filesystem_freenode( &loc );
1070da: 83 ec 0c sub $0xc,%esp
1070dd: 52 push %edx
1070de: e8 81 02 00 00 call 107364 <rtems_filesystem_freenode>
return RTEMS_SUCCESSFUL;
1070e3: 83 c4 10 add $0x10,%esp
1070e6: 31 c0 xor %eax,%eax
}
1070e8: 8d 65 f4 lea -0xc(%ebp),%esp
1070eb: 5b pop %ebx
1070ec: 5e pop %esi
1070ed: 5f pop %edi
1070ee: c9 leave
1070ef: c3 ret
0010c7b4 <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)
{
10c7b4: 55 push %ebp
10c7b5: 89 e5 mov %esp,%ebp
10c7b7: 57 push %edi
10c7b8: 56 push %esi
10c7b9: 53 push %ebx
10c7ba: 83 ec 0c sub $0xc,%esp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10c7bd: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10c7c1: 74 3d je 10c800 <rtems_iterate_over_all_threads+0x4c><== NEVER TAKEN
10c7c3: 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 ];
10c7c8: 8b 04 9d 9c 90 12 00 mov 0x12909c(,%ebx,4),%eax
10c7cf: 8b 78 04 mov 0x4(%eax),%edi
if ( !information )
10c7d2: be 01 00 00 00 mov $0x1,%esi
10c7d7: 85 ff test %edi,%edi
10c7d9: 75 17 jne 10c7f2 <rtems_iterate_over_all_threads+0x3e>
10c7db: eb 1d jmp 10c7fa <rtems_iterate_over_all_threads+0x46>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
10c7dd: 8b 47 1c mov 0x1c(%edi),%eax
10c7e0: 8b 04 b0 mov (%eax,%esi,4),%eax
if ( !the_thread )
10c7e3: 85 c0 test %eax,%eax
10c7e5: 74 0a je 10c7f1 <rtems_iterate_over_all_threads+0x3d><== NEVER TAKEN
continue;
(*routine)(the_thread);
10c7e7: 83 ec 0c sub $0xc,%esp
10c7ea: 50 push %eax
10c7eb: ff 55 08 call *0x8(%ebp)
10c7ee: 83 c4 10 add $0x10,%esp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10c7f1: 46 inc %esi
10c7f2: 0f b7 47 10 movzwl 0x10(%edi),%eax
10c7f6: 39 c6 cmp %eax,%esi
10c7f8: 76 e3 jbe 10c7dd <rtems_iterate_over_all_threads+0x29>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
10c7fa: 43 inc %ebx
10c7fb: 83 fb 04 cmp $0x4,%ebx
10c7fe: 75 c8 jne 10c7c8 <rtems_iterate_over_all_threads+0x14>
(*routine)(the_thread);
}
}
}
10c800: 8d 65 f4 lea -0xc(%ebp),%esp
10c803: 5b pop %ebx
10c804: 5e pop %esi
10c805: 5f pop %edi
10c806: c9 leave
10c807: c3 ret
0010e304 <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
10e304: 55 push %ebp
10e305: 89 e5 mov %esp,%ebp
10e307: 53 push %ebx
10e308: 83 ec 04 sub $0x4,%esp
10e30b: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_libio_lock();
10e30e: e8 d5 fe ff ff call 10e1e8 <rtems_libio_lock>
if (iop->sem)
10e313: 8b 43 2c mov 0x2c(%ebx),%eax
10e316: 85 c0 test %eax,%eax
10e318: 74 0c je 10e326 <rtems_libio_free+0x22> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
10e31a: 83 ec 0c sub $0xc,%esp
10e31d: 50 push %eax
10e31e: e8 09 be ff ff call 10a12c <rtems_semaphore_delete>
10e323: 83 c4 10 add $0x10,%esp
iop->flags &= ~LIBIO_FLAGS_OPEN;
10e326: 81 63 14 ff fe ff ff andl $0xfffffeff,0x14(%ebx)
iop->data1 = rtems_libio_iop_freelist;
10e32d: a1 fc 51 12 00 mov 0x1251fc,%eax
10e332: 89 43 34 mov %eax,0x34(%ebx)
rtems_libio_iop_freelist = iop;
10e335: 89 1d fc 51 12 00 mov %ebx,0x1251fc
rtems_libio_unlock();
}
10e33b: 8b 5d fc mov -0x4(%ebp),%ebx
10e33e: c9 leave
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
rtems_libio_unlock();
10e33f: e9 be fe ff ff jmp 10e202 <rtems_libio_unlock>
00107464 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
107464: 55 push %ebp
107465: 89 e5 mov %esp,%ebp
107467: 53 push %ebx
107468: 83 ec 04 sub $0x4,%esp
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
10746b: 8b 1d 44 11 12 00 mov 0x121144,%ebx
107471: 85 db test %ebx,%ebx
107473: 74 3e je 1074b3 <rtems_libio_init+0x4f> <== NEVER TAKEN
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
107475: 50 push %eax
107476: 50 push %eax
107477: 6a 38 push $0x38
107479: 53 push %ebx
10747a: e8 8d fd ff ff call 10720c <calloc>
10747f: a3 f8 51 12 00 mov %eax,0x1251f8
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
107484: 83 c4 10 add $0x10,%esp
107487: 85 c0 test %eax,%eax
107489: 75 07 jne 107492 <rtems_libio_init+0x2e>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
10748b: 83 ec 0c sub $0xc,%esp
10748e: 6a 1a push $0x1a
107490: eb 44 jmp 1074d6 <rtems_libio_init+0x72>
iop = rtems_libio_iop_freelist = rtems_libio_iops;
107492: a3 fc 51 12 00 mov %eax,0x1251fc
107497: 89 c2 mov %eax,%edx
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
107499: 31 c9 xor %ecx,%ecx
10749b: eb 03 jmp 1074a0 <rtems_libio_init+0x3c>
iop->data1 = iop + 1;
10749d: 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++)
1074a0: 41 inc %ecx
1074a1: 83 c2 38 add $0x38,%edx
1074a4: 39 d9 cmp %ebx,%ecx
1074a6: 72 f5 jb 10749d <rtems_libio_init+0x39>
iop->data1 = iop + 1;
iop->data1 = NULL;
1074a8: 6b db 38 imul $0x38,%ebx,%ebx
1074ab: c7 44 18 fc 00 00 00 movl $0x0,-0x4(%eax,%ebx,1)
1074b2: 00
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
1074b3: 83 ec 0c sub $0xc,%esp
1074b6: 68 00 52 12 00 push $0x125200
1074bb: 6a 00 push $0x0
1074bd: 6a 54 push $0x54
1074bf: 6a 01 push $0x1
1074c1: 68 4f 49 42 4c push $0x4c42494f
1074c6: e8 c9 2a 00 00 call 109f94 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
1074cb: 83 c4 20 add $0x20,%esp
1074ce: 85 c0 test %eax,%eax
1074d0: 74 09 je 1074db <rtems_libio_init+0x77> <== ALWAYS TAKEN
rtems_fatal_error_occurred( rc );
1074d2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1074d5: 50 push %eax <== NOT EXECUTED
1074d6: e8 ad 32 00 00 call 10a788 <rtems_fatal_error_occurred>
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
1074db: a1 40 11 12 00 mov 0x121140,%eax
1074e0: 85 c0 test %eax,%eax
1074e2: 74 06 je 1074ea <rtems_libio_init+0x86> <== NEVER TAKEN
(* rtems_fs_init_helper)();
}
1074e4: 8b 5d fc mov -0x4(%ebp),%ebx
1074e7: c9 leave
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
(* rtems_fs_init_helper)();
1074e8: ff e0 jmp *%eax
}
1074ea: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
1074ed: c9 leave <== NOT EXECUTED
1074ee: c3 ret <== NOT EXECUTED
00108651 <rtems_libio_set_private_env>:
rtems_status_code rtems_libio_set_private_env(void)
{
108651: 55 push %ebp
108652: 89 e5 mov %esp,%ebp
108654: 57 push %edi
108655: 56 push %esi
108656: 53 push %ebx
108657: 83 ec 3c sub $0x3c,%esp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id task_id = rtems_task_self();
10865a: e8 4d 27 00 00 call 10adac <rtems_task_self>
10865f: 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);
108661: 83 ec 0c sub $0xc,%esp
108664: 6a 00 push $0x0
108666: 8d 45 d4 lea -0x2c(%ebp),%eax
108669: 50 push %eax
10866a: 6a 00 push $0x0
10866c: 6a 01 push $0x1
10866e: 68 e8 f7 11 00 push $0x11f7e8
108673: e8 42 f0 ff ff call 1076ba <rtems_filesystem_evaluate_path>
108678: 89 c2 mov %eax,%edx
if (rv != 0)
10867a: 83 c4 20 add $0x20,%esp
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
10867d: 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)
108682: 85 d2 test %edx,%edx
108684: 0f 85 c0 00 00 00 jne 10874a <rtems_libio_set_private_env+0xf9><== NEVER TAKEN
goto error_0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, ¤t_loc, 0);
10868a: 83 ec 0c sub $0xc,%esp
10868d: 6a 00 push $0x0
10868f: 8d 45 c0 lea -0x40(%ebp),%eax
108692: 50 push %eax
108693: 6a 00 push $0x0
108695: 6a 01 push $0x1
108697: 68 e8 f7 11 00 push $0x11f7e8
10869c: e8 19 f0 ff ff call 1076ba <rtems_filesystem_evaluate_path>
if (rv != 0)
1086a1: 83 c4 20 add $0x20,%esp
1086a4: 85 c0 test %eax,%eax
1086a6: 0f 85 8a 00 00 00 jne 108736 <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
1086ac: 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 (
1086b1: 3d 48 52 12 00 cmp $0x125248,%eax
1086b6: 74 04 je 1086bc <rtems_libio_set_private_env+0x6b>
rtems_current_user_env == &rtems_global_user_env
|| rtems_current_user_env->task_id != task_id
1086b8: 39 18 cmp %ebx,(%eax)
1086ba: 74 32 je 1086ee <rtems_libio_set_private_env+0x9d>
) {
new_env = malloc(sizeof(rtems_user_env_t));
1086bc: 83 ec 0c sub $0xc,%esp
1086bf: 6a 48 push $0x48
1086c1: e8 66 f5 ff ff call 107c2c <malloc>
1086c6: 89 c6 mov %eax,%esi
if (new_env == NULL)
1086c8: 83 c4 10 add $0x10,%esp
1086cb: 85 c0 test %eax,%eax
1086cd: 74 58 je 108727 <rtems_libio_set_private_env+0xd6>
#ifdef HAVE_USERENV_REFCNT
new_env->refcnt = 1;
#endif
sc = rtems_task_variable_add(
1086cf: 50 push %eax
1086d0: 68 14 86 10 00 push $0x108614
1086d5: 68 6c 30 12 00 push $0x12306c
1086da: 6a 00 push $0x0
1086dc: e8 3f 27 00 00 call 10ae20 <rtems_task_variable_add>
RTEMS_SELF,
(void*)&rtems_current_user_env,
(void(*)(void *))free_user_env
);
if (sc != RTEMS_SUCCESSFUL)
1086e1: 83 c4 10 add $0x10,%esp
1086e4: 85 c0 test %eax,%eax
1086e6: 75 33 jne 10871b <rtems_libio_set_private_env+0xca>
goto error_3;
rtems_current_user_env = new_env;
1086e8: 89 35 6c 30 12 00 mov %esi,0x12306c
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
1086ee: a1 6c 30 12 00 mov 0x12306c,%eax
1086f3: be 48 52 12 00 mov $0x125248,%esi
1086f8: b9 12 00 00 00 mov $0x12,%ecx
1086fd: 89 c7 mov %eax,%edi
1086ff: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_current_user_env->task_id = task_id;
108701: 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;
108703: 8d 78 18 lea 0x18(%eax),%edi
108706: 8d 75 d4 lea -0x2c(%ebp),%esi
108709: b1 05 mov $0x5,%cl
10870b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_filesystem_current = current_loc;
10870d: 8d 78 04 lea 0x4(%eax),%edi
108710: 8d 75 c0 lea -0x40(%ebp),%esi
108713: b1 05 mov $0x5,%cl
108715: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return RTEMS_SUCCESSFUL;
108717: 31 c0 xor %eax,%eax
108719: eb 2f jmp 10874a <rtems_libio_set_private_env+0xf9>
error_3:
free(new_env);
10871b: 83 ec 0c sub $0xc,%esp
10871e: 56 push %esi
10871f: e8 68 f0 ff ff call 10778c <free>
108724: 83 c4 10 add $0x10,%esp
error_2:
rtems_filesystem_freenode(¤t_loc);
108727: 83 ec 0c sub $0xc,%esp
10872a: 8d 45 c0 lea -0x40(%ebp),%eax
10872d: 50 push %eax
10872e: e8 45 f0 ff ff call 107778 <rtems_filesystem_freenode>
108733: 83 c4 10 add $0x10,%esp
error_1:
rtems_filesystem_freenode(&root_loc);
108736: 83 ec 0c sub $0xc,%esp
108739: 8d 45 d4 lea -0x2c(%ebp),%eax
10873c: 50 push %eax
10873d: e8 36 f0 ff ff call 107778 <rtems_filesystem_freenode>
108742: 83 c4 10 add $0x10,%esp
error_0:
return RTEMS_NO_MEMORY;
108745: b8 1a 00 00 00 mov $0x1a,%eax
}
10874a: 8d 65 f4 lea -0xc(%ebp),%esp
10874d: 5b pop %ebx
10874e: 5e pop %esi
10874f: 5f pop %edi
108750: c9 leave
108751: c3 ret
00108752 <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)
{
108752: 55 push %ebp
108753: 89 e5 mov %esp,%ebp
108755: 56 push %esi
108756: 53 push %ebx
108757: 83 ec 20 sub $0x20,%esp
10875a: 8b 75 08 mov 0x8(%ebp),%esi
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
10875d: e8 4a 26 00 00 call 10adac <rtems_task_self>
108762: 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;
108764: 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 )
108766: 39 de cmp %ebx,%esi
108768: 74 3c je 1087a6 <rtems_libio_share_private_env+0x54><== NEVER TAKEN
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
10876a: 52 push %edx
task_id,
(void*)&rtems_current_user_env,
(void*)&shared_user_env );
10876b: 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(
10876e: 50 push %eax
10876f: 68 6c 30 12 00 push $0x12306c
108774: 56 push %esi
108775: e8 3a 27 00 00 call 10aeb4 <rtems_task_variable_get>
(void*)&shared_user_env );
/*
* If it was not successful, return the error code
*/
if (sc != RTEMS_SUCCESSFUL)
10877a: 83 c4 10 add $0x10,%esp
10877d: 85 c0 test %eax,%eax
10877f: 75 25 jne 1087a6 <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) {
108781: 8b 15 6c 30 12 00 mov 0x12306c,%edx
108787: 39 1a cmp %ebx,(%edx)
108789: 75 12 jne 10879d <rtems_libio_share_private_env+0x4b>
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
10878b: 83 ec 0c sub $0xc,%esp
10878e: 52 push %edx
10878f: 89 45 e4 mov %eax,-0x1c(%ebp)
108792: e8 7d fe ff ff call 108614 <free_user_env>
108797: 83 c4 10 add $0x10,%esp
10879a: 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;
10879d: 8b 55 f4 mov -0xc(%ebp),%edx
1087a0: 89 15 6c 30 12 00 mov %edx,0x12306c
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
1087a6: 8d 65 f8 lea -0x8(%ebp),%esp
1087a9: 5b pop %ebx
1087aa: 5e pop %esi
1087ab: c9 leave
1087ac: c3 ret
0010e24d <rtems_libio_to_fcntl_flags>:
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
10e24d: 55 push %ebp
10e24e: 89 e5 mov %esp,%ebp
10e250: 8b 55 08 mov 0x8(%ebp),%edx
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
10e253: 89 d1 mov %edx,%ecx
10e255: 83 e1 06 and $0x6,%ecx
fcntl_flags |= O_RDWR;
10e258: 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 ) {
10e25d: 83 f9 06 cmp $0x6,%ecx
10e260: 74 0f je 10e271 <rtems_libio_to_fcntl_flags+0x24>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
fcntl_flags |= O_RDONLY;
10e262: 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) {
10e264: f6 c2 02 test $0x2,%dl
10e267: 75 08 jne 10e271 <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;
10e269: 31 c0 xor %eax,%eax
10e26b: f6 c2 04 test $0x4,%dl <== NOT EXECUTED
10e26e: 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 ) {
10e271: f6 c2 01 test $0x1,%dl
10e274: 74 03 je 10e279 <rtems_libio_to_fcntl_flags+0x2c>
fcntl_flags |= O_NONBLOCK;
10e276: 80 cc 40 or $0x40,%ah
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
10e279: f6 c6 02 test $0x2,%dh
10e27c: 74 03 je 10e281 <rtems_libio_to_fcntl_flags+0x34>
fcntl_flags |= O_APPEND;
10e27e: 83 c8 08 or $0x8,%eax
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
10e281: 80 e6 04 and $0x4,%dh
10e284: 74 03 je 10e289 <rtems_libio_to_fcntl_flags+0x3c>
fcntl_flags |= O_CREAT;
10e286: 80 cc 02 or $0x2,%ah
}
return fcntl_flags;
}
10e289: c9 leave
10e28a: c3 ret
00109e0c <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
109e0c: 55 push %ebp
109e0d: 89 e5 mov %esp,%ebp
109e0f: 83 ec 1c sub $0x1c,%esp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
109e12: 8d 45 f4 lea -0xc(%ebp),%eax
109e15: 50 push %eax
109e16: ff 75 08 pushl 0x8(%ebp)
109e19: ff 35 80 71 12 00 pushl 0x127180
109e1f: e8 8c 50 00 00 call 10eeb0 <_Protected_heap_Get_block_size>
109e24: 83 c4 10 add $0x10,%esp
109e27: 84 c0 test %al,%al
109e29: 74 11 je 109e3c <rtems_malloc_statistics_at_free+0x30><== NEVER TAKEN
MSBUMP(lifetime_freed, size);
109e2b: 8b 45 f4 mov -0xc(%ebp),%eax
109e2e: 31 d2 xor %edx,%edx
109e30: 01 05 60 bb 12 00 add %eax,0x12bb60
109e36: 11 15 64 bb 12 00 adc %edx,0x12bb64
}
}
109e3c: c9 leave
109e3d: c3 ret
00109e3e <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
109e3e: 55 push %ebp
109e3f: 89 e5 mov %esp,%ebp
109e41: 83 ec 18 sub $0x18,%esp
109e44: 8b 45 08 mov 0x8(%ebp),%eax
uintptr_t actual_size = 0;
109e47: 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 )
109e4e: 85 c0 test %eax,%eax
109e50: 74 43 je 109e95 <rtems_malloc_statistics_at_malloc+0x57><== NEVER TAKEN
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
109e52: 52 push %edx
109e53: 8d 55 f4 lea -0xc(%ebp),%edx
109e56: 52 push %edx
109e57: 50 push %eax
109e58: ff 35 80 71 12 00 pushl 0x127180
109e5e: e8 4d 50 00 00 call 10eeb0 <_Protected_heap_Get_block_size>
MSBUMP(lifetime_allocated, actual_size);
109e63: 8b 45 f4 mov -0xc(%ebp),%eax
109e66: 31 d2 xor %edx,%edx
109e68: 03 05 58 bb 12 00 add 0x12bb58,%eax
109e6e: 13 15 5c bb 12 00 adc 0x12bb5c,%edx
109e74: a3 58 bb 12 00 mov %eax,0x12bb58
109e79: 89 15 5c bb 12 00 mov %edx,0x12bb5c
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
109e7f: 2b 05 60 bb 12 00 sub 0x12bb60,%eax
if (current_depth > s->max_depth)
109e85: 83 c4 10 add $0x10,%esp
109e88: 3b 05 54 bb 12 00 cmp 0x12bb54,%eax
109e8e: 76 05 jbe 109e95 <rtems_malloc_statistics_at_malloc+0x57>
s->max_depth = current_depth;
109e90: a3 54 bb 12 00 mov %eax,0x12bb54
}
109e95: c9 leave
109e96: c3 ret
00111aac <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
111aac: 55 push %ebp
111aad: 89 e5 mov %esp,%ebp
111aaf: 57 push %edi
111ab0: 56 push %esi
111ab1: 53 push %ebx
111ab2: 83 ec 0c sub $0xc,%esp
111ab5: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
111ab8: be 16 00 00 00 mov $0x16,%esi
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
111abd: 85 db test %ebx,%ebx
111abf: 74 55 je 111b16 <rtems_memalign+0x6a>
return EINVAL;
*pointer = NULL;
111ac1: 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()) &&
111ac7: 83 3d 54 85 12 00 03 cmpl $0x3,0x128554
111ace: 75 09 jne 111ad9 <rtems_memalign+0x2d> <== NEVER TAKEN
!malloc_is_system_state_OK() )
111ad0: e8 57 67 ff ff call 10822c <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()) &&
111ad5: 84 c0 test %al,%al
111ad7: 74 3d je 111b16 <rtems_memalign+0x6a> <== NEVER TAKEN
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
111ad9: e8 8c 67 ff ff call 10826a <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
111ade: 6a 00 push $0x0
111ae0: ff 75 0c pushl 0xc(%ebp)
111ae3: ff 75 10 pushl 0x10(%ebp)
111ae6: ff 35 80 41 12 00 pushl 0x124180
111aec: e8 77 af ff ff call 10ca68 <_Protected_heap_Allocate_aligned_with_boundary>
111af1: 89 c7 mov %eax,%edi
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
111af3: 83 c4 10 add $0x10,%esp
return ENOMEM;
111af6: be 0c 00 00 00 mov $0xc,%esi
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
111afb: 85 c0 test %eax,%eax
111afd: 74 17 je 111b16 <rtems_memalign+0x6a>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
111aff: a1 90 66 12 00 mov 0x126690,%eax
111b04: 85 c0 test %eax,%eax
111b06: 74 0a je 111b12 <rtems_memalign+0x66>
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
111b08: 83 ec 0c sub $0xc,%esp
111b0b: 53 push %ebx
111b0c: ff 50 04 call *0x4(%eax)
111b0f: 83 c4 10 add $0x10,%esp
*pointer = return_this;
111b12: 89 3b mov %edi,(%ebx)
return 0;
111b14: 31 f6 xor %esi,%esi
}
111b16: 89 f0 mov %esi,%eax
111b18: 8d 65 f4 lea -0xc(%ebp),%esp
111b1b: 5b pop %ebx
111b1c: 5e pop %esi
111b1d: 5f pop %edi
111b1e: c9 leave
111b1f: c3 ret
001103cc <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
1103cc: 55 push %ebp
1103cd: 89 e5 mov %esp,%ebp
1103cf: 57 push %edi
1103d0: 56 push %esi
1103d1: 53 push %ebx
1103d2: 83 ec 78 sub $0x78,%esp
int success = 0;
char *dup_path = strdup(path);
1103d5: ff 75 08 pushl 0x8(%ebp)
1103d8: e8 87 32 00 00 call 113664 <strdup>
1103dd: 89 c3 mov %eax,%ebx
if (dup_path != NULL) {
1103df: 83 c4 10 add $0x10,%esp
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
1103e2: 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) {
1103e5: 85 db test %ebx,%ebx
1103e7: 0f 84 1e 01 00 00 je 11050b <rtems_mkdir+0x13f> <== NEVER TAKEN
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
1103ed: 31 c0 xor %eax,%eax
1103ef: 80 3b 2f cmpb $0x2f,(%ebx)
1103f2: 0f 94 c0 sete %al
1103f5: 8d 3c 03 lea (%ebx,%eax,1),%edi
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
1103f8: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
1103ff: b8 01 00 00 00 mov $0x1,%eax
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
110404: 8a 0f mov (%edi),%cl
last = 1;
110406: 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')
11040b: 84 c9 test %cl,%cl
11040d: 74 0b je 11041a <rtems_mkdir+0x4e>
last = 1;
else if (p[0] != '/')
11040f: 80 f9 2f cmp $0x2f,%cl
110412: 0f 85 c8 00 00 00 jne 1104e0 <rtems_mkdir+0x114>
110418: 30 d2 xor %dl,%dl
continue;
*p = '\0';
11041a: c6 07 00 movb $0x0,(%edi)
if (!last && p[1] == '\0')
11041d: be 01 00 00 00 mov $0x1,%esi
110422: 85 d2 test %edx,%edx
110424: 75 0b jne 110431 <rtems_mkdir+0x65>
110426: 31 d2 xor %edx,%edx
110428: 80 7f 01 00 cmpb $0x0,0x1(%edi)
11042c: 0f 94 c2 sete %dl
11042f: 89 d6 mov %edx,%esi
last = 1;
if (first) {
110431: 85 c0 test %eax,%eax
110433: 74 1a je 11044f <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);
110435: 83 ec 0c sub $0xc,%esp
110438: 6a 00 push $0x0
11043a: e8 75 01 00 00 call 1105b4 <umask>
11043f: 89 45 94 mov %eax,-0x6c(%ebp)
numask = oumask & ~(S_IWUSR | S_IXUSR);
110442: 24 3f and $0x3f,%al
(void)umask(numask);
110444: 89 04 24 mov %eax,(%esp)
110447: e8 68 01 00 00 call 1105b4 <umask>
11044c: 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) {
11044f: b8 ff 01 00 00 mov $0x1ff,%eax
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
110454: 85 f6 test %esi,%esi
110456: 74 11 je 110469 <rtems_mkdir+0x9d>
(void)umask(oumask);
110458: 83 ec 0c sub $0xc,%esp
11045b: ff 75 94 pushl -0x6c(%ebp)
11045e: e8 51 01 00 00 call 1105b4 <umask>
110463: 83 c4 10 add $0x10,%esp
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
110466: 8b 45 0c mov 0xc(%ebp),%eax
110469: 52 push %edx
11046a: 52 push %edx
11046b: 50 push %eax
11046c: 53 push %ebx
11046d: e8 9e 82 ff ff call 108710 <mkdir>
110472: 83 c4 10 add $0x10,%esp
110475: 85 c0 test %eax,%eax
110477: 79 5e jns 1104d7 <rtems_mkdir+0x10b>
if (errno == EEXIST || errno == EISDIR) {
110479: e8 0e 25 00 00 call 11298c <__errno>
11047e: 83 38 11 cmpl $0x11,(%eax)
110481: 74 0a je 11048d <rtems_mkdir+0xc1>
110483: e8 04 25 00 00 call 11298c <__errno>
110488: 83 38 15 cmpl $0x15,(%eax)
11048b: 75 59 jne 1104e6 <rtems_mkdir+0x11a> <== ALWAYS TAKEN
if (stat(path, &sb) < 0) {
11048d: 50 push %eax
11048e: 50 push %eax
11048f: 8d 45 a0 lea -0x60(%ebp),%eax
110492: 50 push %eax
110493: 53 push %ebx
110494: e8 8b 00 00 00 call 110524 <stat>
110499: 83 c4 10 add $0x10,%esp
11049c: 85 c0 test %eax,%eax
11049e: 78 46 js 1104e6 <rtems_mkdir+0x11a> <== NEVER TAKEN
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
1104a0: 8b 45 ac mov -0x54(%ebp),%eax
1104a3: 25 00 f0 00 00 and $0xf000,%eax
1104a8: 3d 00 40 00 00 cmp $0x4000,%eax
1104ad: 74 22 je 1104d1 <rtems_mkdir+0x105>
if (last)
1104af: 85 f6 test %esi,%esi
1104b1: 74 0f je 1104c2 <rtems_mkdir+0xf6>
errno = EEXIST;
1104b3: e8 d4 24 00 00 call 11298c <__errno>
1104b8: c7 00 11 00 00 00 movl $0x11,(%eax)
else
errno = ENOTDIR;
retval = 0;
1104be: 31 ff xor %edi,%edi
1104c0: eb 38 jmp 1104fa <rtems_mkdir+0x12e>
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
errno = EEXIST;
else
errno = ENOTDIR;
1104c2: e8 c5 24 00 00 call 11298c <__errno>
1104c7: c7 00 14 00 00 00 movl $0x14,(%eax)
retval = 0;
1104cd: 31 ff xor %edi,%edi
1104cf: eb 1b jmp 1104ec <rtems_mkdir+0x120>
break;
}
if (last)
1104d1: 85 f6 test %esi,%esi
1104d3: 75 3e jne 110513 <rtems_mkdir+0x147>
1104d5: eb 04 jmp 1104db <rtems_mkdir+0x10f>
} else {
retval = 0;
break;
}
}
if (!last)
1104d7: 85 f6 test %esi,%esi
1104d9: 75 3f jne 11051a <rtems_mkdir+0x14e>
*p = '/';
1104db: c6 07 2f movb $0x2f,(%edi)
1104de: 31 c0 xor %eax,%eax
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
1104e0: 47 inc %edi
1104e1: e9 1e ff ff ff jmp 110404 <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;
1104e6: 31 ff xor %edi,%edi
}
}
if (!last)
*p = '/';
}
if (!first && !last)
1104e8: 85 f6 test %esi,%esi
1104ea: 75 0e jne 1104fa <rtems_mkdir+0x12e> <== ALWAYS TAKEN
(void)umask(oumask);
1104ec: 83 ec 0c sub $0xc,%esp
1104ef: ff 75 94 pushl -0x6c(%ebp)
1104f2: e8 bd 00 00 00 call 1105b4 <umask>
1104f7: 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);
1104fa: 83 ec 0c sub $0xc,%esp
1104fd: 53 push %ebx
1104fe: e8 b1 7c ff ff call 1081b4 <free>
}
return success != 0 ? 0 : -1;
110503: 83 c4 10 add $0x10,%esp
110506: 83 ff 01 cmp $0x1,%edi
110509: 19 c0 sbb %eax,%eax
}
11050b: 8d 65 f4 lea -0xc(%ebp),%esp
11050e: 5b pop %ebx
11050f: 5e pop %esi
110510: 5f pop %edi
110511: c9 leave
110512: c3 ret
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
retval = 2;
110513: bf 02 00 00 00 mov $0x2,%edi
110518: eb e0 jmp 1104fa <rtems_mkdir+0x12e>
} else {
retval = 0;
break;
}
}
if (!last)
11051a: bf 01 00 00 00 mov $0x1,%edi
11051f: eb d9 jmp 1104fa <rtems_mkdir+0x12e>
00114840 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
114840: 55 push %ebp
114841: 89 e5 mov %esp,%ebp
114843: 57 push %edi
114844: 56 push %esi
114845: 53 push %ebx
114846: 83 ec 1c sub $0x1c,%esp
114849: 8b 75 0c mov 0xc(%ebp),%esi
11484c: 8b 55 10 mov 0x10(%ebp),%edx
11484f: 8b 7d 14 mov 0x14(%ebp),%edi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
114852: b8 03 00 00 00 mov $0x3,%eax
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
114857: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
11485b: 0f 84 ce 00 00 00 je 11492f <rtems_partition_create+0xef>
return RTEMS_INVALID_NAME;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
114861: b0 09 mov $0x9,%al
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
114863: 85 f6 test %esi,%esi
114865: 0f 84 c4 00 00 00 je 11492f <rtems_partition_create+0xef>
return RTEMS_INVALID_ADDRESS;
if ( !id )
11486b: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp)
11486f: 0f 84 ba 00 00 00 je 11492f <rtems_partition_create+0xef><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
114875: 85 ff test %edi,%edi
114877: 0f 84 ad 00 00 00 je 11492a <rtems_partition_create+0xea>
11487d: 85 d2 test %edx,%edx
11487f: 0f 84 a5 00 00 00 je 11492a <rtems_partition_create+0xea>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
114885: b0 08 mov $0x8,%al
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
114887: 39 fa cmp %edi,%edx
114889: 0f 82 a0 00 00 00 jb 11492f <rtems_partition_create+0xef>
11488f: f7 c7 03 00 00 00 test $0x3,%edi
114895: 0f 85 94 00 00 00 jne 11492f <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;
11489b: 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 ) )
11489d: f7 c6 03 00 00 00 test $0x3,%esi
1148a3: 0f 85 86 00 00 00 jne 11492f <rtems_partition_create+0xef>
1148a9: a1 d4 ef 13 00 mov 0x13efd4,%eax
1148ae: 40 inc %eax
1148af: a3 d4 ef 13 00 mov %eax,0x13efd4
* 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 );
1148b4: 83 ec 0c sub $0xc,%esp
1148b7: 68 64 ee 13 00 push $0x13ee64
1148bc: 89 55 e4 mov %edx,-0x1c(%ebp)
1148bf: e8 20 3e 00 00 call 1186e4 <_Objects_Allocate>
1148c4: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
1148c6: 83 c4 10 add $0x10,%esp
1148c9: 85 c0 test %eax,%eax
1148cb: 8b 55 e4 mov -0x1c(%ebp),%edx
1148ce: 75 0c jne 1148dc <rtems_partition_create+0x9c>
_Thread_Enable_dispatch();
1148d0: e8 29 4d 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
1148d5: b8 05 00 00 00 mov $0x5,%eax
1148da: eb 53 jmp 11492f <rtems_partition_create+0xef>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
1148dc: 89 70 10 mov %esi,0x10(%eax)
the_partition->length = length;
1148df: 89 50 14 mov %edx,0x14(%eax)
the_partition->buffer_size = buffer_size;
1148e2: 89 78 18 mov %edi,0x18(%eax)
the_partition->attribute_set = attribute_set;
1148e5: 8b 45 18 mov 0x18(%ebp),%eax
1148e8: 89 43 1c mov %eax,0x1c(%ebx)
the_partition->number_of_used_blocks = 0;
1148eb: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
_Chain_Initialize( &the_partition->Memory, starting_address,
1148f2: 57 push %edi
1148f3: 89 d0 mov %edx,%eax
1148f5: 31 d2 xor %edx,%edx
1148f7: f7 f7 div %edi
1148f9: 50 push %eax
1148fa: 56 push %esi
1148fb: 8d 43 24 lea 0x24(%ebx),%eax
1148fe: 50 push %eax
1148ff: e8 84 2a 00 00 call 117388 <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
114904: 8b 43 08 mov 0x8(%ebx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
114907: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
11490a: 8b 15 80 ee 13 00 mov 0x13ee80,%edx
114910: 89 1c 8a mov %ebx,(%edx,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
114913: 8b 55 08 mov 0x8(%ebp),%edx
114916: 89 53 0c mov %edx,0xc(%ebx)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
114919: 8b 55 1c mov 0x1c(%ebp),%edx
11491c: 89 02 mov %eax,(%edx)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
11491e: e8 db 4c 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
114923: 83 c4 10 add $0x10,%esp
114926: 31 c0 xor %eax,%eax
114928: eb 05 jmp 11492f <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;
11492a: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
11492f: 8d 65 f4 lea -0xc(%ebp),%esp
114932: 5b pop %ebx
114933: 5e pop %esi
114934: 5f pop %edi
114935: c9 leave
114936: c3 ret
00113fb8 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
113fb8: 55 push %ebp
113fb9: 89 e5 mov %esp,%ebp
113fbb: 57 push %edi
113fbc: 56 push %esi
113fbd: 53 push %ebx
113fbe: 83 ec 0c sub $0xc,%esp
113fc1: 8b 75 08 mov 0x8(%ebp),%esi
113fc4: 8b 7d 10 mov 0x10(%ebp),%edi
113fc7: 8b 5d 18 mov 0x18(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
113fca: b8 03 00 00 00 mov $0x3,%eax
rtems_id *id
)
{
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
113fcf: 85 f6 test %esi,%esi
113fd1: 74 66 je 114039 <rtems_port_create+0x81><== NEVER TAKEN
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
113fd3: b0 09 mov $0x9,%al
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
113fd5: 85 db test %ebx,%ebx
113fd7: 74 60 je 114039 <rtems_port_create+0x81><== NEVER TAKEN
* id - port id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_port_create(
113fd9: 8b 55 0c mov 0xc(%ebp),%edx
113fdc: 09 fa or %edi,%edx
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
113fde: 80 e2 03 and $0x3,%dl
113fe1: 75 56 jne 114039 <rtems_port_create+0x81><== NEVER TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
113fe3: a1 d4 ef 13 00 mov 0x13efd4,%eax
113fe8: 40 inc %eax
113fe9: a3 d4 ef 13 00 mov %eax,0x13efd4
*/
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control
*_Dual_ported_memory_Allocate ( void )
{
return (Dual_ported_memory_Control *)
_Objects_Allocate( &_Dual_ported_memory_Information );
113fee: 83 ec 0c sub $0xc,%esp
113ff1: 68 24 ee 13 00 push $0x13ee24
113ff6: e8 e9 46 00 00 call 1186e4 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
113ffb: 83 c4 10 add $0x10,%esp
113ffe: 85 c0 test %eax,%eax
114000: 75 0c jne 11400e <rtems_port_create+0x56>
_Thread_Enable_dispatch();
114002: e8 f7 55 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
114007: b8 05 00 00 00 mov $0x5,%eax
11400c: eb 2b jmp 114039 <rtems_port_create+0x81>
}
the_port->internal_base = internal_start;
11400e: 8b 55 0c mov 0xc(%ebp),%edx
114011: 89 50 10 mov %edx,0x10(%eax)
the_port->external_base = external_start;
114014: 89 78 14 mov %edi,0x14(%eax)
the_port->length = length - 1;
114017: 8b 55 14 mov 0x14(%ebp),%edx
11401a: 4a dec %edx
11401b: 89 50 18 mov %edx,0x18(%eax)
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
11401e: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
114021: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
114024: 8b 0d 40 ee 13 00 mov 0x13ee40,%ecx
11402a: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
11402d: 89 70 0c mov %esi,0xc(%eax)
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
114030: 89 13 mov %edx,(%ebx)
_Thread_Enable_dispatch();
114032: e8 c7 55 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
114037: 31 c0 xor %eax,%eax
}
114039: 8d 65 f4 lea -0xc(%ebp),%esp
11403c: 5b pop %ebx
11403d: 5e pop %esi
11403e: 5f pop %edi
11403f: c9 leave
114040: c3 ret
0010b085 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
10b085: 55 push %ebp
10b086: 89 e5 mov %esp,%ebp
10b088: 57 push %edi
10b089: 56 push %esi
10b08a: 53 push %ebx
10b08b: 83 ec 30 sub $0x30,%esp
10b08e: 8b 75 08 mov 0x8(%ebp),%esi
10b091: 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 );
10b094: 8d 45 e4 lea -0x1c(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
10b097: 50 push %eax
10b098: 56 push %esi
10b099: 68 74 83 12 00 push $0x128374
10b09e: e8 39 1e 00 00 call 10cedc <_Objects_Get>
10b0a3: 89 c7 mov %eax,%edi
switch ( location ) {
10b0a5: 83 c4 10 add $0x10,%esp
10b0a8: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b0ac: 0f 85 3b 01 00 00 jne 10b1ed <rtems_rate_monotonic_period+0x168><== NEVER TAKEN
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
10b0b2: a1 8c 89 12 00 mov 0x12898c,%eax
10b0b7: 39 47 40 cmp %eax,0x40(%edi)
10b0ba: 74 0f je 10b0cb <rtems_rate_monotonic_period+0x46>
_Thread_Enable_dispatch();
10b0bc: e8 cd 28 00 00 call 10d98e <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
10b0c1: be 17 00 00 00 mov $0x17,%esi
10b0c6: e9 27 01 00 00 jmp 10b1f2 <rtems_rate_monotonic_period+0x16d>
}
if ( length == RTEMS_PERIOD_STATUS ) {
10b0cb: 85 db test %ebx,%ebx
10b0cd: 75 1b jne 10b0ea <rtems_rate_monotonic_period+0x65>
switch ( the_period->state ) {
10b0cf: 8b 47 38 mov 0x38(%edi),%eax
10b0d2: 31 f6 xor %esi,%esi
10b0d4: 83 f8 04 cmp $0x4,%eax
10b0d7: 77 07 ja 10b0e0 <rtems_rate_monotonic_period+0x5b><== NEVER TAKEN
10b0d9: 8b 34 85 8c 16 12 00 mov 0x12168c(,%eax,4),%esi
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
10b0e0: e8 a9 28 00 00 call 10d98e <_Thread_Enable_dispatch>
return( return_value );
10b0e5: e9 08 01 00 00 jmp 10b1f2 <rtems_rate_monotonic_period+0x16d>
}
_ISR_Disable( level );
10b0ea: 9c pushf
10b0eb: fa cli
10b0ec: 8f 45 d4 popl -0x2c(%ebp)
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
10b0ef: 8b 47 38 mov 0x38(%edi),%eax
10b0f2: 85 c0 test %eax,%eax
10b0f4: 75 4c jne 10b142 <rtems_rate_monotonic_period+0xbd>
_ISR_Enable( level );
10b0f6: ff 75 d4 pushl -0x2c(%ebp)
10b0f9: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10b0fa: 83 ec 0c sub $0xc,%esp
10b0fd: 57 push %edi
10b0fe: e8 3f fe ff ff call 10af42 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10b103: 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;
10b10a: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
the_watchdog->routine = routine;
10b111: c7 47 2c fc b3 10 00 movl $0x10b3fc,0x2c(%edi)
the_watchdog->id = id;
10b118: 89 77 30 mov %esi,0x30(%edi)
the_watchdog->user_data = user_data;
10b11b: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10b122: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b125: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b128: 58 pop %eax
10b129: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b12a: 83 c7 10 add $0x10,%edi
10b12d: 57 push %edi
10b12e: 68 28 85 12 00 push $0x128528
10b133: e8 68 35 00 00 call 10e6a0 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b138: e8 51 28 00 00 call 10d98e <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b13d: 83 c4 10 add $0x10,%esp
10b140: eb 65 jmp 10b1a7 <rtems_rate_monotonic_period+0x122>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
10b142: 83 f8 02 cmp $0x2,%eax
10b145: 75 64 jne 10b1ab <rtems_rate_monotonic_period+0x126>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10b147: 83 ec 0c sub $0xc,%esp
10b14a: 57 push %edi
10b14b: e8 5a fe ff ff call 10afaa <_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;
10b150: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi)
the_period->next_length = length;
10b157: 89 5f 3c mov %ebx,0x3c(%edi)
_ISR_Enable( level );
10b15a: ff 75 d4 pushl -0x2c(%ebp)
10b15d: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10b15e: a1 8c 89 12 00 mov 0x12898c,%eax
10b163: 8b 57 08 mov 0x8(%edi),%edx
10b166: 89 50 20 mov %edx,0x20(%eax)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b169: 5b pop %ebx
10b16a: 5e pop %esi
10b16b: 68 00 40 00 00 push $0x4000
10b170: 50 push %eax
10b171: e8 8a 2f 00 00 call 10e100 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10b176: 9c pushf
10b177: fa cli
10b178: 5a pop %edx
local_state = the_period->state;
10b179: 8b 47 38 mov 0x38(%edi),%eax
the_period->state = RATE_MONOTONIC_ACTIVE;
10b17c: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
_ISR_Enable( level );
10b183: 52 push %edx
10b184: 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 )
10b185: 83 c4 10 add $0x10,%esp
10b188: 83 f8 03 cmp $0x3,%eax
10b18b: 75 15 jne 10b1a2 <rtems_rate_monotonic_period+0x11d>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b18d: 51 push %ecx
10b18e: 51 push %ecx
10b18f: 68 00 40 00 00 push $0x4000
10b194: ff 35 8c 89 12 00 pushl 0x12898c
10b19a: e8 d9 24 00 00 call 10d678 <_Thread_Clear_state>
10b19f: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
10b1a2: e8 e7 27 00 00 call 10d98e <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b1a7: 31 f6 xor %esi,%esi
10b1a9: eb 47 jmp 10b1f2 <rtems_rate_monotonic_period+0x16d>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b1ab: be 04 00 00 00 mov $0x4,%esi
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
10b1b0: 83 f8 04 cmp $0x4,%eax
10b1b3: 75 3d jne 10b1f2 <rtems_rate_monotonic_period+0x16d><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10b1b5: 83 ec 0c sub $0xc,%esp
10b1b8: 57 push %edi
10b1b9: e8 ec fd ff ff call 10afaa <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10b1be: ff 75 d4 pushl -0x2c(%ebp)
10b1c1: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10b1c2: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
the_period->next_length = length;
10b1c9: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b1cc: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b1cf: 58 pop %eax
10b1d0: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b1d1: 83 c7 10 add $0x10,%edi
10b1d4: 57 push %edi
10b1d5: 68 28 85 12 00 push $0x128528
10b1da: e8 c1 34 00 00 call 10e6a0 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b1df: e8 aa 27 00 00 call 10d98e <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
10b1e4: 83 c4 10 add $0x10,%esp
10b1e7: 66 be 06 00 mov $0x6,%si
10b1eb: eb 05 jmp 10b1f2 <rtems_rate_monotonic_period+0x16d>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b1ed: be 04 00 00 00 mov $0x4,%esi
}
10b1f2: 89 f0 mov %esi,%eax
10b1f4: 8d 65 f4 lea -0xc(%ebp),%esp
10b1f7: 5b pop %ebx
10b1f8: 5e pop %esi
10b1f9: 5f pop %edi
10b1fa: c9 leave
10b1fb: c3 ret
0010b1fc <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10b1fc: 55 push %ebp
10b1fd: 89 e5 mov %esp,%ebp
10b1ff: 57 push %edi
10b200: 56 push %esi
10b201: 53 push %ebx
10b202: 83 ec 7c sub $0x7c,%esp
10b205: 8b 5d 08 mov 0x8(%ebp),%ebx
10b208: 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 )
10b20b: 85 ff test %edi,%edi
10b20d: 0f 84 2b 01 00 00 je 10b33e <rtems_rate_monotonic_report_statistics_with_plugin+0x142><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10b213: 52 push %edx
10b214: 52 push %edx
10b215: 68 a0 16 12 00 push $0x1216a0
10b21a: 53 push %ebx
10b21b: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
10b21d: 5e pop %esi
10b21e: 58 pop %eax
10b21f: 68 be 16 12 00 push $0x1216be
10b224: 53 push %ebx
10b225: ff d7 call *%edi
(*print)( context, "--- Wall times are in seconds ---\n" );
10b227: 5a pop %edx
10b228: 59 pop %ecx
10b229: 68 e0 16 12 00 push $0x1216e0
10b22e: 53 push %ebx
10b22f: ff d7 call *%edi
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
10b231: 5e pop %esi
10b232: 58 pop %eax
10b233: 68 03 17 12 00 push $0x121703
10b238: 53 push %ebx
10b239: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10b23b: 5a pop %edx
10b23c: 59 pop %ecx
10b23d: 68 4e 17 12 00 push $0x12174e
10b242: 53 push %ebx
10b243: 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 ;
10b245: 8b 35 7c 83 12 00 mov 0x12837c,%esi
10b24b: 83 c4 10 add $0x10,%esp
10b24e: e9 df 00 00 00 jmp 10b332 <rtems_rate_monotonic_report_statistics_with_plugin+0x136>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10b253: 50 push %eax
10b254: 50 push %eax
10b255: 8d 45 88 lea -0x78(%ebp),%eax
10b258: 50 push %eax
10b259: 56 push %esi
10b25a: e8 c1 56 00 00 call 110920 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10b25f: 83 c4 10 add $0x10,%esp
10b262: 85 c0 test %eax,%eax
10b264: 0f 85 c7 00 00 00 jne 10b331 <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 );
10b26a: 51 push %ecx
10b26b: 51 push %ecx
10b26c: 8d 55 c0 lea -0x40(%ebp),%edx
10b26f: 52 push %edx
10b270: 56 push %esi
10b271: e8 4e 57 00 00 call 1109c4 <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
10b276: 83 c4 0c add $0xc,%esp
10b279: 8d 45 e3 lea -0x1d(%ebp),%eax
10b27c: 50 push %eax
10b27d: 6a 05 push $0x5
10b27f: ff 75 c0 pushl -0x40(%ebp)
10b282: e8 01 02 00 00 call 10b488 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10b287: 58 pop %eax
10b288: 5a pop %edx
10b289: ff 75 8c pushl -0x74(%ebp)
10b28c: ff 75 88 pushl -0x78(%ebp)
10b28f: 8d 55 e3 lea -0x1d(%ebp),%edx
10b292: 52 push %edx
10b293: 56 push %esi
10b294: 68 9a 17 12 00 push $0x12179a
10b299: 53 push %ebx
10b29a: ff d7 call *%edi
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10b29c: 8b 45 88 mov -0x78(%ebp),%eax
10b29f: 83 c4 20 add $0x20,%esp
10b2a2: 85 c0 test %eax,%eax
10b2a4: 75 0f jne 10b2b5 <rtems_rate_monotonic_report_statistics_with_plugin+0xb9>
(*print)( context, "\n" );
10b2a6: 51 push %ecx
10b2a7: 51 push %ecx
10b2a8: 68 04 1a 12 00 push $0x121a04
10b2ad: 53 push %ebx
10b2ae: ff d7 call *%edi
continue;
10b2b0: 83 c4 10 add $0x10,%esp
10b2b3: eb 7c jmp 10b331 <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 );
10b2b5: 52 push %edx
10b2b6: 8d 55 d8 lea -0x28(%ebp),%edx
10b2b9: 52 push %edx
10b2ba: 50 push %eax
10b2bb: 8d 45 a0 lea -0x60(%ebp),%eax
10b2be: 50 push %eax
10b2bf: e8 b0 30 00 00 call 10e374 <_Timespec_Divide_by_integer>
(*print)( context,
10b2c4: 8b 45 dc mov -0x24(%ebp),%eax
10b2c7: b9 e8 03 00 00 mov $0x3e8,%ecx
10b2cc: 99 cltd
10b2cd: f7 f9 idiv %ecx
10b2cf: 50 push %eax
10b2d0: ff 75 d8 pushl -0x28(%ebp)
10b2d3: 8b 45 9c mov -0x64(%ebp),%eax
10b2d6: 99 cltd
10b2d7: f7 f9 idiv %ecx
10b2d9: 50 push %eax
10b2da: ff 75 98 pushl -0x68(%ebp)
10b2dd: 8b 45 94 mov -0x6c(%ebp),%eax
10b2e0: 99 cltd
10b2e1: f7 f9 idiv %ecx
10b2e3: 50 push %eax
10b2e4: ff 75 90 pushl -0x70(%ebp)
10b2e7: 68 b1 17 12 00 push $0x1217b1
10b2ec: 53 push %ebx
10b2ed: 89 4d 84 mov %ecx,-0x7c(%ebp)
10b2f0: 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);
10b2f2: 83 c4 2c add $0x2c,%esp
10b2f5: 8d 55 d8 lea -0x28(%ebp),%edx
10b2f8: 52 push %edx
10b2f9: 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;
10b2fc: 8d 45 b8 lea -0x48(%ebp),%eax
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
10b2ff: 50 push %eax
10b300: e8 6f 30 00 00 call 10e374 <_Timespec_Divide_by_integer>
(*print)( context,
10b305: 8b 45 dc mov -0x24(%ebp),%eax
10b308: 8b 4d 84 mov -0x7c(%ebp),%ecx
10b30b: 99 cltd
10b30c: f7 f9 idiv %ecx
10b30e: 50 push %eax
10b30f: ff 75 d8 pushl -0x28(%ebp)
10b312: 8b 45 b4 mov -0x4c(%ebp),%eax
10b315: 99 cltd
10b316: f7 f9 idiv %ecx
10b318: 50 push %eax
10b319: ff 75 b0 pushl -0x50(%ebp)
10b31c: 8b 45 ac mov -0x54(%ebp),%eax
10b31f: 99 cltd
10b320: f7 f9 idiv %ecx
10b322: 50 push %eax
10b323: ff 75 a8 pushl -0x58(%ebp)
10b326: 68 d0 17 12 00 push $0x1217d0
10b32b: 53 push %ebx
10b32c: ff d7 call *%edi
10b32e: 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++ ) {
10b331: 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 ;
10b332: 3b 35 80 83 12 00 cmp 0x128380,%esi
10b338: 0f 86 15 ff ff ff jbe 10b253 <rtems_rate_monotonic_report_statistics_with_plugin+0x57>
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
10b33e: 8d 65 f4 lea -0xc(%ebp),%esp
10b341: 5b pop %ebx
10b342: 5e pop %esi
10b343: 5f pop %edi
10b344: c9 leave
10b345: c3 ret
00115ba0 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
115ba0: 55 push %ebp
115ba1: 89 e5 mov %esp,%ebp
115ba3: 53 push %ebx
115ba4: 83 ec 14 sub $0x14,%esp
115ba7: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
115baa: 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 )
115baf: 85 db test %ebx,%ebx
115bb1: 74 6d je 115c20 <rtems_signal_send+0x80>
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
115bb3: 50 push %eax
115bb4: 50 push %eax
115bb5: 8d 45 f4 lea -0xc(%ebp),%eax
115bb8: 50 push %eax
115bb9: ff 75 08 pushl 0x8(%ebp)
115bbc: e8 5f 3a 00 00 call 119620 <_Thread_Get>
switch ( location ) {
115bc1: 83 c4 10 add $0x10,%esp
115bc4: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
115bc8: 75 51 jne 115c1b <rtems_signal_send+0x7b>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
115bca: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
115bd0: 83 7a 0c 00 cmpl $0x0,0xc(%edx)
115bd4: 74 39 je 115c0f <rtems_signal_send+0x6f>
if ( asr->is_enabled ) {
115bd6: 80 7a 08 00 cmpb $0x0,0x8(%edx)
115bda: 74 22 je 115bfe <rtems_signal_send+0x5e>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115bdc: 9c pushf
115bdd: fa cli
115bde: 59 pop %ecx
*signal_set |= signals;
115bdf: 09 5a 14 or %ebx,0x14(%edx)
_ISR_Enable( _level );
115be2: 51 push %ecx
115be3: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
115be4: 83 3d 00 f5 13 00 00 cmpl $0x0,0x13f500
115beb: 74 19 je 115c06 <rtems_signal_send+0x66>
115bed: 3b 05 04 f5 13 00 cmp 0x13f504,%eax
115bf3: 75 11 jne 115c06 <rtems_signal_send+0x66><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
115bf5: c6 05 10 f5 13 00 01 movb $0x1,0x13f510
115bfc: eb 08 jmp 115c06 <rtems_signal_send+0x66>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115bfe: 9c pushf
115bff: fa cli
115c00: 58 pop %eax
*signal_set |= signals;
115c01: 09 5a 18 or %ebx,0x18(%edx)
_ISR_Enable( _level );
115c04: 50 push %eax
115c05: 9d popf
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
115c06: e8 f3 39 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115c0b: 31 c0 xor %eax,%eax
115c0d: eb 11 jmp 115c20 <rtems_signal_send+0x80>
}
_Thread_Enable_dispatch();
115c0f: e8 ea 39 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
115c14: b8 0b 00 00 00 mov $0xb,%eax
115c19: eb 05 jmp 115c20 <rtems_signal_send+0x80>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115c1b: b8 04 00 00 00 mov $0x4,%eax
}
115c20: 8b 5d fc mov -0x4(%ebp),%ebx
115c23: c9 leave
115c24: c3 ret
001072f4 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
1072f4: 55 push %ebp
1072f5: 89 e5 mov %esp,%ebp
1072f7: 57 push %edi
1072f8: 56 push %esi
1072f9: 8b 45 08 mov 0x8(%ebp),%eax
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
1072fc: 83 78 08 00 cmpl $0x0,0x8(%eax)
107300: 74 15 je 107317 <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;
107302: 8b b8 bc 00 00 00 mov 0xbc(%eax),%edi
107308: 83 c7 08 add $0x8,%edi
10730b: be 28 72 12 00 mov $0x127228,%esi
107310: b9 04 00 00 00 mov $0x4,%ecx
107315: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
107317: 5e pop %esi
107318: 5f pop %edi
107319: c9 leave
10731a: c3 ret
001072cd <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
1072cd: 55 push %ebp
1072ce: 89 e5 mov %esp,%ebp
1072d0: 57 push %edi
1072d1: 8b 7d 0c mov 0xc(%ebp),%edi
Stack_check_Initialize();
1072d4: e8 8a ff ff ff call 107263 <Stack_check_Initialize>
if (the_thread)
1072d9: 85 ff test %edi,%edi
1072db: 74 12 je 1072ef <rtems_stack_checker_create_extension+0x22><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
1072dd: 8b 8f b8 00 00 00 mov 0xb8(%edi),%ecx
1072e3: 8b 97 bc 00 00 00 mov 0xbc(%edi),%edx
1072e9: b0 a5 mov $0xa5,%al
1072eb: 89 d7 mov %edx,%edi
1072ed: f3 aa rep stos %al,%es:(%edi)
return true;
}
1072ef: b0 01 mov $0x1,%al
1072f1: 5f pop %edi
1072f2: c9 leave
1072f3: c3 ret
00107428 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
107428: 55 push %ebp
107429: 89 e5 mov %esp,%ebp
10742b: 53 push %ebx
10742c: 83 ec 04 sub $0x4,%esp
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
10742f: a1 1c 79 12 00 mov 0x12791c,%eax
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
107434: 8b 90 bc 00 00 00 mov 0xbc(%eax),%edx
return false;
10743a: 31 db xor %ebx,%ebx
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
10743c: 39 d5 cmp %edx,%ebp
10743e: 72 0e jb 10744e <rtems_stack_checker_is_blown+0x26><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
107440: 8b 80 b8 00 00 00 mov 0xb8(%eax),%eax
107446: 8d 04 02 lea (%edx,%eax,1),%eax
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
107449: 39 c5 cmp %eax,%ebp
10744b: 0f 96 c3 setbe %bl
{
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
bool sp_ok;
bool pattern_ok = true;
10744e: b0 01 mov $0x1,%al
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
107450: 83 3d 18 6f 12 00 00 cmpl $0x0,0x126f18
107457: 74 19 je 107472 <rtems_stack_checker_is_blown+0x4a><== NEVER TAKEN
pattern_ok = (!memcmp(
107459: 83 c2 08 add $0x8,%edx
10745c: 51 push %ecx
10745d: 6a 10 push $0x10
10745f: 68 28 72 12 00 push $0x127228
107464: 52 push %edx
107465: e8 4a cb 00 00 call 113fb4 <memcmp>
10746a: 83 c4 10 add $0x10,%esp
10746d: 85 c0 test %eax,%eax
10746f: 0f 94 c0 sete %al
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
107472: 84 db test %bl,%bl
107474: 74 04 je 10747a <rtems_stack_checker_is_blown+0x52><== NEVER TAKEN
107476: 84 c0 test %al,%al
107478: 75 11 jne 10748b <rtems_stack_checker_is_blown+0x63><== ALWAYS TAKEN
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
10747a: 52 push %edx <== NOT EXECUTED
10747b: 52 push %edx <== NOT EXECUTED
10747c: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
10747f: 50 push %eax <== NOT EXECUTED
107480: ff 35 1c 79 12 00 pushl 0x12791c <== NOT EXECUTED
107486: e8 90 fe ff ff call 10731b <Stack_check_report_blown_task><== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
10748b: 31 c0 xor %eax,%eax
10748d: 8b 5d fc mov -0x4(%ebp),%ebx
107490: c9 leave
107491: c3 ret
001074f7 <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
1074f7: 55 push %ebp <== NOT EXECUTED
1074f8: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1074fa: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
1074fd: 68 80 8c 10 00 push $0x108c80 <== NOT EXECUTED
107502: 6a 00 push $0x0 <== NOT EXECUTED
107504: e8 89 ff ff ff call 107492 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
107509: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
10750c: c9 leave <== NOT EXECUTED
10750d: c3 ret <== NOT EXECUTED
00107492 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
107492: 55 push %ebp <== NOT EXECUTED
107493: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107495: 56 push %esi <== NOT EXECUTED
107496: 53 push %ebx <== NOT EXECUTED
107497: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
10749a: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
if ( !print )
10749d: 85 db test %ebx,%ebx <== NOT EXECUTED
10749f: 74 4f je 1074f0 <rtems_stack_checker_report_usage_with_plugin+0x5e><== NOT EXECUTED
return;
print_context = context;
1074a1: 89 35 10 6f 12 00 mov %esi,0x126f10 <== NOT EXECUTED
print_handler = print;
1074a7: 89 1d 14 6f 12 00 mov %ebx,0x126f14 <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
1074ad: 51 push %ecx <== NOT EXECUTED
1074ae: 51 push %ecx <== NOT EXECUTED
1074af: 68 73 17 12 00 push $0x121773 <== NOT EXECUTED
1074b4: 56 push %esi <== NOT EXECUTED
1074b5: ff d3 call *%ebx <== NOT EXECUTED
(*print)( context,
1074b7: 58 pop %eax <== NOT EXECUTED
1074b8: 5a pop %edx <== NOT EXECUTED
1074b9: 68 8a 17 12 00 push $0x12178a <== NOT EXECUTED
1074be: 56 push %esi <== NOT EXECUTED
1074bf: 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 );
1074c1: c7 04 24 48 71 10 00 movl $0x107148,(%esp) <== NOT EXECUTED
1074c8: e8 fb 63 00 00 call 10d8c8 <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);
1074cd: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED
1074d4: e8 6f fc ff ff call 107148 <Stack_check_Dump_threads_usage><== NOT EXECUTED
#endif
print_context = NULL;
1074d9: c7 05 10 6f 12 00 00 movl $0x0,0x126f10 <== NOT EXECUTED
1074e0: 00 00 00
print_handler = NULL;
1074e3: c7 05 14 6f 12 00 00 movl $0x0,0x126f14 <== NOT EXECUTED
1074ea: 00 00 00
1074ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1074f0: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
1074f3: 5b pop %ebx <== NOT EXECUTED
1074f4: 5e pop %esi <== NOT EXECUTED
1074f5: c9 leave <== NOT EXECUTED
1074f6: c3 ret <== NOT EXECUTED
001073cf <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
1073cf: 55 push %ebp
1073d0: 89 e5 mov %esp,%ebp
1073d2: 53 push %ebx
1073d3: 83 ec 14 sub $0x14,%esp
1073d6: 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);
1073d9: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax
1073df: 8d 48 08 lea 0x8(%eax),%ecx
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
1073e2: 31 d2 xor %edx,%edx
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
1073e4: 39 c5 cmp %eax,%ebp
1073e6: 72 0b jb 1073f3 <rtems_stack_checker_switch_extension+0x24><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
1073e8: 03 83 b8 00 00 00 add 0xb8(%ebx),%eax
}
/*
* rtems_stack_checker_switch_extension
*/
void rtems_stack_checker_switch_extension(
1073ee: 39 c5 cmp %eax,%ebp
1073f0: 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,
1073f3: 50 push %eax
1073f4: 6a 10 push $0x10
1073f6: 68 28 72 12 00 push $0x127228
1073fb: 51 push %ecx
1073fc: 88 55 f4 mov %dl,-0xc(%ebp)
1073ff: e8 b0 cb 00 00 call 113fb4 <memcmp>
107404: 83 c4 10 add $0x10,%esp
107407: 85 c0 test %eax,%eax
107409: 0f 94 c0 sete %al
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
10740c: 8a 55 f4 mov -0xc(%ebp),%dl
10740f: 84 d2 test %dl,%dl
107411: 74 04 je 107417 <rtems_stack_checker_switch_extension+0x48><== NEVER TAKEN
107413: 84 c0 test %al,%al
107415: 75 0c jne 107423 <rtems_stack_checker_switch_extension+0x54><== ALWAYS TAKEN
Stack_check_report_blown_task( running, pattern_ok );
107417: 52 push %edx <== NOT EXECUTED
107418: 52 push %edx <== NOT EXECUTED
107419: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
10741c: 50 push %eax <== NOT EXECUTED
10741d: 53 push %ebx <== NOT EXECUTED
10741e: e8 f8 fe ff ff call 10731b <Stack_check_report_blown_task><== NOT EXECUTED
}
}
107423: 8b 5d fc mov -0x4(%ebp),%ebx
107426: c9 leave
107427: c3 ret
0010f070 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
10f070: 55 push %ebp
10f071: 89 e5 mov %esp,%ebp
10f073: 57 push %edi
10f074: 56 push %esi
10f075: 53 push %ebx
10f076: 83 ec 2c sub $0x2c,%esp
10f079: 8b 75 08 mov 0x8(%ebp),%esi
10f07c: 8b 5d 0c mov 0xc(%ebp),%ebx
10f07f: 8b 7d 10 mov 0x10(%ebp),%edi
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f082: ba 09 00 00 00 mov $0x9,%edx
)
{
double result;
char *end;
if ( !n )
10f087: 85 db test %ebx,%ebx
10f089: 0f 84 95 00 00 00 je 10f124 <rtems_string_to_double+0xb4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f08f: e8 54 2a 00 00 call 111ae8 <__errno>
10f094: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f09a: c7 03 00 00 00 00 movl $0x0,(%ebx)
10f0a0: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
result = strtod( s, &end );
10f0a7: 50 push %eax
10f0a8: 50 push %eax
10f0a9: 8d 45 e4 lea -0x1c(%ebp),%eax
10f0ac: 50 push %eax
10f0ad: 56 push %esi
10f0ae: e8 e5 54 00 00 call 114598 <strtod>
if ( endptr )
10f0b3: 83 c4 10 add $0x10,%esp
10f0b6: 85 ff test %edi,%edi
10f0b8: 74 05 je 10f0bf <rtems_string_to_double+0x4f>
*endptr = end;
10f0ba: 8b 45 e4 mov -0x1c(%ebp),%eax
10f0bd: 89 07 mov %eax,(%edi)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f0bf: ba 0b 00 00 00 mov $0xb,%edx
result = strtod( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
10f0c4: 39 75 e4 cmp %esi,-0x1c(%ebp)
10f0c7: 74 4d je 10f116 <rtems_string_to_double+0xa6>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f0c9: dd 5d c8 fstpl -0x38(%ebp)
10f0cc: e8 17 2a 00 00 call 111ae8 <__errno>
10f0d1: 83 38 22 cmpl $0x22,(%eax)
10f0d4: dd 45 c8 fldl -0x38(%ebp)
10f0d7: 75 37 jne 10f110 <rtems_string_to_double+0xa0>
10f0d9: d9 ee fldz
10f0db: d9 c9 fxch %st(1)
10f0dd: dd e1 fucom %st(1)
10f0df: df e0 fnstsw %ax
10f0e1: dd d9 fstp %st(1)
10f0e3: 9e sahf
10f0e4: 7a 07 jp 10f0ed <rtems_string_to_double+0x7d><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
10f0e6: ba 0a 00 00 00 mov $0xa,%edx
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f0eb: 74 2d je 10f11a <rtems_string_to_double+0xaa><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
10f0ed: 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 )))
10f0f2: dd 05 30 3e 12 00 fldl 0x123e30
10f0f8: d9 c9 fxch %st(1)
10f0fa: dd e1 fucom %st(1)
10f0fc: df e0 fnstsw %ax
10f0fe: dd d9 fstp %st(1)
10f100: 9e sahf
10f101: 77 1b ja 10f11e <rtems_string_to_double+0xae><== ALWAYS TAKEN
10f103: dd 05 38 3e 12 00 fldl 0x123e38 <== NOT EXECUTED
10f109: dd e9 fucomp %st(1) <== NOT EXECUTED
10f10b: df e0 fnstsw %ax <== NOT EXECUTED
10f10d: 9e sahf <== NOT EXECUTED
10f10e: 77 12 ja 10f122 <rtems_string_to_double+0xb2><== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
*n = result;
10f110: dd 1b fstpl (%ebx)
return RTEMS_SUCCESSFUL;
10f112: 31 d2 xor %edx,%edx
10f114: eb 0e jmp 10f124 <rtems_string_to_double+0xb4>
10f116: dd d8 fstp %st(0)
10f118: eb 0a jmp 10f124 <rtems_string_to_double+0xb4>
10f11a: dd d8 fstp %st(0) <== NOT EXECUTED
10f11c: eb 06 jmp 10f124 <rtems_string_to_double+0xb4><== NOT EXECUTED
10f11e: dd d8 fstp %st(0)
10f120: eb 02 jmp 10f124 <rtems_string_to_double+0xb4>
10f122: dd d8 fstp %st(0) <== NOT EXECUTED
}
10f124: 89 d0 mov %edx,%eax
10f126: 8d 65 f4 lea -0xc(%ebp),%esp
10f129: 5b pop %ebx
10f12a: 5e pop %esi
10f12b: 5f pop %edi
10f12c: c9 leave
10f12d: c3 ret
0010f130 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
10f130: 55 push %ebp
10f131: 89 e5 mov %esp,%ebp
10f133: 57 push %edi
10f134: 56 push %esi
10f135: 53 push %ebx
10f136: 83 ec 2c sub $0x2c,%esp
10f139: 8b 75 08 mov 0x8(%ebp),%esi
10f13c: 8b 5d 0c mov 0xc(%ebp),%ebx
10f13f: 8b 7d 10 mov 0x10(%ebp),%edi
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f142: ba 09 00 00 00 mov $0x9,%edx
)
{
float result;
char *end;
if ( !n )
10f147: 85 db test %ebx,%ebx
10f149: 0f 84 8e 00 00 00 je 10f1dd <rtems_string_to_float+0xad>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f14f: e8 94 29 00 00 call 111ae8 <__errno>
10f154: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f15a: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtof( s, &end );
10f160: 50 push %eax
10f161: 50 push %eax
10f162: 8d 45 e4 lea -0x1c(%ebp),%eax
10f165: 50 push %eax
10f166: 56 push %esi
10f167: e8 48 54 00 00 call 1145b4 <strtof>
if ( endptr )
10f16c: 83 c4 10 add $0x10,%esp
10f16f: 85 ff test %edi,%edi
10f171: 74 05 je 10f178 <rtems_string_to_float+0x48>
*endptr = end;
10f173: 8b 45 e4 mov -0x1c(%ebp),%eax
10f176: 89 07 mov %eax,(%edi)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f178: ba 0b 00 00 00 mov $0xb,%edx
result = strtof( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
10f17d: 39 75 e4 cmp %esi,-0x1c(%ebp)
10f180: 74 4d je 10f1cf <rtems_string_to_float+0x9f>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f182: d9 5d c8 fstps -0x38(%ebp)
10f185: e8 5e 29 00 00 call 111ae8 <__errno>
10f18a: 83 38 22 cmpl $0x22,(%eax)
10f18d: d9 45 c8 flds -0x38(%ebp)
10f190: 75 37 jne 10f1c9 <rtems_string_to_float+0x99>
10f192: d9 ee fldz
10f194: d9 c9 fxch %st(1)
10f196: dd e1 fucom %st(1)
10f198: df e0 fnstsw %ax
10f19a: dd d9 fstp %st(1)
10f19c: 9e sahf
10f19d: 7a 07 jp 10f1a6 <rtems_string_to_float+0x76><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
10f19f: ba 0a 00 00 00 mov $0xa,%edx
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f1a4: 74 2d je 10f1d3 <rtems_string_to_float+0xa3><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
10f1a6: 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 )))
10f1ab: d9 05 40 3e 12 00 flds 0x123e40
10f1b1: d9 c9 fxch %st(1)
10f1b3: dd e1 fucom %st(1)
10f1b5: df e0 fnstsw %ax
10f1b7: dd d9 fstp %st(1)
10f1b9: 9e sahf
10f1ba: 77 1b ja 10f1d7 <rtems_string_to_float+0xa7><== ALWAYS TAKEN
10f1bc: d9 05 44 3e 12 00 flds 0x123e44 <== NOT EXECUTED
10f1c2: dd e9 fucomp %st(1) <== NOT EXECUTED
10f1c4: df e0 fnstsw %ax <== NOT EXECUTED
10f1c6: 9e sahf <== NOT EXECUTED
10f1c7: 77 12 ja 10f1db <rtems_string_to_float+0xab><== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
*n = result;
10f1c9: d9 1b fstps (%ebx)
return RTEMS_SUCCESSFUL;
10f1cb: 31 d2 xor %edx,%edx
10f1cd: eb 0e jmp 10f1dd <rtems_string_to_float+0xad>
10f1cf: dd d8 fstp %st(0)
10f1d1: eb 0a jmp 10f1dd <rtems_string_to_float+0xad>
10f1d3: dd d8 fstp %st(0) <== NOT EXECUTED
10f1d5: eb 06 jmp 10f1dd <rtems_string_to_float+0xad><== NOT EXECUTED
10f1d7: dd d8 fstp %st(0)
10f1d9: eb 02 jmp 10f1dd <rtems_string_to_float+0xad>
10f1db: dd d8 fstp %st(0) <== NOT EXECUTED
}
10f1dd: 89 d0 mov %edx,%eax
10f1df: 8d 65 f4 lea -0xc(%ebp),%esp
10f1e2: 5b pop %ebx
10f1e3: 5e pop %esi
10f1e4: 5f pop %edi
10f1e5: c9 leave
10f1e6: c3 ret
0010f1e8 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
10f1e8: 55 push %ebp
10f1e9: 89 e5 mov %esp,%ebp
10f1eb: 57 push %edi
10f1ec: 56 push %esi
10f1ed: 53 push %ebx
10f1ee: 83 ec 2c sub $0x2c,%esp
10f1f1: 8b 7d 08 mov 0x8(%ebp),%edi
10f1f4: 8b 75 0c mov 0xc(%ebp),%esi
10f1f7: 8b 55 10 mov 0x10(%ebp),%edx
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f1fa: b8 09 00 00 00 mov $0x9,%eax
)
{
long result;
char *end;
if ( !n )
10f1ff: 85 f6 test %esi,%esi
10f201: 74 6b je 10f26e <rtems_string_to_int+0x86>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f203: 89 55 d4 mov %edx,-0x2c(%ebp)
10f206: e8 dd 28 00 00 call 111ae8 <__errno>
10f20b: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f211: c7 06 00 00 00 00 movl $0x0,(%esi)
result = strtol( s, &end, base );
10f217: 50 push %eax
10f218: ff 75 14 pushl 0x14(%ebp)
10f21b: 8d 45 e4 lea -0x1c(%ebp),%eax
10f21e: 50 push %eax
10f21f: 57 push %edi
10f220: e8 4f 55 00 00 call 114774 <strtol>
10f225: 89 c3 mov %eax,%ebx
if ( endptr )
10f227: 83 c4 10 add $0x10,%esp
10f22a: 8b 55 d4 mov -0x2c(%ebp),%edx
10f22d: 85 d2 test %edx,%edx
10f22f: 74 05 je 10f236 <rtems_string_to_int+0x4e>
*endptr = end;
10f231: 8b 45 e4 mov -0x1c(%ebp),%eax
10f234: 89 02 mov %eax,(%edx)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f236: b8 0b 00 00 00 mov $0xb,%eax
result = strtol( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
10f23b: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f23e: 74 2e je 10f26e <rtems_string_to_int+0x86>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f240: e8 a3 28 00 00 call 111ae8 <__errno>
10f245: 83 38 22 cmpl $0x22,(%eax)
10f248: 75 19 jne 10f263 <rtems_string_to_int+0x7b>
10f24a: 81 fb ff ff ff 7f cmp $0x7fffffff,%ebx
10f250: 74 17 je 10f269 <rtems_string_to_int+0x81><== ALWAYS TAKEN
10f252: 85 db test %ebx,%ebx <== NOT EXECUTED
10f254: 74 13 je 10f269 <rtems_string_to_int+0x81><== NOT EXECUTED
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
10f256: 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 )))
10f25b: 81 fb 00 00 00 80 cmp $0x80000000,%ebx <== NOT EXECUTED
10f261: 74 0b je 10f26e <rtems_string_to_int+0x86><== NOT EXECUTED
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
10f263: 89 1e mov %ebx,(%esi)
return RTEMS_SUCCESSFUL;
10f265: 31 c0 xor %eax,%eax
10f267: eb 05 jmp 10f26e <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;
10f269: b8 0a 00 00 00 mov $0xa,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
10f26e: 8d 65 f4 lea -0xc(%ebp),%esp
10f271: 5b pop %ebx
10f272: 5e pop %esi
10f273: 5f pop %edi
10f274: c9 leave
10f275: c3 ret
0010f324 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
10f324: 55 push %ebp
10f325: 89 e5 mov %esp,%ebp
10f327: 57 push %edi
10f328: 56 push %esi
10f329: 53 push %ebx
10f32a: 83 ec 2c sub $0x2c,%esp
10f32d: 8b 7d 08 mov 0x8(%ebp),%edi
10f330: 8b 75 0c mov 0xc(%ebp),%esi
10f333: 8b 55 10 mov 0x10(%ebp),%edx
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f336: b8 09 00 00 00 mov $0x9,%eax
)
{
long result;
char *end;
if ( !n )
10f33b: 85 f6 test %esi,%esi
10f33d: 74 6b je 10f3aa <rtems_string_to_long+0x86>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f33f: 89 55 d4 mov %edx,-0x2c(%ebp)
10f342: e8 a1 27 00 00 call 111ae8 <__errno>
10f347: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f34d: c7 06 00 00 00 00 movl $0x0,(%esi)
result = strtol( s, &end, base );
10f353: 50 push %eax
10f354: ff 75 14 pushl 0x14(%ebp)
10f357: 8d 45 e4 lea -0x1c(%ebp),%eax
10f35a: 50 push %eax
10f35b: 57 push %edi
10f35c: e8 13 54 00 00 call 114774 <strtol>
10f361: 89 c3 mov %eax,%ebx
if ( endptr )
10f363: 83 c4 10 add $0x10,%esp
10f366: 8b 55 d4 mov -0x2c(%ebp),%edx
10f369: 85 d2 test %edx,%edx
10f36b: 74 05 je 10f372 <rtems_string_to_long+0x4e>
*endptr = end;
10f36d: 8b 45 e4 mov -0x1c(%ebp),%eax
10f370: 89 02 mov %eax,(%edx)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f372: b8 0b 00 00 00 mov $0xb,%eax
result = strtol( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
10f377: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f37a: 74 2e je 10f3aa <rtems_string_to_long+0x86>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f37c: e8 67 27 00 00 call 111ae8 <__errno>
10f381: 83 38 22 cmpl $0x22,(%eax)
10f384: 75 19 jne 10f39f <rtems_string_to_long+0x7b>
10f386: 81 fb ff ff ff 7f cmp $0x7fffffff,%ebx
10f38c: 74 17 je 10f3a5 <rtems_string_to_long+0x81>
10f38e: 85 db test %ebx,%ebx
10f390: 74 13 je 10f3a5 <rtems_string_to_long+0x81><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
10f392: 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 )))
10f397: 81 fb 00 00 00 80 cmp $0x80000000,%ebx
10f39d: 74 0b je 10f3aa <rtems_string_to_long+0x86><== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
10f39f: 89 1e mov %ebx,(%esi)
return RTEMS_SUCCESSFUL;
10f3a1: 31 c0 xor %eax,%eax
10f3a3: eb 05 jmp 10f3aa <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;
10f3a5: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
10f3aa: 8d 65 f4 lea -0xc(%ebp),%esp
10f3ad: 5b pop %ebx
10f3ae: 5e pop %esi
10f3af: 5f pop %edi
10f3b0: c9 leave
10f3b1: c3 ret
0010f278 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
10f278: 55 push %ebp
10f279: 89 e5 mov %esp,%ebp
10f27b: 57 push %edi
10f27c: 56 push %esi
10f27d: 53 push %ebx
10f27e: 83 ec 2c sub $0x2c,%esp
10f281: 8b 5d 0c mov 0xc(%ebp),%ebx
10f284: 8b 7d 10 mov 0x10(%ebp),%edi
long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f287: b8 09 00 00 00 mov $0x9,%eax
)
{
long long result;
char *end;
if ( !n )
10f28c: 85 db test %ebx,%ebx
10f28e: 0f 84 85 00 00 00 je 10f319 <rtems_string_to_long_long+0xa1>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f294: e8 4f 28 00 00 call 111ae8 <__errno>
10f299: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f29f: c7 03 00 00 00 00 movl $0x0,(%ebx)
10f2a5: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
result = strtoll( s, &end, base );
10f2ac: 50 push %eax
10f2ad: ff 75 14 pushl 0x14(%ebp)
10f2b0: 8d 45 e4 lea -0x1c(%ebp),%eax
10f2b3: 50 push %eax
10f2b4: ff 75 08 pushl 0x8(%ebp)
10f2b7: e8 d4 54 00 00 call 114790 <strtoll>
10f2bc: 89 c6 mov %eax,%esi
if ( endptr )
10f2be: 83 c4 10 add $0x10,%esp
10f2c1: 85 ff test %edi,%edi
10f2c3: 74 05 je 10f2ca <rtems_string_to_long_long+0x52>
*endptr = end;
10f2c5: 8b 45 e4 mov -0x1c(%ebp),%eax
10f2c8: 89 07 mov %eax,(%edi)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f2ca: b8 0b 00 00 00 mov $0xb,%eax
result = strtoll( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
10f2cf: 8b 4d 08 mov 0x8(%ebp),%ecx
10f2d2: 39 4d e4 cmp %ecx,-0x1c(%ebp)
10f2d5: 74 42 je 10f319 <rtems_string_to_long_long+0xa1>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f2d7: 89 55 d4 mov %edx,-0x2c(%ebp)
10f2da: e8 09 28 00 00 call 111ae8 <__errno>
10f2df: 83 38 22 cmpl $0x22,(%eax)
10f2e2: 8b 55 d4 mov -0x2c(%ebp),%edx
10f2e5: 75 24 jne 10f30b <rtems_string_to_long_long+0x93>
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
10f2e7: 89 f1 mov %esi,%ecx
10f2e9: f7 d1 not %ecx
10f2eb: 89 d0 mov %edx,%eax
10f2ed: 35 ff ff ff 7f xor $0x7fffffff,%eax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f2f2: 09 c1 or %eax,%ecx
10f2f4: 74 1e je 10f314 <rtems_string_to_long_long+0x9c>
10f2f6: 89 f0 mov %esi,%eax
10f2f8: 09 d0 or %edx,%eax
10f2fa: 74 18 je 10f314 <rtems_string_to_long_long+0x9c><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
10f2fc: 8d 8a 00 00 00 80 lea -0x80000000(%edx),%ecx
return RTEMS_INVALID_NUMBER;
10f302: 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 )))
10f307: 09 f1 or %esi,%ecx
10f309: 74 0e je 10f319 <rtems_string_to_long_long+0xa1><== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
10f30b: 89 33 mov %esi,(%ebx)
10f30d: 89 53 04 mov %edx,0x4(%ebx)
return RTEMS_SUCCESSFUL;
10f310: 31 c0 xor %eax,%eax
10f312: eb 05 jmp 10f319 <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;
10f314: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
10f319: 8d 65 f4 lea -0xc(%ebp),%esp
10f31c: 5b pop %ebx
10f31d: 5e pop %esi
10f31e: 5f pop %edi
10f31f: c9 leave
10f320: c3 ret
0010f3cc <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
10f3cc: 55 push %ebp
10f3cd: 89 e5 mov %esp,%ebp
10f3cf: 57 push %edi
10f3d0: 56 push %esi
10f3d1: 53 push %ebx
10f3d2: 83 ec 2c sub $0x2c,%esp
10f3d5: 8b 7d 08 mov 0x8(%ebp),%edi
10f3d8: 8b 5d 0c mov 0xc(%ebp),%ebx
10f3db: 8b 55 10 mov 0x10(%ebp),%edx
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f3de: b8 09 00 00 00 mov $0x9,%eax
)
{
unsigned long result;
char *end;
if ( !n )
10f3e3: 85 db test %ebx,%ebx
10f3e5: 74 71 je 10f458 <rtems_string_to_unsigned_char+0x8c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f3e7: 89 55 d4 mov %edx,-0x2c(%ebp)
10f3ea: e8 f9 26 00 00 call 111ae8 <__errno>
10f3ef: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f3f5: c6 03 00 movb $0x0,(%ebx)
result = strtoul( s, &end, base );
10f3f8: 50 push %eax
10f3f9: ff 75 14 pushl 0x14(%ebp)
10f3fc: 8d 45 e4 lea -0x1c(%ebp),%eax
10f3ff: 50 push %eax
10f400: 57 push %edi
10f401: e8 2a 58 00 00 call 114c30 <strtoul>
10f406: 89 c6 mov %eax,%esi
if ( endptr )
10f408: 83 c4 10 add $0x10,%esp
10f40b: 8b 55 d4 mov -0x2c(%ebp),%edx
10f40e: 85 d2 test %edx,%edx
10f410: 74 05 je 10f417 <rtems_string_to_unsigned_char+0x4b>
*endptr = end;
10f412: 8b 45 e4 mov -0x1c(%ebp),%eax
10f415: 89 02 mov %eax,(%edx)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f417: b8 0b 00 00 00 mov $0xb,%eax
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
10f41c: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f41f: 74 37 je 10f458 <rtems_string_to_unsigned_char+0x8c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f421: e8 c2 26 00 00 call 111ae8 <__errno>
10f426: 83 38 22 cmpl $0x22,(%eax)
10f429: 75 0d jne 10f438 <rtems_string_to_unsigned_char+0x6c><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
10f42b: 8d 56 ff lea -0x1(%esi),%edx <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
10f42e: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f433: 83 fa fd cmp $0xfffffffd,%edx <== NOT EXECUTED
10f436: 77 20 ja 10f458 <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 ) {
10f438: 81 fe ff 00 00 00 cmp $0xff,%esi
10f43e: 76 12 jbe 10f452 <rtems_string_to_unsigned_char+0x86><== ALWAYS TAKEN
errno = ERANGE;
10f440: e8 a3 26 00 00 call 111ae8 <__errno> <== NOT EXECUTED
10f445: c7 00 22 00 00 00 movl $0x22,(%eax) <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
10f44b: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
10f450: eb 06 jmp 10f458 <rtems_string_to_unsigned_char+0x8c><== NOT EXECUTED
}
#endif
*n = result;
10f452: 89 f0 mov %esi,%eax
10f454: 88 03 mov %al,(%ebx)
return RTEMS_SUCCESSFUL;
10f456: 31 c0 xor %eax,%eax
}
10f458: 8d 65 f4 lea -0xc(%ebp),%esp
10f45b: 5b pop %ebx
10f45c: 5e pop %esi
10f45d: 5f pop %edi
10f45e: c9 leave
10f45f: c3 ret
0010f460 <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
10f460: 55 push %ebp
10f461: 89 e5 mov %esp,%ebp
10f463: 57 push %edi
10f464: 56 push %esi
10f465: 53 push %ebx
10f466: 83 ec 2c sub $0x2c,%esp
10f469: 8b 7d 08 mov 0x8(%ebp),%edi
10f46c: 8b 5d 0c mov 0xc(%ebp),%ebx
10f46f: 8b 55 10 mov 0x10(%ebp),%edx
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f472: b8 09 00 00 00 mov $0x9,%eax
)
{
unsigned long result;
char *end;
if ( !n )
10f477: 85 db test %ebx,%ebx
10f479: 74 58 je 10f4d3 <rtems_string_to_unsigned_int+0x73>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f47b: 89 55 d4 mov %edx,-0x2c(%ebp)
10f47e: e8 65 26 00 00 call 111ae8 <__errno>
10f483: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f489: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtoul( s, &end, base );
10f48f: 50 push %eax
10f490: ff 75 14 pushl 0x14(%ebp)
10f493: 8d 45 e4 lea -0x1c(%ebp),%eax
10f496: 50 push %eax
10f497: 57 push %edi
10f498: e8 93 57 00 00 call 114c30 <strtoul>
10f49d: 89 c6 mov %eax,%esi
if ( endptr )
10f49f: 83 c4 10 add $0x10,%esp
10f4a2: 8b 55 d4 mov -0x2c(%ebp),%edx
10f4a5: 85 d2 test %edx,%edx
10f4a7: 74 05 je 10f4ae <rtems_string_to_unsigned_int+0x4e>
*endptr = end;
10f4a9: 8b 45 e4 mov -0x1c(%ebp),%eax
10f4ac: 89 02 mov %eax,(%edx)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f4ae: b8 0b 00 00 00 mov $0xb,%eax
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
10f4b3: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f4b6: 74 1b je 10f4d3 <rtems_string_to_unsigned_int+0x73>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f4b8: e8 2b 26 00 00 call 111ae8 <__errno>
10f4bd: 83 38 22 cmpl $0x22,(%eax)
10f4c0: 75 0d jne 10f4cf <rtems_string_to_unsigned_int+0x6f>
(( result == 0 ) || ( result == ULONG_MAX )))
10f4c2: 8d 56 ff lea -0x1(%esi),%edx
return RTEMS_INVALID_NUMBER;
10f4c5: b8 0a 00 00 00 mov $0xa,%eax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f4ca: 83 fa fd cmp $0xfffffffd,%edx
10f4cd: 77 04 ja 10f4d3 <rtems_string_to_unsigned_int+0x73><== ALWAYS TAKEN
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
10f4cf: 89 33 mov %esi,(%ebx)
return RTEMS_SUCCESSFUL;
10f4d1: 31 c0 xor %eax,%eax
}
10f4d3: 8d 65 f4 lea -0xc(%ebp),%esp
10f4d6: 5b pop %ebx
10f4d7: 5e pop %esi
10f4d8: 5f pop %edi
10f4d9: c9 leave
10f4da: c3 ret
0010f578 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
10f578: 55 push %ebp
10f579: 89 e5 mov %esp,%ebp
10f57b: 57 push %edi
10f57c: 56 push %esi
10f57d: 53 push %ebx
10f57e: 83 ec 2c sub $0x2c,%esp
10f581: 8b 7d 08 mov 0x8(%ebp),%edi
10f584: 8b 5d 0c mov 0xc(%ebp),%ebx
10f587: 8b 55 10 mov 0x10(%ebp),%edx
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f58a: b8 09 00 00 00 mov $0x9,%eax
)
{
unsigned long result;
char *end;
if ( !n )
10f58f: 85 db test %ebx,%ebx
10f591: 74 58 je 10f5eb <rtems_string_to_unsigned_long+0x73>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f593: 89 55 d4 mov %edx,-0x2c(%ebp)
10f596: e8 4d 25 00 00 call 111ae8 <__errno>
10f59b: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f5a1: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtoul( s, &end, base );
10f5a7: 50 push %eax
10f5a8: ff 75 14 pushl 0x14(%ebp)
10f5ab: 8d 45 e4 lea -0x1c(%ebp),%eax
10f5ae: 50 push %eax
10f5af: 57 push %edi
10f5b0: e8 7b 56 00 00 call 114c30 <strtoul>
10f5b5: 89 c6 mov %eax,%esi
if ( endptr )
10f5b7: 83 c4 10 add $0x10,%esp
10f5ba: 8b 55 d4 mov -0x2c(%ebp),%edx
10f5bd: 85 d2 test %edx,%edx
10f5bf: 74 05 je 10f5c6 <rtems_string_to_unsigned_long+0x4e>
*endptr = end;
10f5c1: 8b 45 e4 mov -0x1c(%ebp),%eax
10f5c4: 89 02 mov %eax,(%edx)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f5c6: b8 0b 00 00 00 mov $0xb,%eax
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
10f5cb: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f5ce: 74 1b je 10f5eb <rtems_string_to_unsigned_long+0x73>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f5d0: e8 13 25 00 00 call 111ae8 <__errno>
10f5d5: 83 38 22 cmpl $0x22,(%eax)
10f5d8: 75 0d jne 10f5e7 <rtems_string_to_unsigned_long+0x6f>
(( result == 0 ) || ( result == ULONG_MAX )))
10f5da: 8d 56 ff lea -0x1(%esi),%edx
return RTEMS_INVALID_NUMBER;
10f5dd: b8 0a 00 00 00 mov $0xa,%eax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f5e2: 83 fa fd cmp $0xfffffffd,%edx
10f5e5: 77 04 ja 10f5eb <rtems_string_to_unsigned_long+0x73><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
10f5e7: 89 33 mov %esi,(%ebx)
return RTEMS_SUCCESSFUL;
10f5e9: 31 c0 xor %eax,%eax
}
10f5eb: 8d 65 f4 lea -0xc(%ebp),%esp
10f5ee: 5b pop %ebx
10f5ef: 5e pop %esi
10f5f0: 5f pop %edi
10f5f1: c9 leave
10f5f2: c3 ret
0010f4dc <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
10f4dc: 55 push %ebp
10f4dd: 89 e5 mov %esp,%ebp
10f4df: 57 push %edi
10f4e0: 56 push %esi
10f4e1: 53 push %ebx
10f4e2: 83 ec 2c sub $0x2c,%esp
10f4e5: 8b 7d 08 mov 0x8(%ebp),%edi
10f4e8: 8b 5d 0c mov 0xc(%ebp),%ebx
10f4eb: 8b 75 10 mov 0x10(%ebp),%esi
unsigned long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f4ee: b8 09 00 00 00 mov $0x9,%eax
)
{
unsigned long long result;
char *end;
if ( !n )
10f4f3: 85 db test %ebx,%ebx
10f4f5: 74 76 je 10f56d <rtems_string_to_unsigned_long_long+0x91>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f4f7: e8 ec 25 00 00 call 111ae8 <__errno>
10f4fc: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f502: c7 03 00 00 00 00 movl $0x0,(%ebx)
10f508: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
result = strtoull( s, &end, base );
10f50f: 50 push %eax
10f510: ff 75 14 pushl 0x14(%ebp)
10f513: 8d 45 e4 lea -0x1c(%ebp),%eax
10f516: 50 push %eax
10f517: 57 push %edi
10f518: e8 2f 57 00 00 call 114c4c <strtoull>
10f51d: 89 d1 mov %edx,%ecx
10f51f: 89 c2 mov %eax,%edx
if ( endptr )
10f521: 83 c4 10 add $0x10,%esp
10f524: 85 f6 test %esi,%esi
10f526: 74 05 je 10f52d <rtems_string_to_unsigned_long_long+0x51>
*endptr = end;
10f528: 8b 45 e4 mov -0x1c(%ebp),%eax
10f52b: 89 06 mov %eax,(%esi)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f52d: b8 0b 00 00 00 mov $0xb,%eax
result = strtoull( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
10f532: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f535: 74 36 je 10f56d <rtems_string_to_unsigned_long_long+0x91>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f537: 89 55 d4 mov %edx,-0x2c(%ebp)
10f53a: 89 4d d0 mov %ecx,-0x30(%ebp)
10f53d: e8 a6 25 00 00 call 111ae8 <__errno>
10f542: 83 38 22 cmpl $0x22,(%eax)
10f545: 8b 55 d4 mov -0x2c(%ebp),%edx
10f548: 8b 4d d0 mov -0x30(%ebp),%ecx
10f54b: 75 19 jne 10f566 <rtems_string_to_unsigned_long_long+0x8a>
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
10f54d: 89 d6 mov %edx,%esi
10f54f: 89 cf mov %ecx,%edi
10f551: 83 c6 ff add $0xffffffff,%esi
10f554: 83 d7 ff adc $0xffffffff,%edi
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f557: 83 ff ff cmp $0xffffffff,%edi
10f55a: 72 0a jb 10f566 <rtems_string_to_unsigned_long_long+0x8a><== NEVER TAKEN
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
10f55c: b8 0a 00 00 00 mov $0xa,%eax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f561: 83 fe fd cmp $0xfffffffd,%esi
10f564: 77 07 ja 10f56d <rtems_string_to_unsigned_long_long+0x91><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
10f566: 89 13 mov %edx,(%ebx)
10f568: 89 4b 04 mov %ecx,0x4(%ebx)
return RTEMS_SUCCESSFUL;
10f56b: 31 c0 xor %eax,%eax
}
10f56d: 8d 65 f4 lea -0xc(%ebp),%esp
10f570: 5b pop %ebx
10f571: 5e pop %esi
10f572: 5f pop %edi
10f573: c9 leave
10f574: c3 ret
001070ac <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
1070ac: 55 push %ebp
1070ad: 89 e5 mov %esp,%ebp
1070af: 57 push %edi
1070b0: 56 push %esi
1070b1: 53 push %ebx
1070b2: 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(
1070b8: 31 c0 xor %eax,%eax
1070ba: 83 c9 ff or $0xffffffff,%ecx
1070bd: 8b 7d 08 mov 0x8(%ebp),%edi
1070c0: f2 ae repnz scas %es:(%edi),%al
1070c2: f7 d1 not %ecx
1070c4: 49 dec %ecx
1070c5: 6a 00 push $0x0
1070c7: 8d 45 d0 lea -0x30(%ebp),%eax
1070ca: 50 push %eax
1070cb: 6a 00 push $0x0
1070cd: 51 push %ecx
1070ce: ff 75 08 pushl 0x8(%ebp)
1070d1: e8 d4 09 00 00 call 107aaa <rtems_filesystem_evaluate_path>
1070d6: 89 85 54 fe ff ff mov %eax,-0x1ac(%ebp)
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
1070dc: 83 c4 20 add $0x20,%esp
1070df: 85 c0 test %eax,%eax
1070e1: 0f 85 d9 01 00 00 jne 1072c0 <rtems_tarfs_load+0x214>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
1070e7: 8b 45 dc mov -0x24(%ebp),%eax
1070ea: 31 f6 xor %esi,%esi
1070ec: 3d b0 45 12 00 cmp $0x1245b0,%eax
1070f1: 74 1b je 10710e <rtems_tarfs_load+0x62>
1070f3: 3d 98 4f 12 00 cmp $0x124f98,%eax
1070f8: 0f 85 c2 01 00 00 jne 1072c0 <rtems_tarfs_load+0x214><== ALWAYS TAKEN
1070fe: 8b b5 54 fe ff ff mov -0x1ac(%ebp),%esi <== NOT EXECUTED
107104: eb 08 jmp 10710e <rtems_tarfs_load+0x62> <== NOT EXECUTED
107106: 8b b5 50 fe ff ff mov -0x1b0(%ebp),%esi
10710c: eb 18 jmp 107126 <rtems_tarfs_load+0x7a>
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
10710e: 8d 45 bc lea -0x44(%ebp),%eax
107111: 89 85 34 fe ff ff mov %eax,-0x1cc(%ebp)
107117: 8d 55 d0 lea -0x30(%ebp),%edx
10711a: 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);
107120: 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)
107126: 8d 86 00 02 00 00 lea 0x200(%esi),%eax
10712c: 89 85 50 fe ff ff mov %eax,-0x1b0(%ebp)
107132: 8b 55 10 mov 0x10(%ebp),%edx
107135: 39 d0 cmp %edx,%eax
107137: 0f 87 8d 01 00 00 ja 1072ca <rtems_tarfs_load+0x21e><== NEVER TAKEN
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
10713d: 03 75 0c add 0xc(%ebp),%esi
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
107140: 8d 86 01 01 00 00 lea 0x101(%esi),%eax
107146: 52 push %edx
107147: 6a 05 push $0x5
107149: 68 f8 45 12 00 push $0x1245f8
10714e: 50 push %eax
10714f: e8 a8 e5 00 00 call 1156fc <strncmp>
107154: 83 c4 10 add $0x10,%esp
107157: 85 c0 test %eax,%eax
107159: 0f 85 6b 01 00 00 jne 1072ca <rtems_tarfs_load+0x21e>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
10715f: 50 push %eax
107160: 6a 63 push $0x63
107162: 56 push %esi
107163: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax
107169: 50 push %eax
10716a: e8 1d e6 00 00 call 11578c <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
10716f: c6 45 bb 00 movb $0x0,-0x45(%ebp)
linkflag = hdr_ptr[156];
107173: 8a 96 9c 00 00 00 mov 0x9c(%esi),%dl
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
107179: 59 pop %ecx
10717a: 5f pop %edi
10717b: 6a 08 push $0x8
10717d: 8d 46 64 lea 0x64(%esi),%eax
107180: 50 push %eax
107181: 88 95 44 fe ff ff mov %dl,-0x1bc(%ebp)
107187: e8 b4 6e 00 00 call 10e040 <_rtems_octal2ulong>
10718c: 89 85 48 fe ff ff mov %eax,-0x1b8(%ebp)
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
107192: 5f pop %edi
107193: 58 pop %eax
107194: 6a 0c push $0xc
107196: 8d 46 7c lea 0x7c(%esi),%eax
107199: 50 push %eax
10719a: e8 a1 6e 00 00 call 10e040 <_rtems_octal2ulong>
10719f: 89 85 4c fe ff ff mov %eax,-0x1b4(%ebp)
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
1071a5: 5a pop %edx
1071a6: 59 pop %ecx
1071a7: 6a 08 push $0x8
1071a9: 8d 86 94 00 00 00 lea 0x94(%esi),%eax
1071af: 50 push %eax
1071b0: e8 8b 6e 00 00 call 10e040 <_rtems_octal2ulong>
1071b5: 89 c7 mov %eax,%edi
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
1071b7: 89 34 24 mov %esi,(%esp)
1071ba: e8 af 6e 00 00 call 10e06e <_rtems_tar_header_checksum>
1071bf: 83 c4 10 add $0x10,%esp
1071c2: 39 f8 cmp %edi,%eax
1071c4: 8a 95 44 fe ff ff mov -0x1bc(%ebp),%dl
1071ca: 0f 85 fa 00 00 00 jne 1072ca <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) {
1071d0: 80 fa 35 cmp $0x35,%dl
1071d3: 75 57 jne 10722c <rtems_tarfs_load+0x180>
strcpy(full_filename, mountpoint);
1071d5: 50 push %eax
1071d6: 50 push %eax
1071d7: ff 75 08 pushl 0x8(%ebp)
1071da: 53 push %ebx
1071db: e8 b4 e1 00 00 call 115394 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
1071e0: 31 c0 xor %eax,%eax
1071e2: 83 c9 ff or $0xffffffff,%ecx
1071e5: 89 df mov %ebx,%edi
1071e7: f2 ae repnz scas %es:(%edi),%al
1071e9: f7 d1 not %ecx
1071eb: 83 c4 10 add $0x10,%esp
1071ee: 80 bc 0d 56 fe ff ff cmpb $0x2f,-0x1aa(%ebp,%ecx,1)
1071f5: 2f
1071f6: 74 10 je 107208 <rtems_tarfs_load+0x15c><== ALWAYS TAKEN
strcat(full_filename, "/");
1071f8: 57 push %edi <== NOT EXECUTED
1071f9: 57 push %edi <== NOT EXECUTED
1071fa: 68 59 04 12 00 push $0x120459 <== NOT EXECUTED
1071ff: 53 push %ebx <== NOT EXECUTED
107200: e8 db df 00 00 call 1151e0 <strcat> <== NOT EXECUTED
107205: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
strcat(full_filename, filename);
107208: 56 push %esi
107209: 56 push %esi
10720a: 8d 95 58 ff ff ff lea -0xa8(%ebp),%edx
107210: 52 push %edx
107211: 53 push %ebx
107212: e8 c9 df 00 00 call 1151e0 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
107217: 5a pop %edx
107218: 59 pop %ecx
107219: 68 ff 01 00 00 push $0x1ff
10721e: 53 push %ebx
10721f: e8 58 0f 00 00 call 10817c <mkdir>
107224: 83 c4 10 add $0x10,%esp
107227: e9 da fe ff ff jmp 107106 <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) {
10722c: 80 fa 30 cmp $0x30,%dl
10722f: 0f 85 d1 fe ff ff jne 107106 <rtems_tarfs_load+0x5a>
const char *name;
loc = root_loc;
107235: b9 05 00 00 00 mov $0x5,%ecx
10723a: 8b bd 34 fe ff ff mov -0x1cc(%ebp),%edi
107240: 8b b5 30 fe ff ff mov -0x1d0(%ebp),%esi
107246: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
107248: 50 push %eax
107249: 8d 45 e4 lea -0x1c(%ebp),%eax
10724c: 50 push %eax
10724d: 8d 55 bc lea -0x44(%ebp),%edx
107250: 52 push %edx
107251: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax
107257: 50 push %eax
107258: e8 0f 79 00 00 call 10eb6c <IMFS_evaluate_for_make>
10725d: 83 c4 10 add $0x10,%esp
107260: 85 c0 test %eax,%eax
107262: 75 41 jne 1072a5 <rtems_tarfs_load+0x1f9><== NEVER TAKEN
node = IMFS_create_node(
107264: 83 ec 0c sub $0xc,%esp
107267: 6a 00 push $0x0
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
107269: 8b 85 48 fe ff ff mov -0x1b8(%ebp),%eax
10726f: 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(
107274: 80 cc 80 or $0x80,%ah
107277: 50 push %eax
107278: ff 75 e4 pushl -0x1c(%ebp)
10727b: 6a 06 push $0x6
10727d: 8d 55 bc lea -0x44(%ebp),%edx
107280: 52 push %edx
107281: e8 d9 73 00 00 call 10e65f <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;
107286: 8b 95 4c fe ff ff mov -0x1b4(%ebp),%edx
10728c: 89 50 50 mov %edx,0x50(%eax)
10728f: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.linearfile.direct = &tar_image[offset];
107296: 8b 55 0c mov 0xc(%ebp),%edx
107299: 03 95 50 fe ff ff add -0x1b0(%ebp),%edx
10729f: 89 50 58 mov %edx,0x58(%eax)
1072a2: 83 c4 20 add $0x20,%esp
}
nblocks = (((file_size) + 511) & ~511) / 512;
1072a5: 8b 85 4c fe ff ff mov -0x1b4(%ebp),%eax
1072ab: 05 ff 01 00 00 add $0x1ff,%eax
offset += 512 * nblocks;
1072b0: 25 00 fe ff ff and $0xfffffe00,%eax
1072b5: 01 85 50 fe ff ff add %eax,-0x1b0(%ebp)
1072bb: e9 46 fe ff ff jmp 107106 <rtems_tarfs_load+0x5a>
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
return -1;
1072c0: c7 85 54 fe ff ff ff movl $0xffffffff,-0x1ac(%ebp)
1072c7: ff ff ff
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
1072ca: 8b 85 54 fe ff ff mov -0x1ac(%ebp),%eax
1072d0: 8d 65 f4 lea -0xc(%ebp),%esp
1072d3: 5b pop %ebx
1072d4: 5e pop %esi
1072d5: 5f pop %edi
1072d6: c9 leave
1072d7: c3 ret
00110d68 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
110d68: 55 push %ebp
110d69: 89 e5 mov %esp,%ebp
110d6b: 57 push %edi
110d6c: 56 push %esi
110d6d: 53 push %ebx
110d6e: 83 ec 1c sub $0x1c,%esp
110d71: 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;
110d74: 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 )
110d79: 85 c9 test %ecx,%ecx
110d7b: 0f 84 fb 00 00 00 je 110e7c <rtems_task_mode+0x114> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
110d81: 8b 35 68 58 12 00 mov 0x125868,%esi
api = executing->API_Extensions[ THREAD_API_RTEMS ];
110d87: 8b 9e e8 00 00 00 mov 0xe8(%esi),%ebx
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
110d8d: 80 7e 74 01 cmpb $0x1,0x74(%esi)
110d91: 19 ff sbb %edi,%edi
110d93: 81 e7 00 01 00 00 and $0x100,%edi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
110d99: 83 7e 7c 00 cmpl $0x0,0x7c(%esi)
110d9d: 74 06 je 110da5 <rtems_task_mode+0x3d>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
110d9f: 81 cf 00 02 00 00 or $0x200,%edi
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
110da5: 80 7b 08 01 cmpb $0x1,0x8(%ebx)
110da9: 19 d2 sbb %edx,%edx
110dab: 81 e2 00 04 00 00 and $0x400,%edx
old_mode |= _ISR_Get_level();
110db1: 89 55 e4 mov %edx,-0x1c(%ebp)
110db4: 89 4d e0 mov %ecx,-0x20(%ebp)
110db7: e8 59 c6 ff ff call 10d415 <_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;
110dbc: 8b 55 e4 mov -0x1c(%ebp),%edx
110dbf: 09 d0 or %edx,%eax
old_mode |= _ISR_Get_level();
110dc1: 09 f8 or %edi,%eax
110dc3: 8b 4d e0 mov -0x20(%ebp),%ecx
110dc6: 89 01 mov %eax,(%ecx)
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
110dc8: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
110dcf: 74 0b je 110ddc <rtems_task_mode+0x74>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
110dd1: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp)
110dd8: 0f 94 46 74 sete 0x74(%esi)
if ( mask & RTEMS_TIMESLICE_MASK ) {
110ddc: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
110de3: 74 21 je 110e06 <rtems_task_mode+0x9e>
if ( _Modes_Is_timeslice(mode_set) ) {
110de5: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
110dec: 74 11 je 110dff <rtems_task_mode+0x97>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
110dee: c7 46 7c 01 00 00 00 movl $0x1,0x7c(%esi)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
110df5: a1 10 53 12 00 mov 0x125310,%eax
110dfa: 89 46 78 mov %eax,0x78(%esi)
110dfd: eb 07 jmp 110e06 <rtems_task_mode+0x9e>
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
110dff: c7 46 7c 00 00 00 00 movl $0x0,0x7c(%esi)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
110e06: f6 45 0c 01 testb $0x1,0xc(%ebp)
110e0a: 74 0a je 110e16 <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 ) );
110e0c: f6 45 08 01 testb $0x1,0x8(%ebp)
110e10: 74 03 je 110e15 <rtems_task_mode+0xad>
110e12: fa cli
110e13: eb 01 jmp 110e16 <rtems_task_mode+0xae>
110e15: fb sti
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110e16: 31 c9 xor %ecx,%ecx
if ( mask & RTEMS_ASR_MASK ) {
110e18: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
110e1f: 74 2a je 110e4b <rtems_task_mode+0xe3>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
110e21: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp)
110e28: 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 ) {
110e2b: 3a 43 08 cmp 0x8(%ebx),%al
110e2e: 74 1b je 110e4b <rtems_task_mode+0xe3>
asr->is_enabled = is_asr_enabled;
110e30: 88 43 08 mov %al,0x8(%ebx)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
110e33: 9c pushf
110e34: fa cli
110e35: 58 pop %eax
_signals = information->signals_pending;
110e36: 8b 53 18 mov 0x18(%ebx),%edx
information->signals_pending = information->signals_posted;
110e39: 8b 4b 14 mov 0x14(%ebx),%ecx
110e3c: 89 4b 18 mov %ecx,0x18(%ebx)
information->signals_posted = _signals;
110e3f: 89 53 14 mov %edx,0x14(%ebx)
_ISR_Enable( _level );
110e42: 50 push %eax
110e43: 9d popf
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110e44: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
110e48: 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;
110e4b: 31 c0 xor %eax,%eax
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
110e4d: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c
110e54: 75 26 jne 110e7c <rtems_task_mode+0x114> <== NEVER TAKEN
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
110e56: 8b 15 68 58 12 00 mov 0x125868,%edx
if ( are_signals_pending ||
110e5c: 84 c9 test %cl,%cl
110e5e: 75 0e jne 110e6e <rtems_task_mode+0x106>
110e60: 3b 15 6c 58 12 00 cmp 0x12586c,%edx
110e66: 74 14 je 110e7c <rtems_task_mode+0x114>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
110e68: 80 7a 74 00 cmpb $0x0,0x74(%edx)
110e6c: 74 0e je 110e7c <rtems_task_mode+0x114> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
110e6e: c6 05 74 58 12 00 01 movb $0x1,0x125874
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
110e75: e8 46 b2 ff ff call 10c0c0 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
110e7a: 31 c0 xor %eax,%eax
}
110e7c: 83 c4 1c add $0x1c,%esp
110e7f: 5b pop %ebx
110e80: 5e pop %esi
110e81: 5f pop %edi
110e82: c9 leave
110e83: c3 ret
0010dd84 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10dd84: 55 push %ebp
10dd85: 89 e5 mov %esp,%ebp
10dd87: 56 push %esi
10dd88: 53 push %ebx
10dd89: 83 ec 10 sub $0x10,%esp
10dd8c: 8b 5d 0c mov 0xc(%ebp),%ebx
10dd8f: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10dd92: 85 db test %ebx,%ebx
10dd94: 74 10 je 10dda6 <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 ) );
10dd96: 0f b6 15 24 42 12 00 movzbl 0x124224,%edx
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
10dd9d: b8 13 00 00 00 mov $0x13,%eax
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10dda2: 39 d3 cmp %edx,%ebx
10dda4: 77 52 ja 10ddf8 <rtems_task_set_priority+0x74>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
10dda6: 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 )
10ddab: 85 f6 test %esi,%esi
10ddad: 74 49 je 10ddf8 <rtems_task_set_priority+0x74>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10ddaf: 51 push %ecx
10ddb0: 51 push %ecx
10ddb1: 8d 45 f4 lea -0xc(%ebp),%eax
10ddb4: 50 push %eax
10ddb5: ff 75 08 pushl 0x8(%ebp)
10ddb8: e8 cb 1e 00 00 call 10fc88 <_Thread_Get>
switch ( location ) {
10ddbd: 83 c4 10 add $0x10,%esp
10ddc0: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10ddc4: 75 2d jne 10ddf3 <rtems_task_set_priority+0x6f>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10ddc6: 8b 50 14 mov 0x14(%eax),%edx
10ddc9: 89 16 mov %edx,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10ddcb: 85 db test %ebx,%ebx
10ddcd: 74 1b je 10ddea <rtems_task_set_priority+0x66>
the_thread->real_priority = new_priority;
10ddcf: 89 58 18 mov %ebx,0x18(%eax)
if ( the_thread->resource_count == 0 ||
10ddd2: 83 78 1c 00 cmpl $0x0,0x1c(%eax)
10ddd6: 74 05 je 10dddd <rtems_task_set_priority+0x59>
10ddd8: 39 58 14 cmp %ebx,0x14(%eax)
10dddb: 76 0d jbe 10ddea <rtems_task_set_priority+0x66><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
10dddd: 52 push %edx
10ddde: 6a 00 push $0x0
10dde0: 53 push %ebx
10dde1: 50 push %eax
10dde2: e8 a9 1a 00 00 call 10f890 <_Thread_Change_priority>
10dde7: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10ddea: e8 77 1e 00 00 call 10fc66 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ddef: 31 c0 xor %eax,%eax
10ddf1: eb 05 jmp 10ddf8 <rtems_task_set_priority+0x74>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10ddf3: b8 04 00 00 00 mov $0x4,%eax
}
10ddf8: 8d 65 f8 lea -0x8(%ebp),%esp
10ddfb: 5b pop %ebx
10ddfc: 5e pop %esi
10ddfd: c9 leave
10ddfe: c3 ret
0010855b <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
10855b: 55 push %ebp
10855c: 89 e5 mov %esp,%ebp
10855e: 56 push %esi
10855f: 53 push %ebx
108560: 8b 75 08 mov 0x8(%ebp),%esi
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
108563: 8b 06 mov (%esi),%eax
108565: 8b 58 34 mov 0x34(%eax),%ebx
rtems_status_code sc;
sc = rtems_semaphore_obtain(
108568: 51 push %ecx
108569: 6a 00 push $0x0
10856b: 6a 00 push $0x0
10856d: ff 35 3c 52 12 00 pushl 0x12523c
108573: e8 44 1c 00 00 call 10a1bc <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
108578: 83 c4 10 add $0x10,%esp
10857b: 85 c0 test %eax,%eax
10857d: 0f 85 88 00 00 00 jne 10860b <rtems_termios_close+0xb0><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
108583: 8b 43 08 mov 0x8(%ebx),%eax
108586: 48 dec %eax
108587: 89 43 08 mov %eax,0x8(%ebx)
10858a: 85 c0 test %eax,%eax
10858c: 0f 85 3e 01 00 00 jne 1086d0 <rtems_termios_close+0x175>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
108592: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
108598: c1 e0 05 shl $0x5,%eax
10859b: 8b 80 f8 4e 12 00 mov 0x124ef8(%eax),%eax
1085a1: 85 c0 test %eax,%eax
1085a3: 74 08 je 1085ad <rtems_termios_close+0x52>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
1085a5: 83 ec 0c sub $0xc,%esp
1085a8: 53 push %ebx
1085a9: ff d0 call *%eax
1085ab: eb 26 jmp 1085d3 <rtems_termios_close+0x78>
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
1085ad: 52 push %edx
1085ae: 6a 00 push $0x0
1085b0: 6a 00 push $0x0
1085b2: ff 73 18 pushl 0x18(%ebx)
1085b5: e8 02 1c 00 00 call 10a1bc <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
1085ba: 83 c4 10 add $0x10,%esp
1085bd: 85 c0 test %eax,%eax
1085bf: 75 4a jne 10860b <rtems_termios_close+0xb0><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
1085c1: 89 d8 mov %ebx,%eax
1085c3: e8 10 fb ff ff call 1080d8 <drainOutput>
rtems_semaphore_release (tty->osem);
1085c8: 83 ec 0c sub $0xc,%esp
1085cb: ff 73 18 pushl 0x18(%ebx)
1085ce: e8 d5 1c 00 00 call 10a2a8 <rtems_semaphore_release>
1085d3: 83 c4 10 add $0x10,%esp
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
1085d6: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
1085dd: 75 35 jne 108614 <rtems_termios_close+0xb9>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
1085df: 50 push %eax
1085e0: 50 push %eax
1085e1: 6a 01 push $0x1
1085e3: ff b3 c4 00 00 00 pushl 0xc4(%ebx)
1085e9: e8 66 17 00 00 call 109d54 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
1085ee: 83 c4 10 add $0x10,%esp
1085f1: 85 c0 test %eax,%eax
1085f3: 75 16 jne 10860b <rtems_termios_close+0xb0><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
1085f5: 51 push %ecx
1085f6: 51 push %ecx
1085f7: 6a 01 push $0x1
1085f9: ff b3 c8 00 00 00 pushl 0xc8(%ebx)
1085ff: e8 50 17 00 00 call 109d54 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
108604: 83 c4 10 add $0x10,%esp
108607: 85 c0 test %eax,%eax
108609: 74 09 je 108614 <rtems_termios_close+0xb9><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
10860b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10860e: 50 push %eax <== NOT EXECUTED
10860f: e8 74 21 00 00 call 10a788 <rtems_fatal_error_occurred><== NOT EXECUTED
}
if (tty->device.lastClose)
108614: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax
10861a: 85 c0 test %eax,%eax
10861c: 74 0d je 10862b <rtems_termios_close+0xd0>
(*tty->device.lastClose)(tty->major, tty->minor, arg);
10861e: 52 push %edx
10861f: 56 push %esi
108620: ff 73 10 pushl 0x10(%ebx)
108623: ff 73 0c pushl 0xc(%ebx)
108626: ff d0 call *%eax
108628: 83 c4 10 add $0x10,%esp
if (tty->forw == NULL) {
10862b: 8b 13 mov (%ebx),%edx
10862d: 85 d2 test %edx,%edx
10862f: 8b 43 04 mov 0x4(%ebx),%eax
108632: 75 11 jne 108645 <rtems_termios_close+0xea>
rtems_termios_ttyTail = tty->back;
108634: a3 40 52 12 00 mov %eax,0x125240
if ( rtems_termios_ttyTail != NULL ) {
108639: 85 c0 test %eax,%eax
10863b: 74 0b je 108648 <rtems_termios_close+0xed>
rtems_termios_ttyTail->forw = NULL;
10863d: c7 00 00 00 00 00 movl $0x0,(%eax)
108643: eb 03 jmp 108648 <rtems_termios_close+0xed>
}
} else {
tty->forw->back = tty->back;
108645: 89 42 04 mov %eax,0x4(%edx)
}
if (tty->back == NULL) {
108648: 8b 53 04 mov 0x4(%ebx),%edx
10864b: 85 d2 test %edx,%edx
10864d: 8b 03 mov (%ebx),%eax
10864f: 75 12 jne 108663 <rtems_termios_close+0x108>
rtems_termios_ttyHead = tty->forw;
108651: a3 44 52 12 00 mov %eax,0x125244
if ( rtems_termios_ttyHead != NULL ) {
108656: 85 c0 test %eax,%eax
108658: 74 0b je 108665 <rtems_termios_close+0x10a>
rtems_termios_ttyHead->back = NULL;
10865a: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
108661: eb 02 jmp 108665 <rtems_termios_close+0x10a>
}
} else {
tty->back->forw = tty->forw;
108663: 89 02 mov %eax,(%edx)
}
rtems_semaphore_delete (tty->isem);
108665: 83 ec 0c sub $0xc,%esp
108668: ff 73 14 pushl 0x14(%ebx)
10866b: e8 bc 1a 00 00 call 10a12c <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
108670: 59 pop %ecx
108671: ff 73 18 pushl 0x18(%ebx)
108674: e8 b3 1a 00 00 call 10a12c <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
108679: 5a pop %edx
10867a: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
108680: e8 a7 1a 00 00 call 10a12c <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
108685: 83 c4 10 add $0x10,%esp
108688: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
10868f: 74 09 je 10869a <rtems_termios_close+0x13f>
108691: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
108698: 75 0e jne 1086a8 <rtems_termios_close+0x14d>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
10869a: 83 ec 0c sub $0xc,%esp
10869d: ff 73 68 pushl 0x68(%ebx)
1086a0: e8 87 1a 00 00 call 10a12c <rtems_semaphore_delete>
1086a5: 83 c4 10 add $0x10,%esp
free (tty->rawInBuf.theBuf);
1086a8: 83 ec 0c sub $0xc,%esp
1086ab: ff 73 58 pushl 0x58(%ebx)
1086ae: e8 c5 ec ff ff call 107378 <free>
free (tty->rawOutBuf.theBuf);
1086b3: 58 pop %eax
1086b4: ff 73 7c pushl 0x7c(%ebx)
1086b7: e8 bc ec ff ff call 107378 <free>
free (tty->cbuf);
1086bc: 5e pop %esi
1086bd: ff 73 1c pushl 0x1c(%ebx)
1086c0: e8 b3 ec ff ff call 107378 <free>
free (tty);
1086c5: 89 1c 24 mov %ebx,(%esp)
1086c8: e8 ab ec ff ff call 107378 <free>
1086cd: 83 c4 10 add $0x10,%esp
}
rtems_semaphore_release (rtems_termios_ttyMutex);
1086d0: 83 ec 0c sub $0xc,%esp
1086d3: ff 35 3c 52 12 00 pushl 0x12523c
1086d9: e8 ca 1b 00 00 call 10a2a8 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
1086de: 31 c0 xor %eax,%eax
1086e0: 8d 65 f8 lea -0x8(%ebp),%esp
1086e3: 5b pop %ebx
1086e4: 5e pop %esi
1086e5: c9 leave
1086e6: c3 ret
00109894 <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)
{
109894: 55 push %ebp
109895: 89 e5 mov %esp,%ebp
109897: 83 ec 08 sub $0x8,%esp
10989a: 8b 45 08 mov 0x8(%ebp),%eax
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
10989d: 8b 55 0c mov 0xc(%ebp),%edx
1098a0: 01 90 90 00 00 00 add %edx,0x90(%eax)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
1098a6: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax)
1098ad: 75 1f jne 1098ce <rtems_termios_dequeue_characters+0x3a>
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
1098af: 52 push %edx
1098b0: 52 push %edx
1098b1: 6a 02 push $0x2
1098b3: ff b0 c8 00 00 00 pushl 0xc8(%eax)
1098b9: e8 96 04 00 00 call 109d54 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
1098be: 83 c4 10 add $0x10,%esp
1098c1: 85 c0 test %eax,%eax
1098c3: 74 30 je 1098f5 <rtems_termios_dequeue_characters+0x61><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
1098c5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1098c8: 50 push %eax <== NOT EXECUTED
1098c9: e8 ba 0e 00 00 call 10a788 <rtems_fatal_error_occurred><== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
1098ce: 83 b8 cc 00 00 00 05 cmpl $0x5,0xcc(%eax)
1098d5: 75 15 jne 1098ec <rtems_termios_dequeue_characters+0x58>
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
1098d7: 8b 15 a8 4f 12 00 mov 0x124fa8,%edx
1098dd: 85 d2 test %edx,%edx
1098df: 74 14 je 1098f5 <rtems_termios_dequeue_characters+0x61><== NEVER TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
1098e1: 83 ec 0c sub $0xc,%esp
1098e4: 50 push %eax
1098e5: ff d2 call *%edx
1098e7: 83 c4 10 add $0x10,%esp
1098ea: eb 09 jmp 1098f5 <rtems_termios_dequeue_characters+0x61>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
1098ec: 89 45 08 mov %eax,0x8(%ebp)
}
1098ef: c9 leave
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
1098f0: e9 6d fd ff ff jmp 109662 <rtems_termios_refill_transmitter>
}
1098f5: 31 c0 xor %eax,%eax
1098f7: c9 leave
1098f8: c3 ret
00109373 <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)
{
109373: 55 push %ebp
109374: 89 e5 mov %esp,%ebp
109376: 57 push %edi
109377: 56 push %esi
109378: 53 push %ebx
109379: 83 ec 2c sub $0x2c,%esp
10937c: 8b 5d 08 mov 0x8(%ebp),%ebx
10937f: 8b 7d 0c mov 0xc(%ebp),%edi
109382: 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) {
109385: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
10938b: c1 e0 05 shl $0x5,%eax
10938e: 89 ca mov %ecx,%edx
109390: 83 b8 04 4f 12 00 00 cmpl $0x0,0x124f04(%eax)
109397: 75 3b jne 1093d4 <rtems_termios_enqueue_raw_characters+0x61>
109399: 89 4d e0 mov %ecx,-0x20(%ebp)
10939c: c6 45 df 00 movb $0x0,-0x21(%ebp)
1093a0: 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);
1093a2: 8d 43 30 lea 0x30(%ebx),%eax
1093a5: 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,
1093a8: 8d 53 4a lea 0x4a(%ebx),%edx
1093ab: 89 55 d0 mov %edx,-0x30(%ebp)
1093ae: e9 26 02 00 00 jmp 1095d9 <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++;
1093b3: 0f be 0f movsbl (%edi),%ecx
1093b6: 47 inc %edi
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
1093b7: 56 push %esi
1093b8: 56 push %esi
1093b9: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
1093bf: c1 e0 05 shl $0x5,%eax
1093c2: 53 push %ebx
1093c3: 51 push %ecx
1093c4: 89 55 cc mov %edx,-0x34(%ebp)
1093c7: ff 90 04 4f 12 00 call *0x124f04(%eax)
1093cd: 8b 55 cc mov -0x34(%ebp),%edx
1093d0: 4a dec %edx
1093d1: 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--) {
1093d4: 85 d2 test %edx,%edx
1093d6: 75 db jne 1093b3 <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;
1093d8: 31 f6 xor %esi,%esi
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
1093da: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx)
1093e1: 0f 85 0d 02 00 00 jne 1095f4 <rtems_termios_enqueue_raw_characters+0x281><== NEVER TAKEN
1093e7: 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;
1093ed: 89 d6 mov %edx,%esi
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
1093ef: 85 c0 test %eax,%eax
1093f1: 0f 84 fd 01 00 00 je 1095f4 <rtems_termios_enqueue_raw_characters+0x281><== NEVER TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
1093f7: 51 push %ecx
1093f8: 51 push %ecx
1093f9: ff b3 e0 00 00 00 pushl 0xe0(%ebx)
1093ff: 8d 53 30 lea 0x30(%ebx),%edx
109402: 52 push %edx
109403: ff d0 call *%eax
tty->tty_rcvwakeup = 1;
109405: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx)
10940c: 00 00 00
10940f: e9 dd 01 00 00 jmp 1095f1 <rtems_termios_enqueue_raw_characters+0x27e>
}
return 0;
}
while (len--) {
c = *buf++;
109414: 8a 0f mov (%edi),%cl
109416: 88 4d de mov %cl,-0x22(%ebp)
109419: 47 inc %edi
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
10941a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109420: f6 c4 02 test $0x2,%ah
109423: 74 46 je 10946b <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]) {
109425: 0f be c1 movsbl %cl,%eax
109428: 0f b6 53 4a movzbl 0x4a(%ebx),%edx
10942c: 39 d0 cmp %edx,%eax
10942e: 75 28 jne 109458 <rtems_termios_enqueue_raw_characters+0xe5>
if (c == tty->termios.c_cc[VSTART]) {
109430: 0f b6 53 49 movzbl 0x49(%ebx),%edx
109434: 39 d0 cmp %edx,%eax
109436: 75 0b jne 109443 <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;
109438: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10943e: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED
109441: eb 09 jmp 10944c <rtems_termios_enqueue_raw_characters+0xd9><== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
109443: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109449: 83 c8 10 or $0x10,%eax
10944c: 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)
{
109452: c6 45 df 01 movb $0x1,-0x21(%ebp)
109456: eb 19 jmp 109471 <rtems_termios_enqueue_raw_characters+0xfe>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
109458: 0f b6 53 49 movzbl 0x49(%ebx),%edx
10945c: 39 d0 cmp %edx,%eax
10945e: 75 0b jne 10946b <rtems_termios_enqueue_raw_characters+0xf8><== ALWAYS TAKEN
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
109460: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109466: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED
109469: eb e1 jmp 10944c <rtems_termios_enqueue_raw_characters+0xd9><== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
10946b: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
10946f: 74 51 je 1094c2 <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) {
109471: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109477: 83 e0 30 and $0x30,%eax
10947a: 83 f8 20 cmp $0x20,%eax
10947d: 0f 85 53 01 00 00 jne 1095d6 <rtems_termios_enqueue_raw_characters+0x263>
/* disable interrupts */
rtems_interrupt_disable(level);
109483: 9c pushf <== NOT EXECUTED
109484: fa cli <== NOT EXECUTED
109485: 8f 45 e4 popl -0x1c(%ebp) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
109488: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10948e: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
109491: 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) {
109497: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
10949e: 74 19 je 1094b9 <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);
1094a0: 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)(
1094a6: 52 push %edx <== NOT EXECUTED
1094a7: 6a 01 push $0x1 <== NOT EXECUTED
1094a9: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
1094ac: 50 push %eax <== NOT EXECUTED
1094ad: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1094b0: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
1094b6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
1094b9: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED
1094bc: 9d popf <== NOT EXECUTED
1094bd: e9 14 01 00 00 jmp 1095d6 <rtems_termios_enqueue_raw_characters+0x263><== NOT EXECUTED
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
1094c2: 8b 43 60 mov 0x60(%ebx),%eax
1094c5: 8b 4b 64 mov 0x64(%ebx),%ecx
1094c8: 40 inc %eax
1094c9: 31 d2 xor %edx,%edx
1094cb: f7 f1 div %ecx
1094cd: 89 55 e4 mov %edx,-0x1c(%ebp)
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
1094d0: 9c pushf
1094d1: fa cli
1094d2: 8f 45 d8 popl -0x28(%ebp)
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
1094d5: 8b 53 5c mov 0x5c(%ebx),%edx
1094d8: 8b 43 64 mov 0x64(%ebx),%eax
% tty->rawInBuf.Size) > tty->highwater) &&
1094db: 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)
1094de: 29 d0 sub %edx,%eax
1094e0: 03 45 e4 add -0x1c(%ebp),%eax
% tty->rawInBuf.Size) > tty->highwater) &&
1094e3: 31 d2 xor %edx,%edx
1094e5: 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)
1094e7: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx
1094ed: 0f 86 98 00 00 00 jbe 10958b <rtems_termios_enqueue_raw_characters+0x218><== ALWAYS TAKEN
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
1094f3: 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) &&
1094f9: a8 01 test $0x1,%al <== NOT EXECUTED
1094fb: 0f 85 8a 00 00 00 jne 10958b <rtems_termios_enqueue_raw_characters+0x218><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
109501: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109507: 83 c8 01 or $0x1,%eax <== NOT EXECUTED
10950a: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
109510: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109516: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED
10951b: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED
109520: 75 33 jne 109555 <rtems_termios_enqueue_raw_characters+0x1e2><== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
109522: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109528: a8 20 test $0x20,%al <== NOT EXECUTED
10952a: 75 09 jne 109535 <rtems_termios_enqueue_raw_characters+0x1c2><== NOT EXECUTED
10952c: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
109533: 75 56 jne 10958b <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;
109535: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10953b: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
10953e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
109544: 51 push %ecx <== NOT EXECUTED
109545: 6a 01 push $0x1 <== NOT EXECUTED
109547: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED
10954a: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10954d: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
109553: eb 33 jmp 109588 <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) ) {
109555: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10955b: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED
109560: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED
109565: 75 24 jne 10958b <rtems_termios_enqueue_raw_characters+0x218><== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
109567: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10956d: 83 c8 04 or $0x4,%eax <== NOT EXECUTED
109570: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
109576: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED
10957c: 85 c0 test %eax,%eax <== NOT EXECUTED
10957e: 74 0b je 10958b <rtems_termios_enqueue_raw_characters+0x218><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
109580: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109583: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109586: ff d0 call *%eax <== NOT EXECUTED
109588: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
10958b: ff 75 d8 pushl -0x28(%ebp)
10958e: 9d popf
if (newTail == tty->rawInBuf.Head) {
10958f: 8b 43 5c mov 0x5c(%ebx),%eax
109592: 39 45 e4 cmp %eax,-0x1c(%ebp)
109595: 75 03 jne 10959a <rtems_termios_enqueue_raw_characters+0x227><== ALWAYS TAKEN
dropped++;
109597: 46 inc %esi <== NOT EXECUTED
109598: eb 3c jmp 1095d6 <rtems_termios_enqueue_raw_characters+0x263><== NOT EXECUTED
} else {
tty->rawInBuf.theBuf[newTail] = c;
10959a: 8b 43 58 mov 0x58(%ebx),%eax
10959d: 8a 4d de mov -0x22(%ebp),%cl
1095a0: 8b 55 e4 mov -0x1c(%ebp),%edx
1095a3: 88 0c 10 mov %cl,(%eax,%edx,1)
tty->rawInBuf.Tail = newTail;
1095a6: 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 )) {
1095a9: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx)
1095b0: 75 24 jne 1095d6 <rtems_termios_enqueue_raw_characters+0x263><== NEVER TAKEN
1095b2: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax
1095b8: 85 c0 test %eax,%eax
1095ba: 74 1a je 1095d6 <rtems_termios_enqueue_raw_characters+0x263><== ALWAYS TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
1095bc: 52 push %edx <== NOT EXECUTED
1095bd: 52 push %edx <== NOT EXECUTED
1095be: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED
1095c4: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED
1095c7: ff d0 call *%eax <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
1095c9: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED
1095d0: 00 00 00
1095d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1095d6: ff 4d e0 decl -0x20(%ebp)
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
1095d9: 83 7d e0 00 cmpl $0x0,-0x20(%ebp)
1095dd: 0f 85 31 fe ff ff jne 109414 <rtems_termios_enqueue_raw_characters+0xa1>
}
}
}
}
tty->rawInBufDropped += dropped;
1095e3: 01 73 78 add %esi,0x78(%ebx)
rtems_semaphore_release (tty->rawInBuf.Semaphore);
1095e6: 83 ec 0c sub $0xc,%esp
1095e9: ff 73 68 pushl 0x68(%ebx)
1095ec: e8 b7 0c 00 00 call 10a2a8 <rtems_semaphore_release>
return dropped;
1095f1: 83 c4 10 add $0x10,%esp
}
1095f4: 89 f0 mov %esi,%eax
1095f6: 8d 65 f4 lea -0xc(%ebp),%esp
1095f9: 5b pop %ebx
1095fa: 5e pop %esi
1095fb: 5f pop %edi
1095fc: c9 leave
1095fd: c3 ret
00108706 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
108706: 55 push %ebp
108707: 89 e5 mov %esp,%ebp
108709: 57 push %edi
10870a: 56 push %esi
10870b: 53 push %ebx
10870c: 83 ec 20 sub $0x20,%esp
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
10870f: 8b 55 08 mov 0x8(%ebp),%edx
108712: 8b 02 mov (%edx),%eax
108714: 8b 58 34 mov 0x34(%eax),%ebx
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
108717: 8b 72 08 mov 0x8(%edx),%esi
rtems_status_code sc;
args->ioctl_return = 0;
10871a: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108721: 6a 00 push $0x0
108723: 6a 00 push $0x0
108725: ff 73 18 pushl 0x18(%ebx)
108728: e8 8f 1a 00 00 call 10a1bc <rtems_semaphore_obtain>
10872d: 89 45 e4 mov %eax,-0x1c(%ebp)
if (sc != RTEMS_SUCCESSFUL) {
108730: 83 c4 10 add $0x10,%esp
108733: 85 c0 test %eax,%eax
108735: 74 0b je 108742 <rtems_termios_ioctl+0x3c><== ALWAYS TAKEN
args->ioctl_return = sc;
108737: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
10873a: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED
return sc;
10873d: e9 05 03 00 00 jmp 108a47 <rtems_termios_ioctl+0x341><== NOT EXECUTED
}
switch (args->command) {
108742: 8b 55 08 mov 0x8(%ebp),%edx
108745: 8b 42 04 mov 0x4(%edx),%eax
108748: 83 f8 04 cmp $0x4,%eax
10874b: 0f 84 4d 02 00 00 je 10899e <rtems_termios_ioctl+0x298>
108751: 77 10 ja 108763 <rtems_termios_ioctl+0x5d>
108753: 83 f8 02 cmp $0x2,%eax
108756: 74 77 je 1087cf <rtems_termios_ioctl+0xc9>
108758: 0f 87 1e 02 00 00 ja 10897c <rtems_termios_ioctl+0x276>
10875e: 48 dec %eax
10875f: 75 2f jne 108790 <rtems_termios_ioctl+0x8a><== NEVER TAKEN
108761: eb 55 jmp 1087b8 <rtems_termios_ioctl+0xb2>
108763: 3d 7f 66 04 40 cmp $0x4004667f,%eax
108768: 0f 84 a5 02 00 00 je 108a13 <rtems_termios_ioctl+0x30d><== NEVER TAKEN
10876e: 77 0a ja 10877a <rtems_termios_ioctl+0x74>
108770: 83 f8 05 cmp $0x5,%eax
108773: 75 1b jne 108790 <rtems_termios_ioctl+0x8a>
108775: e9 0e 02 00 00 jmp 108988 <rtems_termios_ioctl+0x282>
10877a: 3d 1a 74 04 40 cmp $0x4004741a,%eax
10877f: 0f 84 7e 02 00 00 je 108a03 <rtems_termios_ioctl+0x2fd>
108785: 3d 1b 74 04 80 cmp $0x8004741b,%eax
10878a: 0f 84 21 02 00 00 je 1089b1 <rtems_termios_ioctl+0x2ab><== ALWAYS TAKEN
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
108790: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
108796: c1 e0 05 shl $0x5,%eax
108799: 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;
10879f: 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) {
1087a6: 85 c0 test %eax,%eax
1087a8: 0f 84 82 02 00 00 je 108a30 <rtems_termios_ioctl+0x32a><== NEVER TAKEN
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
1087ae: 52 push %edx
1087af: 52 push %edx
1087b0: ff 75 08 pushl 0x8(%ebp)
1087b3: e9 40 02 00 00 jmp 1089f8 <rtems_termios_ioctl+0x2f2>
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
1087b8: 8b 4d 08 mov 0x8(%ebp),%ecx
1087bb: 8b 41 08 mov 0x8(%ecx),%eax
1087be: 8d 73 30 lea 0x30(%ebx),%esi
1087c1: b9 09 00 00 00 mov $0x9,%ecx
1087c6: 89 c7 mov %eax,%edi
1087c8: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
break;
1087ca: e9 61 02 00 00 jmp 108a30 <rtems_termios_ioctl+0x32a>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
1087cf: 8b 45 08 mov 0x8(%ebp),%eax
1087d2: 8b 70 08 mov 0x8(%eax),%esi
1087d5: 8d 7b 30 lea 0x30(%ebx),%edi
1087d8: b9 09 00 00 00 mov $0x9,%ecx
1087dd: 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) &&
1087df: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1087e5: f6 c4 02 test $0x2,%ah
1087e8: 74 57 je 108841 <rtems_termios_ioctl+0x13b>
1087ea: f6 43 31 04 testb $0x4,0x31(%ebx)
1087ee: 75 51 jne 108841 <rtems_termios_ioctl+0x13b>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
1087f0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1087f6: 25 ef fd ff ff and $0xfffffdef,%eax
1087fb: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
108801: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108807: a8 20 test $0x20,%al
108809: 74 36 je 108841 <rtems_termios_ioctl+0x13b><== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
10880b: 9c pushf <== NOT EXECUTED
10880c: fa cli <== NOT EXECUTED
10880d: 5e pop %esi <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
10880e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108814: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
108817: 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) {
10881d: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
108824: 74 19 je 10883f <rtems_termios_ioctl+0x139><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
108826: 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)(
10882c: 57 push %edi <== NOT EXECUTED
10882d: 6a 01 push $0x1 <== NOT EXECUTED
10882f: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
108832: 50 push %eax <== NOT EXECUTED
108833: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
108836: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
10883c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
10883f: 56 push %esi <== NOT EXECUTED
108840: 9d popf <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
108841: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108847: f6 c4 04 test $0x4,%ah
10884a: 74 24 je 108870 <rtems_termios_ioctl+0x16a>
10884c: f6 43 31 10 testb $0x10,0x31(%ebx)
108850: 75 1e jne 108870 <rtems_termios_ioctl+0x16a><== NEVER TAKEN
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
108852: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108858: 80 e4 fb and $0xfb,%ah
10885b: 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);
108861: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108867: 83 e0 fd and $0xfffffffd,%eax
10886a: 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)) {
108870: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108876: f6 c4 01 test $0x1,%ah
108879: 74 43 je 1088be <rtems_termios_ioctl+0x1b8><== ALWAYS TAKEN
10887b: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED
10887f: 78 3d js 1088be <rtems_termios_ioctl+0x1b8><== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
108881: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108887: 80 e4 fe and $0xfe,%ah <== NOT EXECUTED
10888a: 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)) {
108890: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108896: a8 04 test $0x4,%al <== NOT EXECUTED
108898: 74 15 je 1088af <rtems_termios_ioctl+0x1a9><== NOT EXECUTED
10889a: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED
1088a0: 85 c0 test %eax,%eax <== NOT EXECUTED
1088a2: 74 0b je 1088af <rtems_termios_ioctl+0x1a9><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
1088a4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1088a7: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1088aa: ff d0 call *%eax <== NOT EXECUTED
1088ac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
1088af: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1088b5: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
1088b8: 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) {
1088be: 83 7b 38 00 cmpl $0x0,0x38(%ebx)
1088c2: 79 0f jns 1088d3 <rtems_termios_ioctl+0x1cd><== ALWAYS TAKEN
tty->flow_ctrl |= FL_MDRTS;
1088c4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1088ca: 80 cc 01 or $0x1,%ah <== NOT EXECUTED
1088cd: 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) {
1088d3: 8b 53 30 mov 0x30(%ebx),%edx
1088d6: f6 c6 10 test $0x10,%dh
1088d9: 74 0f je 1088ea <rtems_termios_ioctl+0x1e4>
tty->flow_ctrl |= FL_MDXOF;
1088db: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1088e1: 80 cc 04 or $0x4,%ah
1088e4: 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) {
1088ea: 80 e6 04 and $0x4,%dh
1088ed: 74 0f je 1088fe <rtems_termios_ioctl+0x1f8>
tty->flow_ctrl |= FL_MDXON;
1088ef: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1088f5: 80 cc 02 or $0x2,%ah
1088f8: 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) {
1088fe: f6 43 3c 02 testb $0x2,0x3c(%ebx)
108902: 75 39 jne 10893d <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] *
108904: 0f b6 73 46 movzbl 0x46(%ebx),%esi
rtems_clock_get_ticks_per_second() / 10;
108908: e8 6f 12 00 00 call 109b7c <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] *
10890d: 0f af c6 imul %esi,%eax
rtems_clock_get_ticks_per_second() / 10;
108910: b9 0a 00 00 00 mov $0xa,%ecx
108915: 31 d2 xor %edx,%edx
108917: 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] *
108919: 89 43 54 mov %eax,0x54(%ebx)
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
10891c: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
108920: 74 15 je 108937 <rtems_termios_ioctl+0x231>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
108922: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
108929: 89 43 70 mov %eax,0x70(%ebx)
if (tty->termios.c_cc[VMIN])
10892c: 80 7b 47 00 cmpb $0x0,0x47(%ebx)
108930: 75 19 jne 10894b <rtems_termios_ioctl+0x245>
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
108932: 89 43 74 mov %eax,0x74(%ebx)
108935: eb 24 jmp 10895b <rtems_termios_ioctl+0x255>
} else {
if (tty->termios.c_cc[VMIN]) {
108937: 80 7b 47 00 cmpb $0x0,0x47(%ebx)
10893b: 74 17 je 108954 <rtems_termios_ioctl+0x24e><== ALWAYS TAKEN
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
10893d: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
108944: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx)
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
10894b: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx)
108952: eb 07 jmp 10895b <rtems_termios_ioctl+0x255>
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
108954: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx)
}
}
}
if (tty->device.setAttributes)
10895b: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax
108961: 85 c0 test %eax,%eax
108963: 0f 84 c7 00 00 00 je 108a30 <rtems_termios_ioctl+0x32a><== NEVER TAKEN
(*tty->device.setAttributes)(tty->minor, &tty->termios);
108969: 56 push %esi
10896a: 56 push %esi
10896b: 8d 53 30 lea 0x30(%ebx),%edx
10896e: 52 push %edx
10896f: ff 73 10 pushl 0x10(%ebx)
108972: ff d0 call *%eax
108974: 83 c4 10 add $0x10,%esp
108977: e9 b4 00 00 00 jmp 108a30 <rtems_termios_ioctl+0x32a>
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
10897c: 89 d8 mov %ebx,%eax
10897e: e8 55 f7 ff ff call 1080d8 <drainOutput>
break;
108983: e9 a8 00 00 00 jmp 108a30 <rtems_termios_ioctl+0x32a>
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
108988: 8b 06 mov (%esi),%eax
10898a: 8b 56 04 mov 0x4(%esi),%edx
10898d: 89 83 d4 00 00 00 mov %eax,0xd4(%ebx)
108993: 89 93 d8 00 00 00 mov %edx,0xd8(%ebx)
break;
108999: e9 92 00 00 00 jmp 108a30 <rtems_termios_ioctl+0x32a>
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
10899e: 8b 06 mov (%esi),%eax
1089a0: 8b 56 04 mov 0x4(%esi),%edx
1089a3: 89 83 dc 00 00 00 mov %eax,0xdc(%ebx)
1089a9: 89 93 e0 00 00 00 mov %edx,0xe0(%ebx)
break;
1089af: eb 7f jmp 108a30 <rtems_termios_ioctl+0x32a>
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
1089b1: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
1089b7: c1 e0 05 shl $0x5,%eax
1089ba: 8b 80 f8 4e 12 00 mov 0x124ef8(%eax),%eax
1089c0: 85 c0 test %eax,%eax
1089c2: 74 0c je 1089d0 <rtems_termios_ioctl+0x2ca>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
1089c4: 83 ec 0c sub $0xc,%esp
1089c7: 53 push %ebx
1089c8: ff d0 call *%eax
1089ca: 89 45 e4 mov %eax,-0x1c(%ebp)
1089cd: 83 c4 10 add $0x10,%esp
}
tty->t_line=*(int*)(args->buffer);
1089d0: 8b 55 08 mov 0x8(%ebp),%edx
1089d3: 8b 42 08 mov 0x8(%edx),%eax
1089d6: 8b 00 mov (%eax),%eax
1089d8: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx)
tty->t_sc = NULL; /* ensure that no more valid data */
1089de: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx)
1089e5: 00 00 00
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
1089e8: c1 e0 05 shl $0x5,%eax
1089eb: 8b 80 f4 4e 12 00 mov 0x124ef4(%eax),%eax
1089f1: 85 c0 test %eax,%eax
1089f3: 74 3b je 108a30 <rtems_termios_ioctl+0x32a><== NEVER TAKEN
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
1089f5: 83 ec 0c sub $0xc,%esp
1089f8: 53 push %ebx
1089f9: ff d0 call *%eax
1089fb: 89 45 e4 mov %eax,-0x1c(%ebp)
1089fe: e9 71 ff ff ff jmp 108974 <rtems_termios_ioctl+0x26e>
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
108a03: 8b 4d 08 mov 0x8(%ebp),%ecx
108a06: 8b 41 08 mov 0x8(%ecx),%eax
108a09: 8b 93 cc 00 00 00 mov 0xcc(%ebx),%edx
108a0f: 89 10 mov %edx,(%eax)
break;
108a11: eb 1d jmp 108a30 <rtems_termios_ioctl+0x32a>
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
108a13: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED
108a16: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED
if ( rawnc < 0 )
108a19: 29 d0 sub %edx,%eax <== NOT EXECUTED
108a1b: 79 05 jns 108a22 <rtems_termios_ioctl+0x31c><== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
108a1d: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED
108a20: 01 d0 add %edx,%eax <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
108a22: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
108a25: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED
108a28: 03 43 20 add 0x20(%ebx),%eax <== NOT EXECUTED
108a2b: 2b 43 24 sub 0x24(%ebx),%eax <== NOT EXECUTED
108a2e: 89 02 mov %eax,(%edx) <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
108a30: 83 ec 0c sub $0xc,%esp
108a33: ff 73 18 pushl 0x18(%ebx)
108a36: e8 6d 18 00 00 call 10a2a8 <rtems_semaphore_release>
args->ioctl_return = sc;
108a3b: 8b 55 e4 mov -0x1c(%ebp),%edx
108a3e: 8b 45 08 mov 0x8(%ebp),%eax
108a41: 89 50 0c mov %edx,0xc(%eax)
return sc;
108a44: 83 c4 10 add $0x10,%esp
}
108a47: 8b 45 e4 mov -0x1c(%ebp),%eax
108a4a: 8d 65 f4 lea -0xc(%ebp),%esp
108a4d: 5b pop %ebx
108a4e: 5e pop %esi
108a4f: 5f pop %edi
108a50: c9 leave
108a51: c3 ret
00108135 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
108135: 55 push %ebp
108136: 89 e5 mov %esp,%ebp
108138: 57 push %edi
108139: 56 push %esi
10813a: 53 push %ebx
10813b: 83 ec 20 sub $0x20,%esp
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
10813e: 6a 00 push $0x0
108140: 6a 00 push $0x0
108142: ff 35 3c 52 12 00 pushl 0x12523c
108148: e8 6f 20 00 00 call 10a1bc <rtems_semaphore_obtain>
10814d: 89 45 e4 mov %eax,-0x1c(%ebp)
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
108150: 83 c4 10 add $0x10,%esp
108153: 85 c0 test %eax,%eax
108155: 0f 85 d3 03 00 00 jne 10852e <rtems_termios_open+0x3f9><== NEVER TAKEN
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
10815b: 8b 35 44 52 12 00 mov 0x125244,%esi
108161: 89 f2 mov %esi,%edx
108163: eb 16 jmp 10817b <rtems_termios_open+0x46>
if ((tty->major == major) && (tty->minor == minor))
108165: 8b 45 08 mov 0x8(%ebp),%eax
108168: 39 42 0c cmp %eax,0xc(%edx)
10816b: 75 0c jne 108179 <rtems_termios_open+0x44>
10816d: 8b 4d 0c mov 0xc(%ebp),%ecx
108170: 39 4a 10 cmp %ecx,0x10(%edx)
108173: 0f 84 26 03 00 00 je 10849f <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) {
108179: 8b 12 mov (%edx),%edx
10817b: 85 d2 test %edx,%edx
10817d: 75 e6 jne 108165 <rtems_termios_open+0x30>
10817f: e9 b5 03 00 00 jmp 108539 <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);
108184: 83 ec 0c sub $0xc,%esp
108187: eb 30 jmp 1081b9 <rtems_termios_open+0x84>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
108189: a1 74 30 12 00 mov 0x123074,%eax
10818e: 89 42 64 mov %eax,0x64(%edx)
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
108191: 8b 42 64 mov 0x64(%edx),%eax
108194: 83 ec 0c sub $0xc,%esp
108197: 50 push %eax
108198: 89 55 e0 mov %edx,-0x20(%ebp)
10819b: e8 74 f4 ff ff call 107614 <malloc>
1081a0: 89 c7 mov %eax,%edi
1081a2: 8b 55 e0 mov -0x20(%ebp),%edx
1081a5: 89 42 58 mov %eax,0x58(%edx)
if (tty->rawInBuf.theBuf == NULL) {
1081a8: 83 c4 10 add $0x10,%esp
1081ab: 85 c0 test %eax,%eax
1081ad: 75 24 jne 1081d3 <rtems_termios_open+0x9e>
free(tty);
1081af: 83 ec 0c sub $0xc,%esp
1081b2: 52 push %edx
1081b3: e8 c0 f1 ff ff call 107378 <free>
rtems_semaphore_release (rtems_termios_ttyMutex);
1081b8: 5b pop %ebx
1081b9: ff 35 3c 52 12 00 pushl 0x12523c
1081bf: e8 e4 20 00 00 call 10a2a8 <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
1081c4: 83 c4 10 add $0x10,%esp
1081c7: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp)
1081ce: e9 5b 03 00 00 jmp 10852e <rtems_termios_open+0x3f9>
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
1081d3: a1 78 30 12 00 mov 0x123078,%eax
1081d8: 89 82 88 00 00 00 mov %eax,0x88(%edx)
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
1081de: 8b 82 88 00 00 00 mov 0x88(%edx),%eax
1081e4: 83 ec 0c sub $0xc,%esp
1081e7: 50 push %eax
1081e8: 89 55 e0 mov %edx,-0x20(%ebp)
1081eb: e8 24 f4 ff ff call 107614 <malloc>
1081f0: 8b 55 e0 mov -0x20(%ebp),%edx
1081f3: 89 42 7c mov %eax,0x7c(%edx)
if (tty->rawOutBuf.theBuf == NULL) {
1081f6: 83 c4 10 add $0x10,%esp
1081f9: 85 c0 test %eax,%eax
1081fb: 75 05 jne 108202 <rtems_termios_open+0xcd><== ALWAYS TAKEN
free((void *)(tty->rawInBuf.theBuf));
1081fd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108200: eb 2e jmp 108230 <rtems_termios_open+0xfb><== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
108202: 83 ec 0c sub $0xc,%esp
108205: ff 35 70 30 12 00 pushl 0x123070
10820b: 89 55 e0 mov %edx,-0x20(%ebp)
10820e: 89 45 dc mov %eax,-0x24(%ebp)
108211: e8 fe f3 ff ff call 107614 <malloc>
108216: 8b 55 e0 mov -0x20(%ebp),%edx
108219: 89 42 1c mov %eax,0x1c(%edx)
if (tty->cbuf == NULL) {
10821c: 83 c4 10 add $0x10,%esp
10821f: 85 c0 test %eax,%eax
108221: 8b 4d dc mov -0x24(%ebp),%ecx
108224: 75 19 jne 10823f <rtems_termios_open+0x10a>
free((void *)(tty->rawOutBuf.theBuf));
108226: 83 ec 0c sub $0xc,%esp
108229: 51 push %ecx
10822a: e8 49 f1 ff ff call 107378 <free>
free((void *)(tty->rawInBuf.theBuf));
10822f: 59 pop %ecx
108230: 57 push %edi
108231: e8 42 f1 ff ff call 107378 <free>
free(tty);
108236: 5a pop %edx
108237: 8b 55 e0 mov -0x20(%ebp),%edx
10823a: e9 73 ff ff ff jmp 1081b2 <rtems_termios_open+0x7d>
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
10823f: c7 82 d4 00 00 00 00 movl $0x0,0xd4(%edx)
108246: 00 00 00
tty->tty_snd.sw_arg = NULL;
108249: c7 82 d8 00 00 00 00 movl $0x0,0xd8(%edx)
108250: 00 00 00
tty->tty_rcv.sw_pfn = NULL;
108253: c7 82 dc 00 00 00 00 movl $0x0,0xdc(%edx)
10825a: 00 00 00
tty->tty_rcv.sw_arg = NULL;
10825d: c7 82 e0 00 00 00 00 movl $0x0,0xe0(%edx)
108264: 00 00 00
tty->tty_rcvwakeup = 0;
108267: c7 82 e4 00 00 00 00 movl $0x0,0xe4(%edx)
10826e: 00 00 00
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
108271: 89 32 mov %esi,(%edx)
tty->back = NULL;
108273: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
if (rtems_termios_ttyHead != NULL)
10827a: 85 f6 test %esi,%esi
10827c: 74 03 je 108281 <rtems_termios_open+0x14c>
rtems_termios_ttyHead->back = tty;
10827e: 89 56 04 mov %edx,0x4(%esi)
rtems_termios_ttyHead = tty;
108281: 89 1d 44 52 12 00 mov %ebx,0x125244
if (rtems_termios_ttyTail == NULL)
108287: 83 3d 40 52 12 00 00 cmpl $0x0,0x125240
10828e: 75 06 jne 108296 <rtems_termios_open+0x161>
rtems_termios_ttyTail = tty;
108290: 89 1d 40 52 12 00 mov %ebx,0x125240
tty->minor = minor;
108296: 8b 45 0c mov 0xc(%ebp),%eax
108299: 89 43 10 mov %eax,0x10(%ebx)
tty->major = major;
10829c: 8b 4d 08 mov 0x8(%ebp),%ecx
10829f: 89 4b 0c mov %ecx,0xc(%ebx)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
1082a2: 83 ec 0c sub $0xc,%esp
1082a5: 8d 43 14 lea 0x14(%ebx),%eax
1082a8: 50 push %eax
1082a9: 6a 00 push $0x0
1082ab: 6a 54 push $0x54
1082ad: 6a 01 push $0x1
rtems_build_name ('T', 'R', 'i', c),
1082af: 0f be 05 7c 30 12 00 movsbl 0x12307c,%eax
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
1082b6: 0d 00 69 52 54 or $0x54526900,%eax
1082bb: 50 push %eax
1082bc: 89 55 e0 mov %edx,-0x20(%ebp)
1082bf: e8 d0 1c 00 00 call 109f94 <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)
1082c4: 83 c4 20 add $0x20,%esp
1082c7: 85 c0 test %eax,%eax
1082c9: 8b 55 e0 mov -0x20(%ebp),%edx
1082cc: 0f 85 42 02 00 00 jne 108514 <rtems_termios_open+0x3df>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
1082d2: 83 ec 0c sub $0xc,%esp
1082d5: 8d 43 18 lea 0x18(%ebx),%eax
1082d8: 50 push %eax
1082d9: 6a 00 push $0x0
1082db: 6a 54 push $0x54
1082dd: 6a 01 push $0x1
rtems_build_name ('T', 'R', 'o', c),
1082df: 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 (
1082e6: 0d 00 6f 52 54 or $0x54526f00,%eax
1082eb: 50 push %eax
1082ec: 89 55 e0 mov %edx,-0x20(%ebp)
1082ef: e8 a0 1c 00 00 call 109f94 <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)
1082f4: 83 c4 20 add $0x20,%esp
1082f7: 85 c0 test %eax,%eax
1082f9: 8b 55 e0 mov -0x20(%ebp),%edx
1082fc: 0f 85 12 02 00 00 jne 108514 <rtems_termios_open+0x3df>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
108302: 83 ec 0c sub $0xc,%esp
108305: 8d 83 8c 00 00 00 lea 0x8c(%ebx),%eax
10830b: 50 push %eax
10830c: 6a 00 push $0x0
10830e: 6a 20 push $0x20
108310: 6a 00 push $0x0
rtems_build_name ('T', 'R', 'x', c),
108312: 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 (
108319: 0d 00 78 52 54 or $0x54527800,%eax
10831e: 50 push %eax
10831f: 89 55 e0 mov %edx,-0x20(%ebp)
108322: e8 6d 1c 00 00 call 109f94 <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)
108327: 83 c4 20 add $0x20,%esp
10832a: 85 c0 test %eax,%eax
10832c: 8b 55 e0 mov -0x20(%ebp),%edx
10832f: 0f 85 df 01 00 00 jne 108514 <rtems_termios_open+0x3df>
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
108335: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx)
10833c: 00 00 00
/*
* Set callbacks
*/
tty->device = *callbacks;
10833f: 8d bb 98 00 00 00 lea 0x98(%ebx),%edi
108345: b9 08 00 00 00 mov $0x8,%ecx
10834a: 8b 75 14 mov 0x14(%ebp),%esi
10834d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
10834f: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
108356: 75 74 jne 1083cc <rtems_termios_open+0x297>
sc = rtems_task_create (
108358: 50 push %eax
108359: 50 push %eax
10835a: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax
108360: 50 push %eax
108361: 6a 00 push $0x0
108363: 68 00 05 00 00 push $0x500
108368: 68 00 04 00 00 push $0x400
10836d: 6a 0a push $0xa
rtems_build_name ('T', 'x', 'T', c),
10836f: 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 (
108376: 0d 00 54 78 54 or $0x54785400,%eax
10837b: 50 push %eax
10837c: 89 55 e0 mov %edx,-0x20(%ebp)
10837f: e8 b4 1f 00 00 call 10a338 <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)
108384: 83 c4 20 add $0x20,%esp
108387: 85 c0 test %eax,%eax
108389: 8b 55 e0 mov -0x20(%ebp),%edx
10838c: 0f 85 82 01 00 00 jne 108514 <rtems_termios_open+0x3df><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
108392: 57 push %edi
108393: 57 push %edi
108394: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax
10839a: 50 push %eax
10839b: 6a 00 push $0x0
10839d: 68 00 05 00 00 push $0x500
1083a2: 68 00 04 00 00 push $0x400
1083a7: 6a 09 push $0x9
rtems_build_name ('R', 'x', 'T', c),
1083a9: 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 (
1083b0: 0d 00 54 78 52 or $0x52785400,%eax
1083b5: 50 push %eax
1083b6: 89 55 e0 mov %edx,-0x20(%ebp)
1083b9: e8 7a 1f 00 00 call 10a338 <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)
1083be: 83 c4 20 add $0x20,%esp
1083c1: 85 c0 test %eax,%eax
1083c3: 8b 55 e0 mov -0x20(%ebp),%edx
1083c6: 0f 85 48 01 00 00 jne 108514 <rtems_termios_open+0x3df><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
1083cc: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
1083d3: 74 09 je 1083de <rtems_termios_open+0x2a9>
1083d5: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
1083dc: 75 30 jne 10840e <rtems_termios_open+0x2d9>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
1083de: 83 ec 0c sub $0xc,%esp
1083e1: 8d 43 68 lea 0x68(%ebx),%eax
1083e4: 50 push %eax
1083e5: 6a 00 push $0x0
1083e7: 6a 24 push $0x24
1083e9: 6a 00 push $0x0
rtems_build_name ('T', 'R', 'r', c),
1083eb: 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 (
1083f2: 0d 00 72 52 54 or $0x54527200,%eax
1083f7: 50 push %eax
1083f8: 89 55 e0 mov %edx,-0x20(%ebp)
1083fb: e8 94 1b 00 00 call 109f94 <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)
108400: 83 c4 20 add $0x20,%esp
108403: 85 c0 test %eax,%eax
108405: 8b 55 e0 mov -0x20(%ebp),%edx
108408: 0f 85 06 01 00 00 jne 108514 <rtems_termios_open+0x3df>
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
10840e: c7 43 30 02 25 00 00 movl $0x2502,0x30(%ebx)
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
108415: c7 43 34 05 18 00 00 movl $0x1805,0x34(%ebx)
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
10841c: c7 43 38 bd 08 00 00 movl $0x8bd,0x38(%ebx)
tty->termios.c_lflag =
108423: c7 43 3c 3b 82 00 00 movl $0x823b,0x3c(%ebx)
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
10842a: c6 43 41 03 movb $0x3,0x41(%ebx)
tty->termios.c_cc[VQUIT] = '\034';
10842e: c6 43 42 1c movb $0x1c,0x42(%ebx)
tty->termios.c_cc[VERASE] = '\177';
108432: c6 43 43 7f movb $0x7f,0x43(%ebx)
tty->termios.c_cc[VKILL] = '\025';
108436: c6 43 44 15 movb $0x15,0x44(%ebx)
tty->termios.c_cc[VEOF] = '\004';
10843a: c6 43 45 04 movb $0x4,0x45(%ebx)
tty->termios.c_cc[VEOL] = '\000';
10843e: c6 43 4c 00 movb $0x0,0x4c(%ebx)
tty->termios.c_cc[VEOL2] = '\000';
108442: c6 43 51 00 movb $0x0,0x51(%ebx)
tty->termios.c_cc[VSTART] = '\021';
108446: c6 43 49 11 movb $0x11,0x49(%ebx)
tty->termios.c_cc[VSTOP] = '\023';
10844a: c6 43 4a 13 movb $0x13,0x4a(%ebx)
tty->termios.c_cc[VSUSP] = '\032';
10844e: c6 43 4b 1a movb $0x1a,0x4b(%ebx)
tty->termios.c_cc[VREPRINT] = '\022';
108452: c6 43 4d 12 movb $0x12,0x4d(%ebx)
tty->termios.c_cc[VDISCARD] = '\017';
108456: c6 43 4e 0f movb $0xf,0x4e(%ebx)
tty->termios.c_cc[VWERASE] = '\027';
10845a: c6 43 4f 17 movb $0x17,0x4f(%ebx)
tty->termios.c_cc[VLNEXT] = '\026';
10845e: c6 43 50 16 movb $0x16,0x50(%ebx)
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
108462: c7 83 b8 00 00 00 00 movl $0x0,0xb8(%ebx)
108469: 00 00 00
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
10846c: 8b 43 64 mov 0x64(%ebx),%eax
10846f: d1 e8 shr %eax
108471: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
tty->highwater = tty->rawInBuf.Size * 3/4;
108477: 8b 43 64 mov 0x64(%ebx),%eax
10847a: 8d 04 40 lea (%eax,%eax,2),%eax
10847d: c1 e8 02 shr $0x2,%eax
108480: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx)
/*
* Bump name characer
*/
if (c++ == 'z')
108486: a0 7c 30 12 00 mov 0x12307c,%al
10848b: 8d 48 01 lea 0x1(%eax),%ecx
10848e: 88 0d 7c 30 12 00 mov %cl,0x12307c
108494: 3c 7a cmp $0x7a,%al
108496: 75 07 jne 10849f <rtems_termios_open+0x36a>
c = 'a';
108498: c6 05 7c 30 12 00 61 movb $0x61,0x12307c
}
args->iop->data1 = tty;
10849f: 8b 4d 10 mov 0x10(%ebp),%ecx
1084a2: 8b 01 mov (%ecx),%eax
1084a4: 89 50 34 mov %edx,0x34(%eax)
if (!tty->refcount++) {
1084a7: 8b 42 08 mov 0x8(%edx),%eax
1084aa: 8d 48 01 lea 0x1(%eax),%ecx
1084ad: 89 4a 08 mov %ecx,0x8(%edx)
1084b0: 85 c0 test %eax,%eax
1084b2: 75 69 jne 10851d <rtems_termios_open+0x3e8>
if (tty->device.firstOpen)
1084b4: 8b 82 98 00 00 00 mov 0x98(%edx),%eax
1084ba: 85 c0 test %eax,%eax
1084bc: 74 15 je 1084d3 <rtems_termios_open+0x39e>
(*tty->device.firstOpen)(major, minor, arg);
1084be: 56 push %esi
1084bf: ff 75 10 pushl 0x10(%ebp)
1084c2: ff 75 0c pushl 0xc(%ebp)
1084c5: ff 75 08 pushl 0x8(%ebp)
1084c8: 89 55 e0 mov %edx,-0x20(%ebp)
1084cb: ff d0 call *%eax
1084cd: 83 c4 10 add $0x10,%esp
1084d0: 8b 55 e0 mov -0x20(%ebp),%edx
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
1084d3: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx)
1084da: 75 41 jne 10851d <rtems_termios_open+0x3e8>
sc = rtems_task_start(
1084dc: 53 push %ebx
1084dd: 52 push %edx
1084de: 68 fe 95 10 00 push $0x1095fe
1084e3: ff b2 c4 00 00 00 pushl 0xc4(%edx)
1084e9: 89 55 e0 mov %edx,-0x20(%ebp)
1084ec: e8 bb 20 00 00 call 10a5ac <rtems_task_start>
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
1084f1: 83 c4 10 add $0x10,%esp
1084f4: 85 c0 test %eax,%eax
1084f6: 8b 55 e0 mov -0x20(%ebp),%edx
1084f9: 75 19 jne 108514 <rtems_termios_open+0x3df><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
1084fb: 51 push %ecx
1084fc: 52 push %edx
1084fd: 68 30 98 10 00 push $0x109830
108502: ff b2 c8 00 00 00 pushl 0xc8(%edx)
108508: e8 9f 20 00 00 call 10a5ac <rtems_task_start>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
10850d: 83 c4 10 add $0x10,%esp
108510: 85 c0 test %eax,%eax
108512: 74 09 je 10851d <rtems_termios_open+0x3e8><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
108514: 83 ec 0c sub $0xc,%esp
108517: 50 push %eax
108518: e8 6b 22 00 00 call 10a788 <rtems_fatal_error_occurred>
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
10851d: 83 ec 0c sub $0xc,%esp
108520: ff 35 3c 52 12 00 pushl 0x12523c
108526: e8 7d 1d 00 00 call 10a2a8 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
10852b: 83 c4 10 add $0x10,%esp
}
10852e: 8b 45 e4 mov -0x1c(%ebp),%eax
108531: 8d 65 f4 lea -0xc(%ebp),%esp
108534: 5b pop %ebx
108535: 5e pop %esi
108536: 5f pop %edi
108537: c9 leave
108538: c3 ret
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
108539: 52 push %edx
10853a: 52 push %edx
10853b: 68 e8 00 00 00 push $0xe8
108540: 6a 01 push $0x1
108542: e8 c5 ec ff ff call 10720c <calloc>
108547: 89 c2 mov %eax,%edx
108549: 89 c3 mov %eax,%ebx
if (tty == NULL) {
10854b: 83 c4 10 add $0x10,%esp
10854e: 85 c0 test %eax,%eax
108550: 0f 85 33 fc ff ff jne 108189 <rtems_termios_open+0x54>
108556: e9 29 fc ff ff jmp 108184 <rtems_termios_open+0x4f>
00108a52 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
108a52: 55 push %ebp
108a53: 89 e5 mov %esp,%ebp
108a55: 57 push %edi
108a56: 56 push %esi
108a57: 53 push %ebx
108a58: 83 ec 3c sub $0x3c,%esp
108a5b: 8b 45 08 mov 0x8(%ebp),%eax
108a5e: 8b 75 0c mov 0xc(%ebp),%esi
108a61: 8b 5d 10 mov 0x10(%ebp),%ebx
const unsigned char *buf = _buf;
108a64: 89 c7 mov %eax,%edi
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
108a66: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx)
108a6d: 75 1b jne 108a8a <rtems_termios_puts+0x38>
(*tty->device.write)(tty->minor, (void *)buf, len);
108a6f: 89 75 10 mov %esi,0x10(%ebp)
108a72: 89 45 0c mov %eax,0xc(%ebp)
108a75: 8b 43 10 mov 0x10(%ebx),%eax
108a78: 89 45 08 mov %eax,0x8(%ebp)
108a7b: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
108a81: 8d 65 f4 lea -0xc(%ebp),%esp
108a84: 5b pop %ebx
108a85: 5e pop %esi
108a86: 5f pop %edi
108a87: 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);
108a88: ff e0 jmp *%eax
return;
}
newHead = tty->rawOutBuf.Head;
108a8a: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
108a90: 89 45 e4 mov %eax,-0x1c(%ebp)
while (len) {
108a93: e9 ca 00 00 00 jmp 108b62 <rtems_termios_puts+0x110>
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
108a98: 8b 45 e4 mov -0x1c(%ebp),%eax
108a9b: 40 inc %eax
108a9c: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
108aa2: 31 d2 xor %edx,%edx
108aa4: f7 f1 div %ecx
108aa6: 89 55 c4 mov %edx,-0x3c(%ebp)
108aa9: 89 55 e4 mov %edx,-0x1c(%ebp)
rtems_interrupt_disable (level);
108aac: 9c pushf
108aad: fa cli
108aae: 8f 45 d4 popl -0x2c(%ebp)
108ab1: 8b 55 d4 mov -0x2c(%ebp),%edx
108ab4: 8b 4d c4 mov -0x3c(%ebp),%ecx
while (newHead == tty->rawOutBuf.Tail) {
108ab7: eb 35 jmp 108aee <rtems_termios_puts+0x9c>
tty->rawOutBufState = rob_wait;
108ab9: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
108ac0: 00 00 00
rtems_interrupt_enable (level);
108ac3: 52 push %edx
108ac4: 9d popf
sc = rtems_semaphore_obtain(
108ac5: 50 push %eax
108ac6: 6a 00 push $0x0
108ac8: 6a 00 push $0x0
108aca: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
108ad0: 89 4d e0 mov %ecx,-0x20(%ebp)
108ad3: e8 e4 16 00 00 call 10a1bc <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
108ad8: 83 c4 10 add $0x10,%esp
108adb: 85 c0 test %eax,%eax
108add: 8b 4d e0 mov -0x20(%ebp),%ecx
108ae0: 74 09 je 108aeb <rtems_termios_puts+0x99><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
108ae2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108ae5: 50 push %eax <== NOT EXECUTED
108ae6: e8 9d 1c 00 00 call 10a788 <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_interrupt_disable (level);
108aeb: 9c pushf
108aec: fa cli
108aed: 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) {
108aee: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
108af4: 39 c1 cmp %eax,%ecx
108af6: 74 c1 je 108ab9 <rtems_termios_puts+0x67>
108af8: 89 55 d4 mov %edx,-0x2c(%ebp)
108afb: 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++;
108afe: 8b 8b 80 00 00 00 mov 0x80(%ebx),%ecx
108b04: 8a 07 mov (%edi),%al
108b06: 8b 53 7c mov 0x7c(%ebx),%edx
108b09: 88 04 0a mov %al,(%edx,%ecx,1)
108b0c: 47 inc %edi
tty->rawOutBuf.Head = newHead;
108b0d: 8b 4d c4 mov -0x3c(%ebp),%ecx
108b10: 89 8b 80 00 00 00 mov %ecx,0x80(%ebx)
if (tty->rawOutBufState == rob_idle) {
108b16: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx)
108b1d: 75 3e jne 108b5d <rtems_termios_puts+0x10b>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
108b1f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108b25: a8 10 test $0x10,%al
108b27: 75 1b jne 108b44 <rtems_termios_puts+0xf2><== NEVER TAKEN
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
108b29: 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,
108b2f: 51 push %ecx
108b30: 6a 01 push $0x1
108b32: 03 43 7c add 0x7c(%ebx),%eax
108b35: 50 push %eax
108b36: ff 73 10 pushl 0x10(%ebx)
108b39: ff 93 a4 00 00 00 call *0xa4(%ebx)
108b3f: 83 c4 10 add $0x10,%esp
108b42: eb 0f jmp 108b53 <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;
108b44: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108b4a: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
108b4d: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
108b53: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
108b5a: 00 00 00
}
rtems_interrupt_enable (level);
108b5d: ff 75 d4 pushl -0x2c(%ebp)
108b60: 9d popf
len--;
108b61: 4e dec %esi
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
108b62: 85 f6 test %esi,%esi
108b64: 0f 85 2e ff ff ff jne 108a98 <rtems_termios_puts+0x46>
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
108b6a: 8d 65 f4 lea -0xc(%ebp),%esp
108b6d: 5b pop %ebx
108b6e: 5e pop %esi
108b6f: 5f pop %edi
108b70: c9 leave
108b71: c3 ret
00109079 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
109079: 55 push %ebp
10907a: 89 e5 mov %esp,%ebp
10907c: 57 push %edi
10907d: 56 push %esi
10907e: 53 push %ebx
10907f: 83 ec 40 sub $0x40,%esp
109082: 8b 75 08 mov 0x8(%ebp),%esi
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
109085: 8b 06 mov (%esi),%eax
109087: 8b 58 34 mov 0x34(%eax),%ebx
uint32_t count = args->count;
10908a: 8b 46 10 mov 0x10(%esi),%eax
10908d: 89 45 e4 mov %eax,-0x1c(%ebp)
char *buffer = args->buffer;
109090: 8b 46 0c mov 0xc(%esi),%eax
109093: 89 45 e0 mov %eax,-0x20(%ebp)
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
109096: 6a 00 push $0x0
109098: 6a 00 push $0x0
10909a: ff 73 14 pushl 0x14(%ebx)
10909d: e8 1a 11 00 00 call 10a1bc <rtems_semaphore_obtain>
1090a2: 89 45 dc mov %eax,-0x24(%ebp)
if (sc != RTEMS_SUCCESSFUL)
1090a5: 83 c4 10 add $0x10,%esp
1090a8: 85 c0 test %eax,%eax
1090aa: 0f 85 9d 02 00 00 jne 10934d <rtems_termios_read+0x2d4><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
1090b0: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
1090b6: c1 e0 05 shl $0x5,%eax
1090b9: 8b 80 fc 4e 12 00 mov 0x124efc(%eax),%eax
1090bf: 85 c0 test %eax,%eax
1090c1: 74 19 je 1090dc <rtems_termios_read+0x63>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
1090c3: 57 push %edi
1090c4: 57 push %edi
1090c5: 56 push %esi
1090c6: 53 push %ebx
1090c7: ff d0 call *%eax
1090c9: 89 45 dc mov %eax,-0x24(%ebp)
tty->tty_rcvwakeup = 0;
1090cc: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
1090d3: 00 00 00
rtems_semaphore_release (tty->isem);
1090d6: 59 pop %ecx
1090d7: e9 66 02 00 00 jmp 109342 <rtems_termios_read+0x2c9>
return sc;
}
if (tty->cindex == tty->ccount) {
1090dc: 8b 43 20 mov 0x20(%ebx),%eax
1090df: 39 43 24 cmp %eax,0x24(%ebx)
1090e2: 0f 85 2d 02 00 00 jne 109315 <rtems_termios_read+0x29c><== NEVER TAKEN
tty->cindex = tty->ccount = 0;
1090e8: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
1090ef: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
tty->read_start_column = tty->column;
1090f6: 8b 43 28 mov 0x28(%ebx),%eax
1090f9: 89 43 2c mov %eax,0x2c(%ebx)
if (tty->device.pollRead != NULL &&
1090fc: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
109103: 0f 84 c4 00 00 00 je 1091cd <rtems_termios_read+0x154>
109109: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx)
109110: 0f 85 b7 00 00 00 jne 1091cd <rtems_termios_read+0x154>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
109116: f6 43 3c 02 testb $0x2,0x3c(%ebx)
10911a: 74 35 je 109151 <rtems_termios_read+0xd8>
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
10911c: 83 ec 0c sub $0xc,%esp
10911f: ff 73 10 pushl 0x10(%ebx)
109122: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (n < 0) {
109128: 83 c4 10 add $0x10,%esp
10912b: 85 c0 test %eax,%eax
10912d: 79 0f jns 10913e <rtems_termios_read+0xc5>
rtems_task_wake_after (1);
10912f: 83 ec 0c sub $0xc,%esp
109132: 6a 01 push $0x1
109134: e8 d7 14 00 00 call 10a610 <rtems_task_wake_after>
109139: 83 c4 10 add $0x10,%esp
10913c: eb de jmp 10911c <rtems_termios_read+0xa3>
} else {
if (siproc (n, tty))
10913e: 0f b6 c0 movzbl %al,%eax
109141: 89 da mov %ebx,%edx
109143: e8 38 fe ff ff call 108f80 <siproc>
109148: 85 c0 test %eax,%eax
10914a: 74 d0 je 10911c <rtems_termios_read+0xa3>
10914c: e9 c4 01 00 00 jmp 109315 <rtems_termios_read+0x29c>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
109151: e8 3a 0a 00 00 call 109b90 <rtems_clock_get_ticks_since_boot>
109156: 89 c7 mov %eax,%edi
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
109158: 83 ec 0c sub $0xc,%esp
10915b: ff 73 10 pushl 0x10(%ebx)
10915e: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (n < 0) {
109164: 83 c4 10 add $0x10,%esp
109167: 85 c0 test %eax,%eax
109169: 79 3d jns 1091a8 <rtems_termios_read+0x12f>
if (tty->termios.c_cc[VMIN]) {
10916b: 80 7b 47 00 cmpb $0x0,0x47(%ebx)
10916f: 74 0e je 10917f <rtems_termios_read+0x106><== NEVER TAKEN
if (tty->termios.c_cc[VTIME] && tty->ccount) {
109171: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
109175: 74 22 je 109199 <rtems_termios_read+0x120><== NEVER TAKEN
109177: 83 7b 20 00 cmpl $0x0,0x20(%ebx)
10917b: 74 1c je 109199 <rtems_termios_read+0x120>
10917d: eb 0a jmp 109189 <rtems_termios_read+0x110>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
10917f: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED
109183: 0f 84 8c 01 00 00 je 109315 <rtems_termios_read+0x29c><== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
109189: e8 02 0a 00 00 call 109b90 <rtems_clock_get_ticks_since_boot>
if ((now - then) > tty->vtimeTicks) {
10918e: 29 f8 sub %edi,%eax
109190: 3b 43 54 cmp 0x54(%ebx),%eax
109193: 0f 87 7c 01 00 00 ja 109315 <rtems_termios_read+0x29c>
break;
}
}
rtems_task_wake_after (1);
109199: 83 ec 0c sub $0xc,%esp
10919c: 6a 01 push $0x1
10919e: e8 6d 14 00 00 call 10a610 <rtems_task_wake_after>
1091a3: 83 c4 10 add $0x10,%esp
1091a6: eb b0 jmp 109158 <rtems_termios_read+0xdf>
} else {
siproc (n, tty);
1091a8: 0f b6 c0 movzbl %al,%eax
1091ab: 89 da mov %ebx,%edx
1091ad: e8 ce fd ff ff call 108f80 <siproc>
if (tty->ccount >= tty->termios.c_cc[VMIN])
1091b2: 8a 43 47 mov 0x47(%ebx),%al
1091b5: 0f b6 d0 movzbl %al,%edx
1091b8: 39 53 20 cmp %edx,0x20(%ebx)
1091bb: 0f 8d 54 01 00 00 jge 109315 <rtems_termios_read+0x29c><== NEVER TAKEN
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
1091c1: 84 c0 test %al,%al
1091c3: 74 93 je 109158 <rtems_termios_read+0xdf><== NEVER TAKEN
1091c5: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
1091c9: 74 8d je 109158 <rtems_termios_read+0xdf><== NEVER TAKEN
1091cb: eb 84 jmp 109151 <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;
1091cd: 8b 53 74 mov 0x74(%ebx),%edx
rtems_status_code sc;
int wait = (int)1;
1091d0: 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)(
1091d5: 8d 43 49 lea 0x49(%ebx),%eax
1091d8: 89 45 d0 mov %eax,-0x30(%ebp)
1091db: e9 e6 00 00 00 jmp 1092c6 <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;
1091e0: 8b 43 5c mov 0x5c(%ebx),%eax
1091e3: 8b 4b 64 mov 0x64(%ebx),%ecx
1091e6: 40 inc %eax
1091e7: 31 d2 xor %edx,%edx
1091e9: f7 f1 div %ecx
c = tty->rawInBuf.theBuf[newHead];
1091eb: 8b 43 58 mov 0x58(%ebx),%eax
1091ee: 8a 04 10 mov (%eax,%edx,1),%al
1091f1: 88 45 db mov %al,-0x25(%ebp)
tty->rawInBuf.Head = newHead;
1091f4: 89 53 5c mov %edx,0x5c(%ebx)
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
1091f7: 8b 43 60 mov 0x60(%ebx),%eax
1091fa: 89 45 c4 mov %eax,-0x3c(%ebp)
1091fd: 8b 4b 64 mov 0x64(%ebx),%ecx
% tty->rawInBuf.Size)
109200: 8b 43 64 mov 0x64(%ebx),%eax
109203: 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)
109206: 8b 45 c4 mov -0x3c(%ebp),%eax
109209: 8d 04 01 lea (%ecx,%eax,1),%eax
10920c: 29 d0 sub %edx,%eax
% tty->rawInBuf.Size)
10920e: 31 d2 xor %edx,%edx
109210: 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)
109213: 3b 93 bc 00 00 00 cmp 0xbc(%ebx),%edx
109219: 73 74 jae 10928f <rtems_termios_read+0x216><== NEVER TAKEN
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
10921b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109221: 83 e0 fe and $0xfffffffe,%eax
109224: 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))
10922a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109230: 25 02 02 00 00 and $0x202,%eax
109235: 3d 02 02 00 00 cmp $0x202,%eax
10923a: 75 24 jne 109260 <rtems_termios_read+0x1e7><== ALWAYS TAKEN
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
10923c: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
109243: 74 0a je 10924f <rtems_termios_read+0x1d6><== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
109245: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10924b: a8 20 test $0x20,%al <== NOT EXECUTED
10924d: 74 11 je 109260 <rtems_termios_read+0x1e7><== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
10924f: 52 push %edx <== NOT EXECUTED
109250: 6a 01 push $0x1 <== NOT EXECUTED
109252: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED
109255: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109258: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
10925e: eb 2c jmp 10928c <rtems_termios_read+0x213><== NOT EXECUTED
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
109260: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109266: f6 c4 01 test $0x1,%ah
109269: 74 24 je 10928f <rtems_termios_read+0x216><== ALWAYS TAKEN
tty->flow_ctrl &= ~FL_IRTSOFF;
10926b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109271: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
109274: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
10927a: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED
109280: 85 c0 test %eax,%eax <== NOT EXECUTED
109282: 74 0b je 10928f <rtems_termios_read+0x216><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
109284: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109287: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10928a: ff d0 call *%eax <== NOT EXECUTED
10928c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
10928f: f6 43 3c 02 testb $0x2,0x3c(%ebx)
109293: 74 12 je 1092a7 <rtems_termios_read+0x22e><== NEVER TAKEN
if (siproc (c, tty))
109295: 0f b6 45 db movzbl -0x25(%ebp),%eax
109299: 89 da mov %ebx,%edx
10929b: e8 e0 fc ff ff call 108f80 <siproc>
wait = 0;
1092a0: 85 c0 test %eax,%eax
1092a2: 0f 94 c0 sete %al
1092a5: eb 15 jmp 1092bc <rtems_termios_read+0x243>
} else {
siproc (c, tty);
1092a7: 0f b6 45 db movzbl -0x25(%ebp),%eax <== NOT EXECUTED
1092ab: 89 da mov %ebx,%edx <== NOT EXECUTED
1092ad: e8 ce fc ff ff call 108f80 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
1092b2: 0f b6 43 47 movzbl 0x47(%ebx),%eax <== NOT EXECUTED
wait = 0;
1092b6: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED
1092b9: 0f 9c c0 setl %al <== NOT EXECUTED
1092bc: 0f b6 c0 movzbl %al,%eax
1092bf: f7 d8 neg %eax
1092c1: 21 c7 and %eax,%edi
}
timeout = tty->rawInBufSemaphoreTimeout;
1092c3: 8b 53 70 mov 0x70(%ebx),%edx
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
1092c6: 8b 4b 5c mov 0x5c(%ebx),%ecx
1092c9: 8b 43 60 mov 0x60(%ebx),%eax
1092cc: 39 c1 cmp %eax,%ecx
1092ce: 74 0f je 1092df <rtems_termios_read+0x266>
(tty->ccount < (CBUFSIZE-1))) {
1092d0: a1 70 30 12 00 mov 0x123070,%eax
1092d5: 48 dec %eax
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
1092d6: 39 43 20 cmp %eax,0x20(%ebx)
1092d9: 0f 8c 01 ff ff ff jl 1091e0 <rtems_termios_read+0x167><== ALWAYS TAKEN
}
/*
* Wait for characters
*/
if ( wait ) {
1092df: 85 ff test %edi,%edi
1092e1: 74 32 je 109315 <rtems_termios_read+0x29c>
sc = rtems_semaphore_obtain(
1092e3: 50 push %eax
1092e4: 52 push %edx
1092e5: ff 73 6c pushl 0x6c(%ebx)
1092e8: ff 73 68 pushl 0x68(%ebx)
1092eb: 89 55 cc mov %edx,-0x34(%ebp)
1092ee: e8 c9 0e 00 00 call 10a1bc <rtems_semaphore_obtain>
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
1092f3: 83 c4 10 add $0x10,%esp
1092f6: 85 c0 test %eax,%eax
1092f8: 8b 55 cc mov -0x34(%ebp),%edx
1092fb: 74 c9 je 1092c6 <rtems_termios_read+0x24d><== ALWAYS TAKEN
1092fd: eb 16 jmp 109315 <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++];
1092ff: 8b 7b 1c mov 0x1c(%ebx),%edi
109302: 8b 45 e4 mov -0x1c(%ebp),%eax
109305: 8a 04 07 mov (%edi,%eax,1),%al
109308: 88 01 mov %al,(%ecx)
10930a: 41 inc %ecx
10930b: 8b 45 e4 mov -0x1c(%ebp),%eax
10930e: 40 inc %eax
10930f: 89 43 24 mov %eax,0x24(%ebx)
count--;
109312: 4a dec %edx
109313: eb 06 jmp 10931b <rtems_termios_read+0x2a2>
109315: 8b 55 e4 mov -0x1c(%ebp),%edx
109318: 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)) {
10931b: 85 d2 test %edx,%edx
10931d: 74 0b je 10932a <rtems_termios_read+0x2b1>
10931f: 8b 43 24 mov 0x24(%ebx),%eax
109322: 89 45 e4 mov %eax,-0x1c(%ebp)
109325: 3b 43 20 cmp 0x20(%ebx),%eax
109328: 7c d5 jl 1092ff <rtems_termios_read+0x286>
10932a: 89 55 e4 mov %edx,-0x1c(%ebp)
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
10932d: 8b 46 10 mov 0x10(%esi),%eax
109330: 29 d0 sub %edx,%eax
109332: 89 46 18 mov %eax,0x18(%esi)
tty->tty_rcvwakeup = 0;
109335: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10933c: 00 00 00
rtems_semaphore_release (tty->isem);
10933f: 83 ec 0c sub $0xc,%esp
109342: ff 73 14 pushl 0x14(%ebx)
109345: e8 5e 0f 00 00 call 10a2a8 <rtems_semaphore_release>
return sc;
10934a: 83 c4 10 add $0x10,%esp
}
10934d: 8b 45 dc mov -0x24(%ebp),%eax
109350: 8d 65 f4 lea -0xc(%ebp),%esp
109353: 5b pop %ebx
109354: 5e pop %esi
109355: 5f pop %edi
109356: c9 leave
109357: c3 ret
00109662 <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)
{
109662: 55 push %ebp
109663: 89 e5 mov %esp,%ebp
109665: 57 push %edi
109666: 56 push %esi
109667: 53 push %ebx
109668: 83 ec 0c sub $0xc,%esp
10966b: 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))
10966e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109674: 25 03 04 00 00 and $0x403,%eax
109679: 3d 01 04 00 00 cmp $0x401,%eax
10967e: 75 2c jne 1096ac <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);
109680: 57 push %edi <== NOT EXECUTED
109681: 6a 01 push $0x1 <== NOT EXECUTED
109683: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED
109686: 50 push %eax <== NOT EXECUTED
109687: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10968a: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
rtems_interrupt_disable(level);
109690: 9c pushf <== NOT EXECUTED
109691: fa cli <== NOT EXECUTED
109692: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
109693: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
109699: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10969f: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
1096a2: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
1096a8: 52 push %edx <== NOT EXECUTED
1096a9: 9d popf <== NOT EXECUTED
1096aa: eb 38 jmp 1096e4 <rtems_termios_refill_transmitter+0x82><== NOT EXECUTED
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
1096ac: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1096b2: 83 e0 03 and $0x3,%eax
1096b5: 83 f8 02 cmp $0x2,%eax
1096b8: 75 37 jne 1096f1 <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);
1096ba: 56 push %esi <== NOT EXECUTED
1096bb: 6a 01 push $0x1 <== NOT EXECUTED
1096bd: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED
1096c0: 50 push %eax <== NOT EXECUTED
1096c1: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1096c4: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
rtems_interrupt_disable(level);
1096ca: 9c pushf <== NOT EXECUTED
1096cb: fa cli <== NOT EXECUTED
1096cc: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
1096cd: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
1096d3: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1096d9: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
1096dc: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
1096e2: 52 push %edx <== NOT EXECUTED
1096e3: 9d popf <== NOT EXECUTED
1096e4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
nToSend = 1;
1096e7: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
1096ec: e9 35 01 00 00 jmp 109826 <rtems_termios_refill_transmitter+0x1c4><== NOT EXECUTED
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
1096f1: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
1096f7: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
1096fd: 39 c2 cmp %eax,%edx
1096ff: 75 25 jne 109726 <rtems_termios_refill_transmitter+0xc4>
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
109701: 31 f6 xor %esi,%esi
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
109703: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx)
10970a: 0f 85 16 01 00 00 jne 109826 <rtems_termios_refill_transmitter+0x1c4><== ALWAYS TAKEN
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
109710: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109713: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED
109719: e8 8a 0b 00 00 call 10a2a8 <rtems_semaphore_release><== NOT EXECUTED
10971e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109721: e9 00 01 00 00 jmp 109826 <rtems_termios_refill_transmitter+0x1c4><== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
109726: 9c pushf
109727: fa cli
109728: 58 pop %eax
len = tty->t_dqlen;
109729: 8b bb 90 00 00 00 mov 0x90(%ebx),%edi
tty->t_dqlen = 0;
10972f: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx)
109736: 00 00 00
rtems_interrupt_enable(level);
109739: 50 push %eax
10973a: 9d popf
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
10973b: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
109741: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
109747: 8d 04 07 lea (%edi,%eax,1),%eax
10974a: 31 d2 xor %edx,%edx
10974c: f7 f1 div %ecx
10974e: 89 d7 mov %edx,%edi
tty->rawOutBuf.Tail = newTail;
109750: 89 93 84 00 00 00 mov %edx,0x84(%ebx)
if (tty->rawOutBufState == rob_wait) {
109756: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx)
10975d: 75 11 jne 109770 <rtems_termios_refill_transmitter+0x10e>
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
10975f: 83 ec 0c sub $0xc,%esp
109762: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
109768: e8 3b 0b 00 00 call 10a2a8 <rtems_semaphore_release>
10976d: 83 c4 10 add $0x10,%esp
}
if (newTail == tty->rawOutBuf.Head) {
109770: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
109776: 39 c7 cmp %eax,%edi
109778: 75 2a jne 1097a4 <rtems_termios_refill_transmitter+0x142>
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
10977a: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx)
109781: 00 00 00
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
109784: 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;
10978a: 31 f6 xor %esi,%esi
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
10978c: 85 c0 test %eax,%eax
10978e: 0f 84 8c 00 00 00 je 109820 <rtems_termios_refill_transmitter+0x1be><== ALWAYS TAKEN
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
109794: 51 push %ecx <== NOT EXECUTED
109795: 51 push %ecx <== NOT EXECUTED
109796: ff b3 d8 00 00 00 pushl 0xd8(%ebx) <== NOT EXECUTED
10979c: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED
10979f: 52 push %edx <== NOT EXECUTED
1097a0: ff d0 call *%eax <== NOT EXECUTED
1097a2: eb 79 jmp 10981d <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))
1097a4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1097aa: 25 10 02 00 00 and $0x210,%eax
1097af: 3d 10 02 00 00 cmp $0x210,%eax
1097b4: 75 22 jne 1097d8 <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);
1097b6: 9c pushf <== NOT EXECUTED
1097b7: fa cli <== NOT EXECUTED
1097b8: 5a pop %edx <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
1097b9: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1097bf: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
1097c2: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
1097c8: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED
1097cf: 00 00 00
rtems_interrupt_enable(level);
1097d2: 52 push %edx <== NOT EXECUTED
1097d3: 9d popf <== NOT EXECUTED
nToSend = 0;
1097d4: 31 f6 xor %esi,%esi <== NOT EXECUTED
1097d6: eb 48 jmp 109820 <rtems_termios_refill_transmitter+0x1be><== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
1097d8: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
1097de: 39 c7 cmp %eax,%edi
1097e0: 76 08 jbe 1097ea <rtems_termios_refill_transmitter+0x188>
nToSend = tty->rawOutBuf.Size - newTail;
1097e2: 8b b3 88 00 00 00 mov 0x88(%ebx),%esi
1097e8: eb 06 jmp 1097f0 <rtems_termios_refill_transmitter+0x18e>
else
nToSend = tty->rawOutBuf.Head - newTail;
1097ea: 8b b3 80 00 00 00 mov 0x80(%ebx),%esi
1097f0: 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)) {
1097f2: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1097f8: f6 c4 06 test $0x6,%ah
1097fb: 74 05 je 109802 <rtems_termios_refill_transmitter+0x1a0>
nToSend = 1;
1097fd: be 01 00 00 00 mov $0x1,%esi
}
tty->rawOutBufState = rob_busy; /*apm*/
109802: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
109809: 00 00 00
(*tty->device.write)(
10980c: 52 push %edx
10980d: 56 push %esi
10980e: 8b 43 7c mov 0x7c(%ebx),%eax
109811: 01 f8 add %edi,%eax
109813: 50 push %eax
109814: ff 73 10 pushl 0x10(%ebx)
109817: ff 93 a4 00 00 00 call *0xa4(%ebx)
10981d: 83 c4 10 add $0x10,%esp
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
109820: 89 bb 84 00 00 00 mov %edi,0x84(%ebx)
}
return nToSend;
}
109826: 89 f0 mov %esi,%eax
109828: 8d 65 f4 lea -0xc(%ebp),%esp
10982b: 5b pop %ebx
10982c: 5e pop %esi
10982d: 5f pop %edi
10982e: c9 leave
10982f: c3 ret
001095fe <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
1095fe: 55 push %ebp
1095ff: 89 e5 mov %esp,%ebp
109601: 57 push %edi
109602: 56 push %esi
109603: 53 push %ebx
109604: 83 ec 1c sub $0x1c,%esp
109607: 8b 5d 08 mov 0x8(%ebp),%ebx
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
10960a: 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);
10960d: 8d 75 e7 lea -0x19(%ebp),%esi
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
109610: 57 push %edi
109611: 6a 00 push $0x0
109613: 6a 02 push $0x2
109615: 6a 03 push $0x3
109617: e8 d8 05 00 00 call 109bf4 <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) {
10961c: 83 c4 10 add $0x10,%esp
10961f: f6 45 e0 01 testb $0x1,-0x20(%ebp)
109623: 74 17 je 10963c <rtems_termios_rxdaemon+0x3e><== ALWAYS TAKEN
tty->rxTaskId = 0;
109625: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED
10962c: 00 00 00
rtems_task_delete(RTEMS_SELF);
10962f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109632: 6a 00 push $0x0 <== NOT EXECUTED
109634: e8 37 0e 00 00 call 10a470 <rtems_task_delete> <== NOT EXECUTED
109639: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
10963c: 83 ec 0c sub $0xc,%esp
10963f: ff 73 10 pushl 0x10(%ebx)
109642: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (c != EOF) {
109648: 83 c4 10 add $0x10,%esp
10964b: 83 f8 ff cmp $0xffffffff,%eax
10964e: 74 c0 je 109610 <rtems_termios_rxdaemon+0x12>
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
109650: 88 45 e7 mov %al,-0x19(%ebp)
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
109653: 50 push %eax
109654: 6a 01 push $0x1
109656: 56 push %esi
109657: 53 push %ebx
109658: e8 16 fd ff ff call 109373 <rtems_termios_enqueue_raw_characters>
10965d: 83 c4 10 add $0x10,%esp
109660: eb ae jmp 109610 <rtems_termios_rxdaemon+0x12>
00109830 <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
109830: 55 push %ebp
109831: 89 e5 mov %esp,%ebp
109833: 56 push %esi
109834: 53 push %ebx
109835: 83 ec 10 sub $0x10,%esp
109838: 8b 5d 08 mov 0x8(%ebp),%ebx
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
10983b: 8d 75 f4 lea -0xc(%ebp),%esi
10983e: 56 push %esi
10983f: 6a 00 push $0x0
109841: 6a 02 push $0x2
109843: 6a 03 push $0x3
109845: e8 aa 03 00 00 call 109bf4 <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) {
10984a: 83 c4 10 add $0x10,%esp
10984d: f6 45 f4 01 testb $0x1,-0xc(%ebp)
109851: 74 17 je 10986a <rtems_termios_txdaemon+0x3a><== ALWAYS TAKEN
tty->txTaskId = 0;
109853: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED
10985a: 00 00 00
rtems_task_delete(RTEMS_SELF);
10985d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109860: 6a 00 push $0x0 <== NOT EXECUTED
109862: e8 09 0c 00 00 call 10a470 <rtems_task_delete> <== NOT EXECUTED
109867: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
10986a: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
109870: c1 e0 05 shl $0x5,%eax
109873: 8b 80 08 4f 12 00 mov 0x124f08(%eax),%eax
109879: 85 c0 test %eax,%eax
10987b: 74 09 je 109886 <rtems_termios_txdaemon+0x56><== ALWAYS TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
10987d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109880: 53 push %ebx <== NOT EXECUTED
109881: ff d0 call *%eax <== NOT EXECUTED
109883: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
109886: 83 ec 0c sub $0xc,%esp
109889: 53 push %ebx
10988a: e8 d3 fd ff ff call 109662 <rtems_termios_refill_transmitter>
}
10988f: 83 c4 10 add $0x10,%esp
109892: eb aa jmp 10983e <rtems_termios_txdaemon+0xe>
00108fd2 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
108fd2: 55 push %ebp
108fd3: 89 e5 mov %esp,%ebp
108fd5: 57 push %edi
108fd6: 56 push %esi
108fd7: 53 push %ebx
108fd8: 83 ec 20 sub $0x20,%esp
108fdb: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
108fde: 8b 03 mov (%ebx),%eax
108fe0: 8b 70 34 mov 0x34(%eax),%esi
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108fe3: 6a 00 push $0x0
108fe5: 6a 00 push $0x0
108fe7: ff 76 18 pushl 0x18(%esi)
108fea: e8 cd 11 00 00 call 10a1bc <rtems_semaphore_obtain>
108fef: 89 c7 mov %eax,%edi
if (sc != RTEMS_SUCCESSFUL)
108ff1: 83 c4 10 add $0x10,%esp
108ff4: 85 c0 test %eax,%eax
108ff6: 75 77 jne 10906f <rtems_termios_write+0x9d><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
108ff8: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax
108ffe: c1 e0 05 shl $0x5,%eax
109001: 8b 80 00 4f 12 00 mov 0x124f00(%eax),%eax
109007: 85 c0 test %eax,%eax
109009: 74 0b je 109016 <rtems_termios_write+0x44>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
10900b: 57 push %edi
10900c: 57 push %edi
10900d: 53 push %ebx
10900e: 56 push %esi
10900f: ff d0 call *%eax
109011: 89 c7 mov %eax,%edi
rtems_semaphore_release (tty->osem);
109013: 5b pop %ebx
109014: eb 4e jmp 109064 <rtems_termios_write+0x92>
return sc;
}
if (tty->termios.c_oflag & OPOST) {
109016: f6 46 34 01 testb $0x1,0x34(%esi)
10901a: 74 2f je 10904b <rtems_termios_write+0x79><== NEVER TAKEN
uint32_t count = args->count;
10901c: 8b 4b 10 mov 0x10(%ebx),%ecx
char *buffer = args->buffer;
10901f: 8b 43 0c mov 0xc(%ebx),%eax
109022: 89 45 e4 mov %eax,-0x1c(%ebp)
while (count--)
109025: eb 18 jmp 10903f <rtems_termios_write+0x6d>
oproc (*buffer++, tty);
109027: 8b 55 e4 mov -0x1c(%ebp),%edx
10902a: 0f b6 02 movzbl (%edx),%eax
10902d: 42 inc %edx
10902e: 89 55 e4 mov %edx,-0x1c(%ebp)
109031: 89 f2 mov %esi,%edx
109033: 89 4d e0 mov %ecx,-0x20(%ebp)
109036: e8 37 fb ff ff call 108b72 <oproc>
10903b: 8b 4d e0 mov -0x20(%ebp),%ecx
10903e: 49 dec %ecx
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
10903f: 85 c9 test %ecx,%ecx
109041: 75 e4 jne 109027 <rtems_termios_write+0x55>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
109043: 8b 43 10 mov 0x10(%ebx),%eax
109046: 89 43 18 mov %eax,0x18(%ebx)
109049: eb 16 jmp 109061 <rtems_termios_write+0x8f>
} else {
rtems_termios_puts (args->buffer, args->count, tty);
10904b: 51 push %ecx <== NOT EXECUTED
10904c: 56 push %esi <== NOT EXECUTED
10904d: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109050: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED
109053: e8 fa f9 ff ff call 108a52 <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
109058: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
10905b: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED
10905e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
rtems_semaphore_release (tty->osem);
109061: 83 ec 0c sub $0xc,%esp
109064: ff 76 18 pushl 0x18(%esi)
109067: e8 3c 12 00 00 call 10a2a8 <rtems_semaphore_release>
return sc;
10906c: 83 c4 10 add $0x10,%esp
}
10906f: 89 f8 mov %edi,%eax
109071: 8d 65 f4 lea -0xc(%ebp),%esp
109074: 5b pop %ebx
109075: 5e pop %esi
109076: 5f pop %edi
109077: c9 leave
109078: c3 ret
001163ec <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
1163ec: 55 push %ebp
1163ed: 89 e5 mov %esp,%ebp
1163ef: 83 ec 1c sub $0x1c,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
1163f2: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
1163f5: 50 push %eax
1163f6: ff 75 08 pushl 0x8(%ebp)
1163f9: 68 1c f9 13 00 push $0x13f91c
1163fe: e8 49 27 00 00 call 118b4c <_Objects_Get>
switch ( location ) {
116403: 83 c4 10 add $0x10,%esp
116406: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
11640a: 75 1e jne 11642a <rtems_timer_cancel+0x3e>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
11640c: 83 78 38 04 cmpl $0x4,0x38(%eax)
116410: 74 0f je 116421 <rtems_timer_cancel+0x35><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
116412: 83 ec 0c sub $0xc,%esp
116415: 83 c0 10 add $0x10,%eax
116418: 50 push %eax
116419: e8 7e 41 00 00 call 11a59c <_Watchdog_Remove>
11641e: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
116421: e8 d8 31 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116426: 31 c0 xor %eax,%eax
116428: eb 05 jmp 11642f <rtems_timer_cancel+0x43>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11642a: b8 04 00 00 00 mov $0x4,%eax
}
11642f: c9 leave
116430: c3 ret
0011684c <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
11684c: 55 push %ebp
11684d: 89 e5 mov %esp,%ebp
11684f: 57 push %edi
116850: 56 push %esi
116851: 53 push %ebx
116852: 83 ec 1c sub $0x1c,%esp
116855: 8b 7d 0c mov 0xc(%ebp),%edi
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
116858: 8b 35 5c f9 13 00 mov 0x13f95c,%esi
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
11685e: 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 )
116863: 85 f6 test %esi,%esi
116865: 0f 84 b1 00 00 00 je 11691c <rtems_timer_server_fire_when+0xd0>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
11686b: b3 0b mov $0xb,%bl
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
11686d: 80 3d e8 ef 13 00 00 cmpb $0x0,0x13efe8
116874: 0f 84 a2 00 00 00 je 11691c <rtems_timer_server_fire_when+0xd0><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
11687a: b3 09 mov $0x9,%bl
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
11687c: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
116880: 0f 84 96 00 00 00 je 11691c <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
116886: 83 ec 0c sub $0xc,%esp
116889: 57 push %edi
11688a: e8 b5 d6 ff ff call 113f44 <_TOD_Validate>
11688f: 83 c4 10 add $0x10,%esp
return RTEMS_INVALID_CLOCK;
116892: b3 14 mov $0x14,%bl
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
116894: 84 c0 test %al,%al
116896: 0f 84 80 00 00 00 je 11691c <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
11689c: 83 ec 0c sub $0xc,%esp
11689f: 57 push %edi
1168a0: e8 37 d6 ff ff call 113edc <_TOD_To_seconds>
1168a5: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
1168a7: 83 c4 10 add $0x10,%esp
1168aa: 3b 05 60 f0 13 00 cmp 0x13f060,%eax
1168b0: 76 6a jbe 11691c <rtems_timer_server_fire_when+0xd0>
1168b2: 51 push %ecx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
1168b3: 8d 45 e4 lea -0x1c(%ebp),%eax
1168b6: 50 push %eax
1168b7: ff 75 08 pushl 0x8(%ebp)
1168ba: 68 1c f9 13 00 push $0x13f91c
1168bf: e8 88 22 00 00 call 118b4c <_Objects_Get>
1168c4: 89 c3 mov %eax,%ebx
switch ( location ) {
1168c6: 83 c4 10 add $0x10,%esp
1168c9: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
1168cd: 75 48 jne 116917 <rtems_timer_server_fire_when+0xcb>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
1168cf: 83 ec 0c sub $0xc,%esp
1168d2: 8d 40 10 lea 0x10(%eax),%eax
1168d5: 50 push %eax
1168d6: e8 c1 3c 00 00 call 11a59c <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
1168db: 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;
1168e2: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
the_watchdog->routine = routine;
1168e9: 8b 45 10 mov 0x10(%ebp),%eax
1168ec: 89 43 2c mov %eax,0x2c(%ebx)
the_watchdog->id = id;
1168ef: 8b 45 08 mov 0x8(%ebp),%eax
1168f2: 89 43 30 mov %eax,0x30(%ebx)
the_watchdog->user_data = user_data;
1168f5: 8b 45 14 mov 0x14(%ebp),%eax
1168f8: 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();
1168fb: 2b 3d 60 f0 13 00 sub 0x13f060,%edi
116901: 89 7b 1c mov %edi,0x1c(%ebx)
(*timer_server->schedule_operation)( timer_server, the_timer );
116904: 58 pop %eax
116905: 5a pop %edx
116906: 53 push %ebx
116907: 56 push %esi
116908: ff 56 04 call *0x4(%esi)
_Thread_Enable_dispatch();
11690b: e8 ee 2c 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116910: 83 c4 10 add $0x10,%esp
116913: 31 db xor %ebx,%ebx
116915: eb 05 jmp 11691c <rtems_timer_server_fire_when+0xd0>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
116917: bb 04 00 00 00 mov $0x4,%ebx
}
11691c: 89 d8 mov %ebx,%eax
11691e: 8d 65 f4 lea -0xc(%ebp),%esp
116921: 5b pop %ebx
116922: 5e pop %esi
116923: 5f pop %edi
116924: c9 leave
116925: c3 ret
0010b17d <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
10b17d: 55 push %ebp
10b17e: 89 e5 mov %esp,%ebp
10b180: 57 push %edi
10b181: 56 push %esi
10b182: 53 push %ebx
10b183: 83 ec 1c sub $0x1c,%esp
10b186: 89 c3 mov %eax,%ebx
10b188: 89 55 e4 mov %edx,-0x1c(%ebp)
10b18b: 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) {
10b18e: a9 00 00 00 20 test $0x20000000,%eax
10b193: 74 2c je 10b1c1 <rtems_verror+0x44>
if (rtems_panic_in_progress++)
10b195: a1 68 b3 12 00 mov 0x12b368,%eax
10b19a: 8d 50 01 lea 0x1(%eax),%edx
10b19d: 89 15 68 b3 12 00 mov %edx,0x12b368
10b1a3: 85 c0 test %eax,%eax
10b1a5: 74 0b je 10b1b2 <rtems_verror+0x35> <== ALWAYS TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b1a7: a1 b4 b4 12 00 mov 0x12b4b4,%eax <== NOT EXECUTED
10b1ac: 40 inc %eax <== NOT EXECUTED
10b1ad: 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;
10b1b2: 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)
10b1b4: 83 3d 68 b3 12 00 02 cmpl $0x2,0x12b368
10b1bb: 0f 8f da 00 00 00 jg 10b29b <rtems_verror+0x11e> <== NEVER TAKEN
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
10b1c1: 83 ec 0c sub $0xc,%esp
10b1c4: a1 c0 91 12 00 mov 0x1291c0,%eax
10b1c9: ff 70 08 pushl 0x8(%eax)
10b1cc: e8 97 ab 00 00 call 115d68 <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
10b1d1: 89 df mov %ebx,%edi
10b1d3: 81 e7 ff ff ff 8f and $0x8fffffff,%edi
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
10b1d9: 83 c4 10 add $0x10,%esp
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
10b1dc: 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? */
10b1de: 81 e3 00 00 00 40 and $0x40000000,%ebx
10b1e4: 74 07 je 10b1ed <rtems_verror+0x70>
local_errno = errno;
10b1e6: e8 e5 a7 00 00 call 1159d0 <__errno>
10b1eb: 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);
10b1ed: 53 push %ebx
10b1ee: ff 75 e0 pushl -0x20(%ebp)
10b1f1: ff 75 e4 pushl -0x1c(%ebp)
10b1f4: a1 c0 91 12 00 mov 0x1291c0,%eax
10b1f9: ff 70 0c pushl 0xc(%eax)
10b1fc: e8 03 11 01 00 call 11c304 <vfprintf>
10b201: 89 c3 mov %eax,%ebx
if (status)
10b203: 83 c4 10 add $0x10,%esp
10b206: 85 ff test %edi,%edi
10b208: 74 24 je 10b22e <rtems_verror+0xb1>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
10b20a: 83 ec 0c sub $0xc,%esp
10b20d: 57 push %edi
10b20e: e8 55 ff ff ff call 10b168 <rtems_status_text>
10b213: 83 c4 0c add $0xc,%esp
10b216: 50 push %eax
10b217: 68 93 44 12 00 push $0x124493
10b21c: a1 c0 91 12 00 mov 0x1291c0,%eax
10b221: ff 70 0c pushl 0xc(%eax)
10b224: e8 33 af 00 00 call 11615c <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
10b229: 01 c3 add %eax,%ebx
10b22b: 83 c4 10 add $0x10,%esp
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
10b22e: 83 fe 00 cmp $0x0,%esi
10b231: 74 40 je 10b273 <rtems_verror+0xf6>
if ((local_errno > 0) && *strerror(local_errno))
10b233: 7e 25 jle 10b25a <rtems_verror+0xdd>
10b235: 83 ec 0c sub $0xc,%esp
10b238: 56 push %esi
10b239: e8 be b7 00 00 call 1169fc <strerror>
10b23e: 83 c4 10 add $0x10,%esp
10b241: 80 38 00 cmpb $0x0,(%eax)
10b244: 74 14 je 10b25a <rtems_verror+0xdd> <== NEVER TAKEN
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
10b246: 83 ec 0c sub $0xc,%esp
10b249: 56 push %esi
10b24a: e8 ad b7 00 00 call 1169fc <strerror>
10b24f: 83 c4 0c add $0xc,%esp
10b252: 50 push %eax
10b253: 68 a1 44 12 00 push $0x1244a1
10b258: eb 07 jmp 10b261 <rtems_verror+0xe4>
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
10b25a: 51 push %ecx
10b25b: 56 push %esi
10b25c: 68 ae 44 12 00 push $0x1244ae
10b261: a1 c0 91 12 00 mov 0x1291c0,%eax
10b266: ff 70 0c pushl 0xc(%eax)
10b269: e8 ee ae 00 00 call 11615c <fprintf>
10b26e: 01 c3 add %eax,%ebx
10b270: 83 c4 10 add $0x10,%esp
}
chars_written += fprintf(stderr, "\n");
10b273: 52 push %edx
10b274: 52 push %edx
10b275: 68 10 4c 12 00 push $0x124c10
10b27a: a1 c0 91 12 00 mov 0x1291c0,%eax
10b27f: ff 70 0c pushl 0xc(%eax)
10b282: e8 d5 ae 00 00 call 11615c <fprintf>
10b287: 8d 34 18 lea (%eax,%ebx,1),%esi
(void) fflush(stderr);
10b28a: 58 pop %eax
10b28b: a1 c0 91 12 00 mov 0x1291c0,%eax
10b290: ff 70 0c pushl 0xc(%eax)
10b293: e8 d0 aa 00 00 call 115d68 <fflush>
return chars_written;
10b298: 83 c4 10 add $0x10,%esp
}
10b29b: 89 f0 mov %esi,%eax
10b29d: 8d 65 f4 lea -0xc(%ebp),%esp
10b2a0: 5b pop %ebx
10b2a1: 5e pop %esi
10b2a2: 5f pop %edi
10b2a3: c9 leave
10b2a4: c3 ret
00107960 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
107960: 55 push %ebp
107961: 89 e5 mov %esp,%ebp
107963: 57 push %edi
107964: 56 push %esi
107965: 53 push %ebx
107966: 83 ec 3c sub $0x3c,%esp
107969: 89 c3 mov %eax,%ebx
10796b: 89 55 e0 mov %edx,-0x20(%ebp)
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
int sign = 0;
10796e: 31 f6 xor %esi,%esi
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
107970: c7 45 e4 ff ff ff 7f movl $0x7fffffff,-0x1c(%ebp)
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
107977: 31 ff xor %edi,%edi
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
107979: 89 7d c4 mov %edi,-0x3c(%ebp)
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
10797c: 8b 43 04 mov 0x4(%ebx),%eax
10797f: 48 dec %eax
107980: 89 43 04 mov %eax,0x4(%ebx)
107983: 85 c0 test %eax,%eax
107985: 79 15 jns 10799c <scanInt+0x3c> <== ALWAYS TAKEN
107987: 50 push %eax <== NOT EXECUTED
107988: 50 push %eax <== NOT EXECUTED
107989: 53 push %ebx <== NOT EXECUTED
10798a: ff 35 00 4e 12 00 pushl 0x124e00 <== NOT EXECUTED
107990: e8 2f bf 00 00 call 1138c4 <__srget_r> <== NOT EXECUTED
107995: 89 c1 mov %eax,%ecx <== NOT EXECUTED
107997: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10799a: eb 08 jmp 1079a4 <scanInt+0x44> <== NOT EXECUTED
10799c: 8b 03 mov (%ebx),%eax
10799e: 0f b6 08 movzbl (%eax),%ecx
1079a1: 40 inc %eax
1079a2: 89 03 mov %eax,(%ebx)
if (c == ':')
1079a4: 83 f9 3a cmp $0x3a,%ecx
1079a7: 74 4a je 1079f3 <scanInt+0x93>
break;
if (sign == 0) {
1079a9: 85 f6 test %esi,%esi
1079ab: 75 11 jne 1079be <scanInt+0x5e>
if (c == '-') {
sign = -1;
limit++;
continue;
}
sign = 1;
1079ad: 66 be 01 00 mov $0x1,%si
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
1079b1: 83 f9 2d cmp $0x2d,%ecx
1079b4: 75 08 jne 1079be <scanInt+0x5e>
sign = -1;
limit++;
1079b6: ff 45 e4 incl -0x1c(%ebp)
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
1079b9: 83 ce ff or $0xffffffff,%esi
limit++;
continue;
1079bc: eb be jmp 10797c <scanInt+0x1c>
}
sign = 1;
}
if (!isdigit(c))
1079be: a1 fc 4d 12 00 mov 0x124dfc,%eax
1079c3: f6 44 08 01 04 testb $0x4,0x1(%eax,%ecx,1)
1079c8: 74 41 je 107a0b <scanInt+0xab>
return 0;
d = c - '0';
if ((i > (limit / 10))
1079ca: 8b 45 e4 mov -0x1c(%ebp),%eax
1079cd: bf 0a 00 00 00 mov $0xa,%edi
1079d2: 31 d2 xor %edx,%edx
1079d4: f7 f7 div %edi
1079d6: 89 55 d4 mov %edx,-0x2c(%ebp)
1079d9: 39 45 c4 cmp %eax,-0x3c(%ebp)
1079dc: 77 2d ja 107a0b <scanInt+0xab>
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
1079de: 83 e9 30 sub $0x30,%ecx
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
1079e1: 39 45 c4 cmp %eax,-0x3c(%ebp)
1079e4: 75 04 jne 1079ea <scanInt+0x8a>
1079e6: 39 d1 cmp %edx,%ecx
1079e8: 77 21 ja 107a0b <scanInt+0xab> <== ALWAYS TAKEN
return 0;
i = i * 10 + d;
1079ea: 6b 7d c4 0a imul $0xa,-0x3c(%ebp),%edi
1079ee: 8d 3c 39 lea (%ecx,%edi,1),%edi
1079f1: eb 86 jmp 107979 <scanInt+0x19>
1079f3: 8b 7d c4 mov -0x3c(%ebp),%edi
}
if (sign == 0)
return 0;
1079f6: 31 c0 xor %eax,%eax
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
1079f8: 85 f6 test %esi,%esi
1079fa: 74 11 je 107a0d <scanInt+0xad> <== NEVER TAKEN
return 0;
*val = i * sign;
1079fc: 0f af f7 imul %edi,%esi
1079ff: 8b 45 e0 mov -0x20(%ebp),%eax
107a02: 89 30 mov %esi,(%eax)
return 1;
107a04: b8 01 00 00 00 mov $0x1,%eax
107a09: eb 02 jmp 107a0d <scanInt+0xad>
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
107a0b: 31 c0 xor %eax,%eax
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
107a0d: 8d 65 f4 lea -0xc(%ebp),%esp
107a10: 5b pop %ebx
107a11: 5e pop %esi
107a12: 5f pop %edi
107a13: c9 leave
107a14: c3 ret
00107aa0 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
107aa0: 55 push %ebp
107aa1: 89 e5 mov %esp,%ebp
107aa3: 57 push %edi
107aa4: 56 push %esi
107aa5: 53 push %ebx
107aa6: 83 ec 34 sub $0x34,%esp
107aa9: 89 c7 mov %eax,%edi
107aab: 89 d3 mov %edx,%ebx
107aad: 89 4d d4 mov %ecx,-0x2c(%ebp)
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
107ab0: 6a 00 push $0x0
107ab2: 8d 45 08 lea 0x8(%ebp),%eax
107ab5: 50 push %eax
107ab6: 8d 4d d4 lea -0x2c(%ebp),%ecx
107ab9: 89 f8 mov %edi,%eax
107abb: e8 55 ff ff ff call 107a15 <scanString>
107ac0: 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;
107ac3: 31 f6 xor %esi,%esi
{
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
107ac5: 85 c0 test %eax,%eax
107ac7: 0f 84 c2 00 00 00 je 107b8f <scangr+0xef>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
107acd: 50 push %eax
107ace: 50 push %eax
107acf: 8d 53 04 lea 0x4(%ebx),%edx
107ad2: 6a 00 push $0x0
107ad4: 8d 45 08 lea 0x8(%ebp),%eax
107ad7: 50 push %eax
107ad8: 8d 4d d4 lea -0x2c(%ebp),%ecx
107adb: 89 f8 mov %edi,%eax
107add: e8 33 ff ff ff call 107a15 <scanString>
107ae2: 83 c4 10 add $0x10,%esp
107ae5: 85 c0 test %eax,%eax
107ae7: 0f 84 a2 00 00 00 je 107b8f <scangr+0xef> <== NEVER TAKEN
|| !scanInt(fp, &grgid)
107aed: 8d 55 e4 lea -0x1c(%ebp),%edx
107af0: 89 f8 mov %edi,%eax
107af2: e8 69 fe ff ff call 107960 <scanInt>
107af7: 85 c0 test %eax,%eax
107af9: 0f 84 90 00 00 00 je 107b8f <scangr+0xef> <== NEVER TAKEN
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
107aff: 51 push %ecx
107b00: 51 push %ecx
107b01: 8d 55 e0 lea -0x20(%ebp),%edx
107b04: 6a 01 push $0x1
107b06: 8d 45 08 lea 0x8(%ebp),%eax
107b09: 50 push %eax
107b0a: 8d 4d d4 lea -0x2c(%ebp),%ecx
107b0d: 89 f8 mov %edi,%eax
107b0f: e8 01 ff ff ff call 107a15 <scanString>
107b14: 83 c4 10 add $0x10,%esp
107b17: 85 c0 test %eax,%eax
107b19: 74 74 je 107b8f <scangr+0xef> <== NEVER TAKEN
return 0;
grp->gr_gid = grgid;
107b1b: 8b 45 e4 mov -0x1c(%ebp),%eax
107b1e: 66 89 43 08 mov %ax,0x8(%ebx)
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107b22: 8b 4d e0 mov -0x20(%ebp),%ecx
107b25: 89 ca mov %ecx,%edx
107b27: b8 01 00 00 00 mov $0x1,%eax
107b2c: 89 c6 mov %eax,%esi
107b2e: eb 0b jmp 107b3b <scangr+0x9b>
if(*cp == ',')
memcount++;
107b30: 3c 2c cmp $0x2c,%al
107b32: 0f 94 c0 sete %al
107b35: 0f b6 c0 movzbl %al,%eax
107b38: 01 c6 add %eax,%esi
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107b3a: 42 inc %edx
107b3b: 8a 02 mov (%edx),%al
107b3d: 84 c0 test %al,%al
107b3f: 75 ef jne 107b30 <scangr+0x90>
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
107b41: 8d 04 b5 13 00 00 00 lea 0x13(,%esi,4),%eax
return 0;
107b48: 31 f6 xor %esi,%esi
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
107b4a: 39 45 08 cmp %eax,0x8(%ebp)
107b4d: 72 40 jb 107b8f <scangr+0xef> <== NEVER TAKEN
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
107b4f: 8b 45 d4 mov -0x2c(%ebp),%eax
107b52: 83 c0 0f add $0xf,%eax
107b55: 83 e0 f0 and $0xfffffff0,%eax
107b58: 89 43 0c mov %eax,0xc(%ebx)
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
107b5b: 89 08 mov %ecx,(%eax)
}
/*
* Extract a single group record from the database
*/
static int scangr(
107b5d: 8b 45 e0 mov -0x20(%ebp),%eax
107b60: 40 inc %eax
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107b61: ba 01 00 00 00 mov $0x1,%edx
107b66: eb 11 jmp 107b79 <scangr+0xd9>
if(*cp == ',') {
107b68: 80 f9 2c cmp $0x2c,%cl
107b6b: 75 0b jne 107b78 <scangr+0xd8>
*cp = '\0';
107b6d: c6 40 ff 00 movb $0x0,-0x1(%eax)
grp->gr_mem[memcount++] = cp + 1;
107b71: 8b 4b 0c mov 0xc(%ebx),%ecx
107b74: 89 04 91 mov %eax,(%ecx,%edx,4)
107b77: 42 inc %edx
107b78: 40 inc %eax
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107b79: 8a 48 ff mov -0x1(%eax),%cl
107b7c: 84 c9 test %cl,%cl
107b7e: 75 e8 jne 107b68 <scangr+0xc8>
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
107b80: 8b 43 0c mov 0xc(%ebx),%eax
107b83: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4)
return 1;
107b8a: be 01 00 00 00 mov $0x1,%esi
}
107b8f: 89 f0 mov %esi,%eax
107b91: 8d 65 f4 lea -0xc(%ebp),%esp
107b94: 5b pop %ebx
107b95: 5e pop %esi
107b96: 5f pop %edi
107b97: c9 leave
107b98: c3 ret
00107b99 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
107b99: 55 push %ebp
107b9a: 89 e5 mov %esp,%ebp
107b9c: 57 push %edi
107b9d: 56 push %esi
107b9e: 53 push %ebx
107b9f: 83 ec 34 sub $0x34,%esp
107ba2: 89 c6 mov %eax,%esi
107ba4: 89 d3 mov %edx,%ebx
107ba6: 89 4d d4 mov %ecx,-0x2c(%ebp)
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
107ba9: 8d 7d d4 lea -0x2c(%ebp),%edi
107bac: 6a 00 push $0x0
107bae: 8d 45 08 lea 0x8(%ebp),%eax
107bb1: 50 push %eax
107bb2: 89 f9 mov %edi,%ecx
107bb4: 89 f0 mov %esi,%eax
107bb6: e8 5a fe ff ff call 107a15 <scanString>
107bbb: 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;
107bbe: 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)
107bc5: 85 c0 test %eax,%eax
107bc7: 0f 84 c4 00 00 00 je 107c91 <scanpw+0xf8>
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
107bcd: 51 push %ecx
107bce: 51 push %ecx
107bcf: 8d 53 04 lea 0x4(%ebx),%edx
107bd2: 6a 00 push $0x0
107bd4: 8d 45 08 lea 0x8(%ebp),%eax
107bd7: 50 push %eax
107bd8: 89 f9 mov %edi,%ecx
107bda: 89 f0 mov %esi,%eax
107bdc: e8 34 fe ff ff call 107a15 <scanString>
107be1: 83 c4 10 add $0x10,%esp
107be4: 85 c0 test %eax,%eax
107be6: 0f 84 a5 00 00 00 je 107c91 <scanpw+0xf8> <== NEVER TAKEN
|| !scanInt(fp, &pwuid)
107bec: 8d 55 e4 lea -0x1c(%ebp),%edx
107bef: 89 f0 mov %esi,%eax
107bf1: e8 6a fd ff ff call 107960 <scanInt>
107bf6: 85 c0 test %eax,%eax
107bf8: 0f 84 93 00 00 00 je 107c91 <scanpw+0xf8>
|| !scanInt(fp, &pwgid)
107bfe: 8d 55 e0 lea -0x20(%ebp),%edx
107c01: 89 f0 mov %esi,%eax
107c03: e8 58 fd ff ff call 107960 <scanInt>
107c08: 85 c0 test %eax,%eax
107c0a: 0f 84 81 00 00 00 je 107c91 <scanpw+0xf8>
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
107c10: 52 push %edx
107c11: 52 push %edx
107c12: 8d 53 0c lea 0xc(%ebx),%edx
107c15: 6a 00 push $0x0
107c17: 8d 45 08 lea 0x8(%ebp),%eax
107c1a: 50 push %eax
107c1b: 89 f9 mov %edi,%ecx
107c1d: 89 f0 mov %esi,%eax
107c1f: e8 f1 fd ff ff call 107a15 <scanString>
107c24: 83 c4 10 add $0x10,%esp
107c27: 85 c0 test %eax,%eax
107c29: 74 66 je 107c91 <scanpw+0xf8> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
107c2b: 50 push %eax
107c2c: 50 push %eax
107c2d: 8d 53 10 lea 0x10(%ebx),%edx
107c30: 6a 00 push $0x0
107c32: 8d 45 08 lea 0x8(%ebp),%eax
107c35: 50 push %eax
107c36: 89 f9 mov %edi,%ecx
107c38: 89 f0 mov %esi,%eax
107c3a: e8 d6 fd ff ff call 107a15 <scanString>
107c3f: 83 c4 10 add $0x10,%esp
107c42: 85 c0 test %eax,%eax
107c44: 74 4b je 107c91 <scanpw+0xf8> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
107c46: 51 push %ecx
107c47: 51 push %ecx
107c48: 8d 53 14 lea 0x14(%ebx),%edx
107c4b: 6a 00 push $0x0
107c4d: 8d 45 08 lea 0x8(%ebp),%eax
107c50: 50 push %eax
107c51: 89 f9 mov %edi,%ecx
107c53: 89 f0 mov %esi,%eax
107c55: e8 bb fd ff ff call 107a15 <scanString>
107c5a: 83 c4 10 add $0x10,%esp
107c5d: 85 c0 test %eax,%eax
107c5f: 74 30 je 107c91 <scanpw+0xf8> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
107c61: 52 push %edx
107c62: 52 push %edx
107c63: 8d 53 18 lea 0x18(%ebx),%edx
107c66: 6a 01 push $0x1
107c68: 8d 45 08 lea 0x8(%ebp),%eax
107c6b: 50 push %eax
107c6c: 89 f9 mov %edi,%ecx
107c6e: 89 f0 mov %esi,%eax
107c70: e8 a0 fd ff ff call 107a15 <scanString>
107c75: 83 c4 10 add $0x10,%esp
107c78: 85 c0 test %eax,%eax
107c7a: 74 15 je 107c91 <scanpw+0xf8>
return 0;
pwd->pw_uid = pwuid;
107c7c: 8b 45 e4 mov -0x1c(%ebp),%eax
107c7f: 66 89 43 08 mov %ax,0x8(%ebx)
pwd->pw_gid = pwgid;
107c83: 8b 45 e0 mov -0x20(%ebp),%eax
107c86: 66 89 43 0a mov %ax,0xa(%ebx)
return 1;
107c8a: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp)
}
107c91: 8b 45 d0 mov -0x30(%ebp),%eax
107c94: 8d 65 f4 lea -0xc(%ebp),%esp
107c97: 5b pop %ebx
107c98: 5e pop %esi
107c99: 5f pop %edi
107c9a: c9 leave
107c9b: c3 ret
0010a948 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
10a948: 55 push %ebp
10a949: 89 e5 mov %esp,%ebp
10a94b: 83 ec 08 sub $0x8,%esp
10a94e: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a951: 83 f9 04 cmp $0x4,%ecx
10a954: 77 0b ja 10a961 <sched_get_priority_max+0x19>
10a956: b8 01 00 00 00 mov $0x1,%eax
10a95b: d3 e0 shl %cl,%eax
10a95d: a8 17 test $0x17,%al
10a95f: 75 10 jne 10a971 <sched_get_priority_max+0x29><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a961: e8 e2 73 00 00 call 111d48 <__errno>
10a966: c7 00 16 00 00 00 movl $0x16,(%eax)
10a96c: 83 c8 ff or $0xffffffff,%eax
10a96f: eb 08 jmp 10a979 <sched_get_priority_max+0x31>
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
10a971: 0f b6 05 48 22 12 00 movzbl 0x122248,%eax
10a978: 48 dec %eax
}
10a979: c9 leave
10a97a: c3 ret
0010a97c <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
10a97c: 55 push %ebp
10a97d: 89 e5 mov %esp,%ebp
10a97f: 83 ec 08 sub $0x8,%esp
10a982: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a985: 83 f9 04 cmp $0x4,%ecx
10a988: 77 11 ja 10a99b <sched_get_priority_min+0x1f>
10a98a: ba 01 00 00 00 mov $0x1,%edx
10a98f: d3 e2 shl %cl,%edx
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
10a991: b8 01 00 00 00 mov $0x1,%eax
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
10a996: 80 e2 17 and $0x17,%dl
10a999: 75 0e jne 10a9a9 <sched_get_priority_min+0x2d><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a99b: e8 a8 73 00 00 call 111d48 <__errno>
10a9a0: c7 00 16 00 00 00 movl $0x16,(%eax)
10a9a6: 83 c8 ff or $0xffffffff,%eax
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
10a9a9: c9 leave
10a9aa: c3 ret
0010a9ac <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
10a9ac: 55 push %ebp
10a9ad: 89 e5 mov %esp,%ebp
10a9af: 56 push %esi
10a9b0: 53 push %ebx
10a9b1: 8b 75 08 mov 0x8(%ebp),%esi
10a9b4: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
10a9b7: 85 f6 test %esi,%esi
10a9b9: 74 16 je 10a9d1 <sched_rr_get_interval+0x25><== NEVER TAKEN
10a9bb: e8 90 d0 ff ff call 107a50 <getpid>
10a9c0: 39 c6 cmp %eax,%esi
10a9c2: 74 0d je 10a9d1 <sched_rr_get_interval+0x25>
rtems_set_errno_and_return_minus_one( ESRCH );
10a9c4: e8 7f 73 00 00 call 111d48 <__errno>
10a9c9: c7 00 03 00 00 00 movl $0x3,(%eax)
10a9cf: eb 0f jmp 10a9e0 <sched_rr_get_interval+0x34>
if ( !interval )
10a9d1: 85 db test %ebx,%ebx
10a9d3: 75 10 jne 10a9e5 <sched_rr_get_interval+0x39>
rtems_set_errno_and_return_minus_one( EINVAL );
10a9d5: e8 6e 73 00 00 call 111d48 <__errno>
10a9da: c7 00 16 00 00 00 movl $0x16,(%eax)
10a9e0: 83 c8 ff or $0xffffffff,%eax
10a9e3: eb 13 jmp 10a9f8 <sched_rr_get_interval+0x4c>
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
10a9e5: 50 push %eax
10a9e6: 50 push %eax
10a9e7: 53 push %ebx
10a9e8: ff 35 20 63 12 00 pushl 0x126320
10a9ee: e8 b9 30 00 00 call 10daac <_Timespec_From_ticks>
return 0;
10a9f3: 83 c4 10 add $0x10,%esp
10a9f6: 31 c0 xor %eax,%eax
}
10a9f8: 8d 65 f8 lea -0x8(%ebp),%esp
10a9fb: 5b pop %ebx
10a9fc: 5e pop %esi
10a9fd: c9 leave
10a9fe: c3 ret
0010d088 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
10d088: 55 push %ebp
10d089: 89 e5 mov %esp,%ebp
10d08b: 57 push %edi
10d08c: 56 push %esi
10d08d: 53 push %ebx
10d08e: 83 ec 2c sub $0x2c,%esp
10d091: 8b 75 08 mov 0x8(%ebp),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10d094: a1 a8 af 12 00 mov 0x12afa8,%eax
10d099: 40 inc %eax
10d09a: a3 a8 af 12 00 mov %eax,0x12afa8
va_list arg;
mode_t mode;
unsigned int value = 0;
10d09f: 31 ff xor %edi,%edi
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
10d0a1: 8b 45 0c mov 0xc(%ebp),%eax
10d0a4: 25 00 02 00 00 and $0x200,%eax
10d0a9: 89 45 d4 mov %eax,-0x2c(%ebp)
10d0ac: 74 03 je 10d0b1 <sem_open+0x29>
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
10d0ae: 8b 7d 14 mov 0x14(%ebp),%edi
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
10d0b1: 52 push %edx
10d0b2: 52 push %edx
10d0b3: 8d 45 e4 lea -0x1c(%ebp),%eax
10d0b6: 50 push %eax
10d0b7: 56 push %esi
10d0b8: e8 b3 59 00 00 call 112a70 <_POSIX_Semaphore_Name_to_id>
10d0bd: 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 ) {
10d0bf: 83 c4 10 add $0x10,%esp
10d0c2: 85 c0 test %eax,%eax
10d0c4: 74 19 je 10d0df <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) ) ) {
10d0c6: 83 f8 02 cmp $0x2,%eax
10d0c9: 75 06 jne 10d0d1 <sem_open+0x49> <== NEVER TAKEN
10d0cb: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10d0cf: 75 59 jne 10d12a <sem_open+0xa2>
_Thread_Enable_dispatch();
10d0d1: e8 3c 28 00 00 call 10f912 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
10d0d6: e8 69 7f 00 00 call 115044 <__errno>
10d0db: 89 18 mov %ebx,(%eax)
10d0dd: eb 1f jmp 10d0fe <sem_open+0x76>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
10d0df: 8b 45 0c mov 0xc(%ebp),%eax
10d0e2: 25 00 0a 00 00 and $0xa00,%eax
10d0e7: 3d 00 0a 00 00 cmp $0xa00,%eax
10d0ec: 75 15 jne 10d103 <sem_open+0x7b>
_Thread_Enable_dispatch();
10d0ee: e8 1f 28 00 00 call 10f912 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
10d0f3: e8 4c 7f 00 00 call 115044 <__errno>
10d0f8: c7 00 11 00 00 00 movl $0x11,(%eax)
10d0fe: 83 c8 ff or $0xffffffff,%eax
10d101: eb 4a jmp 10d14d <sem_open+0xc5>
10d103: 50 push %eax
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
10d104: 8d 45 dc lea -0x24(%ebp),%eax
10d107: 50 push %eax
10d108: ff 75 e4 pushl -0x1c(%ebp)
10d10b: 68 4c b2 12 00 push $0x12b24c
10d110: e8 d7 1c 00 00 call 10edec <_Objects_Get>
10d115: 89 45 e0 mov %eax,-0x20(%ebp)
the_semaphore->open_count += 1;
10d118: ff 40 18 incl 0x18(%eax)
_Thread_Enable_dispatch();
10d11b: e8 f2 27 00 00 call 10f912 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10d120: e8 ed 27 00 00 call 10f912 <_Thread_Enable_dispatch>
goto return_id;
10d125: 83 c4 10 add $0x10,%esp
10d128: eb 1d jmp 10d147 <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(
10d12a: 8d 45 e0 lea -0x20(%ebp),%eax
10d12d: 50 push %eax
10d12e: 57 push %edi
10d12f: 6a 00 push $0x0
10d131: 56 push %esi
10d132: e8 05 58 00 00 call 11293c <_POSIX_Semaphore_Create_support>
10d137: 89 c3 mov %eax,%ebx
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
10d139: e8 d4 27 00 00 call 10f912 <_Thread_Enable_dispatch>
if ( status == -1 )
10d13e: 83 c4 10 add $0x10,%esp
return SEM_FAILED;
10d141: 83 c8 ff or $0xffffffff,%eax
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
if ( status == -1 )
10d144: 43 inc %ebx
10d145: 74 06 je 10d14d <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;
10d147: 8b 45 e0 mov -0x20(%ebp),%eax
10d14a: 83 c0 08 add $0x8,%eax
#endif
return id;
}
10d14d: 8d 65 f4 lea -0xc(%ebp),%esp
10d150: 5b pop %ebx
10d151: 5e pop %esi
10d152: 5f pop %edi
10d153: c9 leave
10d154: c3 ret
0010a820 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
10a820: 55 push %ebp
10a821: 89 e5 mov %esp,%ebp
10a823: 57 push %edi
10a824: 56 push %esi
10a825: 53 push %ebx
10a826: 83 ec 1c sub $0x1c,%esp
10a829: 8b 5d 08 mov 0x8(%ebp),%ebx
10a82c: 8b 55 0c mov 0xc(%ebp),%edx
10a82f: 8b 45 10 mov 0x10(%ebp),%eax
ISR_Level level;
if ( oact )
10a832: 85 c0 test %eax,%eax
10a834: 74 12 je 10a848 <sigaction+0x28>
*oact = _POSIX_signals_Vectors[ sig ];
10a836: 6b f3 0c imul $0xc,%ebx,%esi
10a839: 81 c6 fc 78 12 00 add $0x1278fc,%esi
10a83f: b9 03 00 00 00 mov $0x3,%ecx
10a844: 89 c7 mov %eax,%edi
10a846: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !sig )
10a848: 85 db test %ebx,%ebx
10a84a: 74 0d je 10a859 <sigaction+0x39>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a84c: 8d 43 ff lea -0x1(%ebx),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
10a84f: 83 f8 1f cmp $0x1f,%eax
10a852: 77 05 ja 10a859 <sigaction+0x39>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
10a854: 83 fb 09 cmp $0x9,%ebx
10a857: 75 10 jne 10a869 <sigaction+0x49>
rtems_set_errno_and_return_minus_one( EINVAL );
10a859: e8 6e 77 00 00 call 111fcc <__errno>
10a85e: c7 00 16 00 00 00 movl $0x16,(%eax)
10a864: 83 c8 ff or $0xffffffff,%eax
10a867: eb 57 jmp 10a8c0 <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;
10a869: 31 c0 xor %eax,%eax
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
10a86b: 85 d2 test %edx,%edx
10a86d: 74 51 je 10a8c0 <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 );
10a86f: 9c pushf
10a870: fa cli
10a871: 8f 45 e4 popl -0x1c(%ebp)
if ( act->sa_handler == SIG_DFL ) {
10a874: 83 7a 08 00 cmpl $0x0,0x8(%edx)
10a878: 75 1a jne 10a894 <sigaction+0x74>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
10a87a: 6b f3 0c imul $0xc,%ebx,%esi
10a87d: 8d 86 fc 78 12 00 lea 0x1278fc(%esi),%eax
10a883: 81 c6 70 12 12 00 add $0x121270,%esi
10a889: b9 03 00 00 00 mov $0x3,%ecx
10a88e: 89 c7 mov %eax,%edi
10a890: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a892: eb 26 jmp 10a8ba <sigaction+0x9a>
} else {
_POSIX_signals_Clear_process_signals( sig );
10a894: 83 ec 0c sub $0xc,%esp
10a897: 53 push %ebx
10a898: 89 55 e0 mov %edx,-0x20(%ebp)
10a89b: e8 bc 4e 00 00 call 10f75c <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
10a8a0: 6b db 0c imul $0xc,%ebx,%ebx
10a8a3: 81 c3 fc 78 12 00 add $0x1278fc,%ebx
10a8a9: b9 03 00 00 00 mov $0x3,%ecx
10a8ae: 8b 55 e0 mov -0x20(%ebp),%edx
10a8b1: 89 df mov %ebx,%edi
10a8b3: 89 d6 mov %edx,%esi
10a8b5: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a8b7: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10a8ba: ff 75 e4 pushl -0x1c(%ebp)
10a8bd: 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;
10a8be: 31 c0 xor %eax,%eax
}
10a8c0: 8d 65 f4 lea -0xc(%ebp),%esp
10a8c3: 5b pop %ebx
10a8c4: 5e pop %esi
10a8c5: 5f pop %edi
10a8c6: c9 leave
10a8c7: c3 ret
0010abe7 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
10abe7: 55 push %ebp
10abe8: 89 e5 mov %esp,%ebp
10abea: 57 push %edi
10abeb: 56 push %esi
10abec: 53 push %ebx
10abed: 83 ec 3c sub $0x3c,%esp
10abf0: 8b 75 08 mov 0x8(%ebp),%esi
10abf3: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
10abf6: 85 f6 test %esi,%esi
10abf8: 74 24 je 10ac1e <sigtimedwait+0x37>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
10abfa: 85 db test %ebx,%ebx
10abfc: 74 30 je 10ac2e <sigtimedwait+0x47>
if ( !_Timespec_Is_valid( timeout ) )
10abfe: 83 ec 0c sub $0xc,%esp
10ac01: 53 push %ebx
10ac02: e8 5d 31 00 00 call 10dd64 <_Timespec_Is_valid>
10ac07: 83 c4 10 add $0x10,%esp
10ac0a: 84 c0 test %al,%al
10ac0c: 74 10 je 10ac1e <sigtimedwait+0x37>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
10ac0e: 83 ec 0c sub $0xc,%esp
10ac11: 53 push %ebx
10ac12: e8 a5 31 00 00 call 10ddbc <_Timespec_To_ticks>
if ( !interval )
10ac17: 83 c4 10 add $0x10,%esp
10ac1a: 85 c0 test %eax,%eax
10ac1c: 75 12 jne 10ac30 <sigtimedwait+0x49> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10ac1e: e8 51 79 00 00 call 112574 <__errno>
10ac23: c7 00 16 00 00 00 movl $0x16,(%eax)
10ac29: e9 39 01 00 00 jmp 10ad67 <sigtimedwait+0x180>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
10ac2e: 31 c0 xor %eax,%eax
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
10ac30: 8b 7d 0c mov 0xc(%ebp),%edi
10ac33: 85 ff test %edi,%edi
10ac35: 75 03 jne 10ac3a <sigtimedwait+0x53>
10ac37: 8d 7d dc lea -0x24(%ebp),%edi
the_thread = _Thread_Executing;
10ac3a: 8b 15 c8 78 12 00 mov 0x1278c8,%edx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10ac40: 8b 8a ec 00 00 00 mov 0xec(%edx),%ecx
10ac46: 89 4d d4 mov %ecx,-0x2c(%ebp)
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
10ac49: 9c pushf
10ac4a: fa cli
10ac4b: 8f 45 d0 popl -0x30(%ebp)
if ( *set & api->signals_pending ) {
10ac4e: 8b 1e mov (%esi),%ebx
10ac50: 89 5d c4 mov %ebx,-0x3c(%ebp)
10ac53: 8b 5d d4 mov -0x2c(%ebp),%ebx
10ac56: 8b 8b d4 00 00 00 mov 0xd4(%ebx),%ecx
10ac5c: 85 4d c4 test %ecx,-0x3c(%ebp)
10ac5f: 74 32 je 10ac93 <sigtimedwait+0xac>
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
10ac61: 83 ec 0c sub $0xc,%esp
10ac64: 51 push %ecx
10ac65: e8 3e ff ff ff call 10aba8 <_POSIX_signals_Get_lowest>
10ac6a: 89 07 mov %eax,(%edi)
_POSIX_signals_Clear_signals(
10ac6c: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ac73: 6a 00 push $0x0
10ac75: 57 push %edi
10ac76: 50 push %eax
10ac77: 53 push %ebx
10ac78: e8 2b 51 00 00 call 10fda8 <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
10ac7d: ff 75 d0 pushl -0x30(%ebp)
10ac80: 9d popf
the_info->si_code = SI_USER;
10ac81: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10ac88: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return the_info->si_signo;
10ac8f: 8b 1f mov (%edi),%ebx
10ac91: eb 3d jmp 10acd0 <sigtimedwait+0xe9>
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
10ac93: 8b 0d f0 7a 12 00 mov 0x127af0,%ecx
10ac99: 85 4d c4 test %ecx,-0x3c(%ebp)
10ac9c: 74 3a je 10acd8 <sigtimedwait+0xf1>
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
10ac9e: 83 ec 0c sub $0xc,%esp
10aca1: 51 push %ecx
10aca2: e8 01 ff ff ff call 10aba8 <_POSIX_signals_Get_lowest>
10aca7: 89 c3 mov %eax,%ebx
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
10aca9: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10acb0: 6a 01 push $0x1
10acb2: 57 push %edi
10acb3: 50 push %eax
10acb4: ff 75 d4 pushl -0x2c(%ebp)
10acb7: e8 ec 50 00 00 call 10fda8 <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
10acbc: ff 75 d0 pushl -0x30(%ebp)
10acbf: 9d popf
the_info->si_signo = signo;
10acc0: 89 1f mov %ebx,(%edi)
the_info->si_code = SI_USER;
10acc2: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10acc9: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return signo;
10acd0: 83 c4 20 add $0x20,%esp
10acd3: e9 92 00 00 00 jmp 10ad6a <sigtimedwait+0x183>
}
the_info->si_signo = -1;
10acd8: c7 07 ff ff ff ff movl $0xffffffff,(%edi)
10acde: 8b 0d a0 73 12 00 mov 0x1273a0,%ecx
10ace4: 41 inc %ecx
10ace5: 89 0d a0 73 12 00 mov %ecx,0x1273a0
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
10aceb: c7 42 44 88 7a 12 00 movl $0x127a88,0x44(%edx)
the_thread->Wait.return_code = EINTR;
10acf2: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx)
the_thread->Wait.option = *set;
10acf9: 8b 0e mov (%esi),%ecx
10acfb: 89 4a 30 mov %ecx,0x30(%edx)
the_thread->Wait.return_argument = the_info;
10acfe: 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;
10ad01: c7 05 b8 7a 12 00 01 movl $0x1,0x127ab8
10ad08: 00 00 00
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
10ad0b: ff 75 d0 pushl -0x30(%ebp)
10ad0e: 9d popf
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
10ad0f: 52 push %edx
10ad10: 68 e0 da 10 00 push $0x10dae0
10ad15: 50 push %eax
10ad16: 68 88 7a 12 00 push $0x127a88
10ad1b: e8 e4 2a 00 00 call 10d804 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10ad20: e8 95 26 00 00 call 10d3ba <_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 );
10ad25: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ad2c: 6a 00 push $0x0
10ad2e: 57 push %edi
10ad2f: ff 37 pushl (%edi)
10ad31: ff 75 d4 pushl -0x2c(%ebp)
10ad34: e8 6f 50 00 00 call 10fda8 <_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)
10ad39: 83 c4 20 add $0x20,%esp
10ad3c: a1 c8 78 12 00 mov 0x1278c8,%eax
10ad41: 83 78 34 04 cmpl $0x4,0x34(%eax)
10ad45: 75 10 jne 10ad57 <sigtimedwait+0x170>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
10ad47: 8b 1f mov (%edi),%ebx
10ad49: 8d 4b ff lea -0x1(%ebx),%ecx
10ad4c: b8 01 00 00 00 mov $0x1,%eax
10ad51: d3 e0 shl %cl,%eax
10ad53: 85 06 test %eax,(%esi)
10ad55: 75 13 jne 10ad6a <sigtimedwait+0x183>
errno = _Thread_Executing->Wait.return_code;
10ad57: e8 18 78 00 00 call 112574 <__errno>
10ad5c: 8b 15 c8 78 12 00 mov 0x1278c8,%edx
10ad62: 8b 52 34 mov 0x34(%edx),%edx
10ad65: 89 10 mov %edx,(%eax)
return -1;
10ad67: 83 cb ff or $0xffffffff,%ebx
}
return the_info->si_signo;
}
10ad6a: 89 d8 mov %ebx,%eax
10ad6c: 8d 65 f4 lea -0xc(%ebp),%esp
10ad6f: 5b pop %ebx
10ad70: 5e pop %esi
10ad71: 5f pop %edi
10ad72: c9 leave
10ad73: c3 ret
0010ca68 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
10ca68: 55 push %ebp
10ca69: 89 e5 mov %esp,%ebp
10ca6b: 53 push %ebx
10ca6c: 83 ec 08 sub $0x8,%esp
10ca6f: 8b 5d 0c mov 0xc(%ebp),%ebx
int status;
status = sigtimedwait( set, NULL, NULL );
10ca72: 6a 00 push $0x0
10ca74: 6a 00 push $0x0
10ca76: ff 75 08 pushl 0x8(%ebp)
10ca79: e8 45 fe ff ff call 10c8c3 <sigtimedwait>
10ca7e: 89 c2 mov %eax,%edx
if ( status != -1 ) {
10ca80: 83 c4 10 add $0x10,%esp
10ca83: 83 f8 ff cmp $0xffffffff,%eax
10ca86: 74 0a je 10ca92 <sigwait+0x2a>
if ( sig )
*sig = status;
return 0;
10ca88: 31 c0 xor %eax,%eax
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
10ca8a: 85 db test %ebx,%ebx
10ca8c: 74 0b je 10ca99 <sigwait+0x31> <== NEVER TAKEN
*sig = status;
10ca8e: 89 13 mov %edx,(%ebx)
10ca90: eb 07 jmp 10ca99 <sigwait+0x31>
return 0;
}
return errno;
10ca92: e8 05 73 00 00 call 113d9c <__errno>
10ca97: 8b 00 mov (%eax),%eax
}
10ca99: 8b 5d fc mov -0x4(%ebp),%ebx
10ca9c: c9 leave
10ca9d: c3 ret
00108f80 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
108f80: 55 push %ebp
108f81: 89 e5 mov %esp,%ebp
108f83: 56 push %esi
108f84: 53 push %ebx
108f85: 89 d3 mov %edx,%ebx
108f87: 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)) {
108f89: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx)
108f90: 74 30 je 108fc2 <siproc+0x42> <== NEVER TAKEN
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108f92: 52 push %edx
108f93: 6a 00 push $0x0
108f95: 6a 00 push $0x0
108f97: ff 73 18 pushl 0x18(%ebx)
108f9a: e8 1d 12 00 00 call 10a1bc <rtems_semaphore_obtain>
i = iproc (c, tty);
108f9f: 89 f2 mov %esi,%edx
108fa1: 0f b6 c2 movzbl %dl,%eax
108fa4: 89 da mov %ebx,%edx
108fa6: e8 b5 fe ff ff call 108e60 <iproc>
108fab: 89 c6 mov %eax,%esi
rtems_semaphore_release (tty->osem);
108fad: 58 pop %eax
108fae: ff 73 18 pushl 0x18(%ebx)
108fb1: e8 f2 12 00 00 call 10a2a8 <rtems_semaphore_release>
108fb6: 83 c4 10 add $0x10,%esp
}
else {
i = iproc (c, tty);
}
return i;
}
108fb9: 89 f0 mov %esi,%eax
108fbb: 8d 65 f8 lea -0x8(%ebp),%esp
108fbe: 5b pop %ebx
108fbf: 5e pop %esi
108fc0: c9 leave
108fc1: 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);
108fc2: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
108fc5: 89 da mov %ebx,%edx <== NOT EXECUTED
}
return i;
}
108fc7: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
108fca: 5b pop %ebx <== NOT EXECUTED
108fcb: 5e pop %esi <== NOT EXECUTED
108fcc: 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);
108fcd: e9 8e fe ff ff jmp 108e60 <iproc> <== NOT EXECUTED
0010a154 <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
10a154: 55 push %ebp
10a155: 89 e5 mov %esp,%ebp
10a157: 57 push %edi
10a158: 56 push %esi
10a159: 53 push %ebx
10a15a: 83 ec 38 sub $0x38,%esp
10a15d: 8b 55 08 mov 0x8(%ebp),%edx
10a160: 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 ) )
10a163: 31 c0 xor %eax,%eax
10a165: 83 c9 ff or $0xffffffff,%ecx
10a168: 89 d7 mov %edx,%edi
10a16a: f2 ae repnz scas %es:(%edi),%al
10a16c: f7 d1 not %ecx
10a16e: 49 dec %ecx
10a16f: 6a 01 push $0x1
10a171: 8d 5d d4 lea -0x2c(%ebp),%ebx
10a174: 53 push %ebx
10a175: 6a 00 push $0x0
10a177: 51 push %ecx
10a178: 52 push %edx
10a179: e8 04 ee ff ff call 108f82 <rtems_filesystem_evaluate_path>
10a17e: 83 c4 20 add $0x20,%esp
return -1;
10a181: 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 ) )
10a184: 85 c0 test %eax,%eax
10a186: 75 26 jne 10a1ae <statvfs+0x5a> <== NEVER TAKEN
return -1;
mt_entry = loc.mt_entry;
10a188: 8b 55 e4 mov -0x1c(%ebp),%edx
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
10a18b: b9 0e 00 00 00 mov $0xe,%ecx
10a190: 89 f7 mov %esi,%edi
10a192: f3 ab rep stos %eax,%es:(%edi)
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
10a194: 50 push %eax
10a195: 50 push %eax
10a196: 8b 42 28 mov 0x28(%edx),%eax
10a199: 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;
10a19a: 83 c2 1c add $0x1c,%edx
memset (sb, 0, sizeof (struct statvfs));
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
10a19d: 52 push %edx
10a19e: ff 50 44 call *0x44(%eax)
10a1a1: 89 c7 mov %eax,%edi
rtems_filesystem_freenode( &loc );
10a1a3: 89 1c 24 mov %ebx,(%esp)
10a1a6: e8 95 ee ff ff call 109040 <rtems_filesystem_freenode>
return result;
10a1ab: 83 c4 10 add $0x10,%esp
}
10a1ae: 89 f8 mov %edi,%eax
10a1b0: 8d 65 f4 lea -0xc(%ebp),%esp
10a1b3: 5b pop %ebx
10a1b4: 5e pop %esi
10a1b5: 5f pop %edi
10a1b6: c9 leave
10a1b7: c3 ret
00108fbc <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
108fbc: 55 push %ebp
108fbd: 89 e5 mov %esp,%ebp
108fbf: 53 push %ebx
108fc0: 83 ec 04 sub $0x4,%esp
108fc3: 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;
108fc6: 8b 88 e4 00 00 00 mov 0xe4(%eax),%ecx
if ( this_reent ) {
108fcc: 85 c9 test %ecx,%ecx
108fce: 74 32 je 109002 <sync_per_thread+0x46> <== NEVER TAKEN
current_reent = _Thread_Executing->libc_reent;
108fd0: 8b 15 68 68 12 00 mov 0x126868,%edx
108fd6: 8b 9a e4 00 00 00 mov 0xe4(%edx),%ebx
_Thread_Executing->libc_reent = this_reent;
108fdc: 89 8a e4 00 00 00 mov %ecx,0xe4(%edx)
_fwalk (t->libc_reent, sync_wrapper);
108fe2: 52 push %edx
108fe3: 52 push %edx
108fe4: 68 07 90 10 00 push $0x109007
108fe9: ff b0 e4 00 00 00 pushl 0xe4(%eax)
108fef: e8 c4 9e 00 00 call 112eb8 <_fwalk>
_Thread_Executing->libc_reent = current_reent;
108ff4: a1 68 68 12 00 mov 0x126868,%eax
108ff9: 89 98 e4 00 00 00 mov %ebx,0xe4(%eax)
108fff: 83 c4 10 add $0x10,%esp
}
}
109002: 8b 5d fc mov -0x4(%ebp),%ebx
109005: c9 leave
109006: c3 ret
0010987c <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
10987c: 55 push %ebp
10987d: 89 e5 mov %esp,%ebp
10987f: 56 push %esi
109880: 53 push %ebx
109881: 8b 5d 08 mov 0x8(%ebp),%ebx
109884: 8b 45 0c mov 0xc(%ebp),%eax
109887: 8b 75 10 mov 0x10(%ebp),%esi
switch (opt) {
10988a: 85 c0 test %eax,%eax
10988c: 74 22 je 1098b0 <tcsetattr+0x34>
10988e: 48 dec %eax
10988f: 74 0d je 10989e <tcsetattr+0x22>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
109891: e8 66 92 00 00 call 112afc <__errno>
109896: c7 00 86 00 00 00 movl $0x86,(%eax)
10989c: eb 2a jmp 1098c8 <tcsetattr+0x4c>
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
10989e: 50 push %eax
10989f: 6a 00 push $0x0
1098a1: 6a 03 push $0x3
1098a3: 53 push %ebx
1098a4: e8 7b 64 00 00 call 10fd24 <ioctl>
1098a9: 83 c4 10 add $0x10,%esp
1098ac: 85 c0 test %eax,%eax
1098ae: 78 18 js 1098c8 <tcsetattr+0x4c> <== NEVER TAKEN
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
1098b0: 89 75 10 mov %esi,0x10(%ebp)
1098b3: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp)
1098ba: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
1098bd: 8d 65 f8 lea -0x8(%ebp),%esp
1098c0: 5b pop %ebx
1098c1: 5e pop %esi
1098c2: c9 leave
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
1098c3: e9 5c 64 00 00 jmp 10fd24 <ioctl>
}
}
1098c8: 83 c8 ff or $0xffffffff,%eax
1098cb: 8d 65 f8 lea -0x8(%ebp),%esp
1098ce: 5b pop %ebx
1098cf: 5e pop %esi
1098d0: c9 leave
1098d1: c3 ret
0010a084 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
10a084: 55 push %ebp
10a085: 89 e5 mov %esp,%ebp
10a087: 56 push %esi
10a088: 53 push %ebx
10a089: 8b 5d 0c mov 0xc(%ebp),%ebx
10a08c: 8b 75 10 mov 0x10(%ebp),%esi
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
10a08f: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
10a093: 75 1d jne 10a0b2 <timer_create+0x2e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
10a095: 85 f6 test %esi,%esi
10a097: 74 19 je 10a0b2 <timer_create+0x2e>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
10a099: 85 db test %ebx,%ebx
10a09b: 74 22 je 10a0bf <timer_create+0x3b>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
10a09d: 8b 03 mov (%ebx),%eax
10a09f: 48 dec %eax
10a0a0: 83 f8 01 cmp $0x1,%eax
10a0a3: 77 0d ja 10a0b2 <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 )
10a0a5: 8b 43 04 mov 0x4(%ebx),%eax
10a0a8: 85 c0 test %eax,%eax
10a0aa: 74 06 je 10a0b2 <timer_create+0x2e> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a0ac: 48 dec %eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
10a0ad: 83 f8 1f cmp $0x1f,%eax
10a0b0: 76 0d jbe 10a0bf <timer_create+0x3b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10a0b2: e8 9d 7c 00 00 call 111d54 <__errno>
10a0b7: c7 00 16 00 00 00 movl $0x16,(%eax)
10a0bd: eb 2f jmp 10a0ee <timer_create+0x6a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a0bf: a1 b4 73 12 00 mov 0x1273b4,%eax
10a0c4: 40 inc %eax
10a0c5: 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 );
10a0ca: 83 ec 0c sub $0xc,%esp
10a0cd: 68 98 76 12 00 push $0x127698
10a0d2: e8 75 1b 00 00 call 10bc4c <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
10a0d7: 83 c4 10 add $0x10,%esp
10a0da: 85 c0 test %eax,%eax
10a0dc: 75 18 jne 10a0f6 <timer_create+0x72>
_Thread_Enable_dispatch();
10a0de: e8 47 2a 00 00 call 10cb2a <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
10a0e3: e8 6c 7c 00 00 call 111d54 <__errno>
10a0e8: c7 00 0b 00 00 00 movl $0xb,(%eax)
10a0ee: 83 c8 ff or $0xffffffff,%eax
10a0f1: e9 83 00 00 00 jmp 10a179 <timer_create+0xf5>
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
10a0f6: c6 40 3c 02 movb $0x2,0x3c(%eax)
ptimer->thread_id = _Thread_Executing->Object.id;
10a0fa: 8b 15 dc 78 12 00 mov 0x1278dc,%edx
10a100: 8b 52 08 mov 0x8(%edx),%edx
10a103: 89 50 38 mov %edx,0x38(%eax)
if ( evp != NULL ) {
10a106: 85 db test %ebx,%ebx
10a108: 74 11 je 10a11b <timer_create+0x97>
ptimer->inf.sigev_notify = evp->sigev_notify;
10a10a: 8b 13 mov (%ebx),%edx
10a10c: 89 50 40 mov %edx,0x40(%eax)
ptimer->inf.sigev_signo = evp->sigev_signo;
10a10f: 8b 53 04 mov 0x4(%ebx),%edx
10a112: 89 50 44 mov %edx,0x44(%eax)
ptimer->inf.sigev_value = evp->sigev_value;
10a115: 8b 53 08 mov 0x8(%ebx),%edx
10a118: 89 50 48 mov %edx,0x48(%eax)
}
ptimer->overrun = 0;
10a11b: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax)
ptimer->timer_data.it_value.tv_sec = 0;
10a122: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
ptimer->timer_data.it_value.tv_nsec = 0;
10a129: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
ptimer->timer_data.it_interval.tv_sec = 0;
10a130: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
ptimer->timer_data.it_interval.tv_nsec = 0;
10a137: 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;
10a13e: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10a145: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10a14c: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10a153: 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 ),
10a15a: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a15d: 0f b7 da movzwl %dx,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a160: 8b 0d b4 76 12 00 mov 0x1276b4,%ecx
10a166: 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;
10a169: 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;
10a170: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10a172: e8 b3 29 00 00 call 10cb2a <_Thread_Enable_dispatch>
return 0;
10a177: 31 c0 xor %eax,%eax
}
10a179: 8d 65 f8 lea -0x8(%ebp),%esp
10a17c: 5b pop %ebx
10a17d: 5e pop %esi
10a17e: c9 leave
10a17f: c3 ret
0010a180 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
10a180: 55 push %ebp
10a181: 89 e5 mov %esp,%ebp
10a183: 57 push %edi
10a184: 56 push %esi
10a185: 53 push %ebx
10a186: 83 ec 2c sub $0x2c,%esp
10a189: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
10a18c: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a190: 0f 84 58 01 00 00 je 10a2ee <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) ) ) {
10a196: 83 ec 0c sub $0xc,%esp
10a199: 8b 45 10 mov 0x10(%ebp),%eax
10a19c: 83 c0 08 add $0x8,%eax
10a19f: 50 push %eax
10a1a0: e8 53 33 00 00 call 10d4f8 <_Timespec_Is_valid>
10a1a5: 83 c4 10 add $0x10,%esp
10a1a8: 84 c0 test %al,%al
10a1aa: 0f 84 3e 01 00 00 je 10a2ee <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
10a1b0: 83 ec 0c sub $0xc,%esp
10a1b3: ff 75 10 pushl 0x10(%ebp)
10a1b6: e8 3d 33 00 00 call 10d4f8 <_Timespec_Is_valid>
10a1bb: 83 c4 10 add $0x10,%esp
10a1be: 84 c0 test %al,%al
10a1c0: 0f 84 28 01 00 00 je 10a2ee <timer_settime+0x16e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
10a1c6: 85 db test %ebx,%ebx
10a1c8: 74 09 je 10a1d3 <timer_settime+0x53>
10a1ca: 83 fb 04 cmp $0x4,%ebx
10a1cd: 0f 85 1b 01 00 00 jne 10a2ee <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
10a1d3: 8d 7d cc lea -0x34(%ebp),%edi
10a1d6: b9 04 00 00 00 mov $0x4,%ecx
10a1db: 8b 75 10 mov 0x10(%ebp),%esi
10a1de: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
10a1e0: 83 fb 04 cmp $0x4,%ebx
10a1e3: 75 2f jne 10a214 <timer_settime+0x94>
struct timespec now;
_TOD_Get( &now );
10a1e5: 83 ec 0c sub $0xc,%esp
10a1e8: 8d 5d dc lea -0x24(%ebp),%ebx
10a1eb: 53 push %ebx
10a1ec: e8 b3 15 00 00 call 10b7a4 <_TOD_Get>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
10a1f1: 59 pop %ecx
10a1f2: 5e pop %esi
10a1f3: 8d 75 d4 lea -0x2c(%ebp),%esi
10a1f6: 56 push %esi
10a1f7: 53 push %ebx
10a1f8: e8 d7 32 00 00 call 10d4d4 <_Timespec_Greater_than>
10a1fd: 83 c4 10 add $0x10,%esp
10a200: 84 c0 test %al,%al
10a202: 0f 85 e6 00 00 00 jne 10a2ee <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
10a208: 52 push %edx
10a209: 56 push %esi
10a20a: 56 push %esi
10a20b: 53 push %ebx
10a20c: e8 0b 33 00 00 call 10d51c <_Timespec_Subtract>
10a211: 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 );
10a214: 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 );
10a215: 8d 45 e4 lea -0x1c(%ebp),%eax
10a218: 50 push %eax
10a219: ff 75 08 pushl 0x8(%ebp)
10a21c: 68 98 76 12 00 push $0x127698
10a221: e8 52 1e 00 00 call 10c078 <_Objects_Get>
10a226: 89 c3 mov %eax,%ebx
switch ( location ) {
10a228: 83 c4 10 add $0x10,%esp
10a22b: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10a22f: 0f 85 b9 00 00 00 jne 10a2ee <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 ) {
10a235: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10a239: 75 3b jne 10a276 <timer_settime+0xf6>
10a23b: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10a23f: 75 35 jne 10a276 <timer_settime+0xf6>
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
10a241: 83 ec 0c sub $0xc,%esp
10a244: 8d 40 10 lea 0x10(%eax),%eax
10a247: 50 push %eax
10a248: e8 9b 36 00 00 call 10d8e8 <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
10a24d: 83 c4 10 add $0x10,%esp
10a250: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a254: 74 0d je 10a263 <timer_settime+0xe3>
*ovalue = ptimer->timer_data;
10a256: 8d 73 54 lea 0x54(%ebx),%esi
10a259: b9 04 00 00 00 mov $0x4,%ecx
10a25e: 8b 7d 14 mov 0x14(%ebp),%edi
10a261: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* The new data are set */
ptimer->timer_data = normalize;
10a263: 8d 7b 54 lea 0x54(%ebx),%edi
10a266: 8d 75 cc lea -0x34(%ebp),%esi
10a269: b9 04 00 00 00 mov $0x4,%ecx
10a26e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a270: c6 43 3c 04 movb $0x4,0x3c(%ebx)
10a274: eb 35 jmp 10a2ab <timer_settime+0x12b>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
10a276: 83 ec 0c sub $0xc,%esp
10a279: ff 75 10 pushl 0x10(%ebp)
10a27c: e8 cf 32 00 00 call 10d550 <_Timespec_To_ticks>
10a281: 89 43 64 mov %eax,0x64(%ebx)
initial_period = _Timespec_To_ticks( &normalize.it_value );
10a284: 8d 45 d4 lea -0x2c(%ebp),%eax
10a287: 89 04 24 mov %eax,(%esp)
10a28a: e8 c1 32 00 00 call 10d550 <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
10a28f: 89 1c 24 mov %ebx,(%esp)
10a292: 68 04 a3 10 00 push $0x10a304
10a297: ff 73 08 pushl 0x8(%ebx)
10a29a: 50 push %eax
10a29b: 8d 43 10 lea 0x10(%ebx),%eax
10a29e: 50 push %eax
10a29f: e8 78 57 00 00 call 10fa1c <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
10a2a4: 83 c4 20 add $0x20,%esp
10a2a7: 84 c0 test %al,%al
10a2a9: 75 07 jne 10a2b2 <timer_settime+0x132>
_Thread_Enable_dispatch();
10a2ab: e8 7a 28 00 00 call 10cb2a <_Thread_Enable_dispatch>
10a2b0: eb 38 jmp 10a2ea <timer_settime+0x16a>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
10a2b2: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a2b6: 74 0d je 10a2c5 <timer_settime+0x145>
*ovalue = ptimer->timer_data;
10a2b8: 8d 73 54 lea 0x54(%ebx),%esi
10a2bb: b9 04 00 00 00 mov $0x4,%ecx
10a2c0: 8b 7d 14 mov 0x14(%ebp),%edi
10a2c3: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ptimer->timer_data = normalize;
10a2c5: 8d 7b 54 lea 0x54(%ebx),%edi
10a2c8: 8d 75 cc lea -0x34(%ebp),%esi
10a2cb: b9 04 00 00 00 mov $0x4,%ecx
10a2d0: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a2d2: c6 43 3c 03 movb $0x3,0x3c(%ebx)
_TOD_Get( &ptimer->time );
10a2d6: 83 ec 0c sub $0xc,%esp
10a2d9: 83 c3 6c add $0x6c,%ebx
10a2dc: 53 push %ebx
10a2dd: e8 c2 14 00 00 call 10b7a4 <_TOD_Get>
_Thread_Enable_dispatch();
10a2e2: e8 43 28 00 00 call 10cb2a <_Thread_Enable_dispatch>
return 0;
10a2e7: 83 c4 10 add $0x10,%esp
10a2ea: 31 c0 xor %eax,%eax
10a2ec: eb 0e jmp 10a2fc <timer_settime+0x17c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10a2ee: e8 61 7a 00 00 call 111d54 <__errno>
10a2f3: c7 00 16 00 00 00 movl $0x16,(%eax)
10a2f9: 83 c8 ff or $0xffffffff,%eax
}
10a2fc: 8d 65 f4 lea -0xc(%ebp),%esp
10a2ff: 5b pop %ebx
10a300: 5e pop %esi
10a301: 5f pop %edi
10a302: c9 leave
10a303: c3 ret
00109fc0 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
109fc0: 55 push %ebp
109fc1: 89 e5 mov %esp,%ebp
109fc3: 57 push %edi
109fc4: 56 push %esi
109fc5: 53 push %ebx
109fc6: 83 ec 1c sub $0x1c,%esp
109fc9: 8b 75 08 mov 0x8(%ebp),%esi
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
109fcc: 83 3d 00 7d 12 00 00 cmpl $0x0,0x127d00
109fd3: 75 2c jne 10a001 <ualarm+0x41> <== NEVER TAKEN
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
109fd5: c7 05 ec 7c 12 00 00 movl $0x0,0x127cec
109fdc: 00 00 00
the_watchdog->routine = routine;
109fdf: c7 05 00 7d 12 00 88 movl $0x109f88,0x127d00
109fe6: 9f 10 00
the_watchdog->id = id;
109fe9: c7 05 04 7d 12 00 00 movl $0x0,0x127d04
109ff0: 00 00 00
the_watchdog->user_data = user_data;
109ff3: c7 05 08 7d 12 00 00 movl $0x0,0x127d08
109ffa: 00 00 00
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
109ffd: 31 db xor %ebx,%ebx
109fff: eb 4f jmp 10a050 <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 );
10a001: 83 ec 0c sub $0xc,%esp
10a004: 68 e4 7c 12 00 push $0x127ce4
10a009: e8 c2 34 00 00 call 10d4d0 <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
10a00e: 83 e8 02 sub $0x2,%eax
10a011: 83 c4 10 add $0x10,%esp
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
10a014: 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) ) {
10a016: 83 f8 01 cmp $0x1,%eax
10a019: 77 35 ja 10a050 <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);
10a01b: a1 f8 7c 12 00 mov 0x127cf8,%eax
10a020: 03 05 f0 7c 12 00 add 0x127cf0,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
10a026: 57 push %edi
10a027: 57 push %edi
10a028: 8d 55 e0 lea -0x20(%ebp),%edx
10a02b: 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);
10a02c: 2b 05 fc 7c 12 00 sub 0x127cfc,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
10a032: 50 push %eax
10a033: e8 38 30 00 00 call 10d070 <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
10a038: 69 4d e0 40 42 0f 00 imul $0xf4240,-0x20(%ebp),%ecx
remaining += tp.tv_nsec / 1000;
10a03f: 8b 45 e4 mov -0x1c(%ebp),%eax
10a042: bf e8 03 00 00 mov $0x3e8,%edi
10a047: 99 cltd
10a048: f7 ff idiv %edi
10a04a: 8d 1c 08 lea (%eax,%ecx,1),%ebx
10a04d: 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 ) {
10a050: 85 f6 test %esi,%esi
10a052: 74 44 je 10a098 <ualarm+0xd8>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
10a054: b9 40 42 0f 00 mov $0xf4240,%ecx
10a059: 89 f0 mov %esi,%eax
10a05b: 31 d2 xor %edx,%edx
10a05d: f7 f1 div %ecx
10a05f: 89 45 e0 mov %eax,-0x20(%ebp)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
10a062: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx
10a068: 89 55 e4 mov %edx,-0x1c(%ebp)
ticks = _Timespec_To_ticks( &tp );
10a06b: 83 ec 0c sub $0xc,%esp
10a06e: 8d 75 e0 lea -0x20(%ebp),%esi
10a071: 56 push %esi
10a072: e8 55 30 00 00 call 10d0cc <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
10a077: 89 34 24 mov %esi,(%esp)
10a07a: e8 4d 30 00 00 call 10d0cc <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a07f: a3 f0 7c 12 00 mov %eax,0x127cf0
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a084: 59 pop %ecx
10a085: 5e pop %esi
10a086: 68 e4 7c 12 00 push $0x127ce4
10a08b: 68 d4 74 12 00 push $0x1274d4
10a090: e8 1b 33 00 00 call 10d3b0 <_Watchdog_Insert>
10a095: 83 c4 10 add $0x10,%esp
}
return remaining;
}
10a098: 89 d8 mov %ebx,%eax
10a09a: 8d 65 f4 lea -0xc(%ebp),%esp
10a09d: 5b pop %ebx
10a09e: 5e pop %esi
10a09f: 5f pop %edi
10a0a0: c9 leave
10a0a1: c3 ret
0010a71c <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
10a71c: 55 push %ebp
10a71d: 89 e5 mov %esp,%ebp
10a71f: 57 push %edi
10a720: 56 push %esi
10a721: 53 push %ebx
10a722: 83 ec 58 sub $0x58,%esp
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
10a725: ff 75 08 pushl 0x8(%ebp)
10a728: e8 f6 d8 ff ff call 108023 <rtems_filesystem_dirname>
10a72d: 89 45 b4 mov %eax,-0x4c(%ebp)
if ( parentpathlen == 0 )
10a730: 83 c4 10 add $0x10,%esp
10a733: 85 c0 test %eax,%eax
10a735: 8d 45 d0 lea -0x30(%ebp),%eax
10a738: 75 15 jne 10a74f <unlink+0x33>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
10a73a: 51 push %ecx
10a73b: 50 push %eax
10a73c: 8d 45 e4 lea -0x1c(%ebp),%eax
10a73f: 50 push %eax
10a740: ff 75 08 pushl 0x8(%ebp)
10a743: e8 d4 e6 ff ff call 108e1c <rtems_filesystem_get_start_loc>
10a748: 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;
10a74b: 31 db xor %ebx,%ebx
10a74d: eb 25 jmp 10a774 <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,
10a74f: 83 ec 0c sub $0xc,%esp
10a752: 6a 00 push $0x0
10a754: 50 push %eax
10a755: 6a 02 push $0x2
10a757: ff 75 b4 pushl -0x4c(%ebp)
10a75a: ff 75 08 pushl 0x8(%ebp)
10a75d: e8 80 d8 ff ff call 107fe2 <rtems_filesystem_evaluate_path>
10a762: 89 c2 mov %eax,%edx
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
10a764: 83 c4 20 add $0x20,%esp
return -1;
10a767: 83 c8 ff or $0xffffffff,%eax
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
10a76a: 85 d2 test %edx,%edx
10a76c: 0f 85 d6 00 00 00 jne 10a848 <unlink+0x12c> <== NEVER TAKEN
return -1;
free_parentloc = true;
10a772: b3 01 mov $0x1,%bl
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
10a774: 8d 7d bc lea -0x44(%ebp),%edi
10a777: 8d 75 d0 lea -0x30(%ebp),%esi
10a77a: b9 05 00 00 00 mov $0x5,%ecx
10a77f: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = path + parentpathlen;
10a781: 8b 75 08 mov 0x8(%ebp),%esi
10a784: 03 75 b4 add -0x4c(%ebp),%esi
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
10a787: 83 c9 ff or $0xffffffff,%ecx
10a78a: 89 f7 mov %esi,%edi
10a78c: 31 c0 xor %eax,%eax
10a78e: f2 ae repnz scas %es:(%edi),%al
10a790: f7 d1 not %ecx
10a792: 49 dec %ecx
10a793: 52 push %edx
10a794: 52 push %edx
10a795: 51 push %ecx
10a796: 56 push %esi
10a797: e8 c6 d8 ff ff call 108062 <rtems_filesystem_prefix_separators>
10a79c: 01 c6 add %eax,%esi
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
10a79e: 83 c9 ff or $0xffffffff,%ecx
10a7a1: 89 f7 mov %esi,%edi
10a7a3: 31 c0 xor %eax,%eax
10a7a5: f2 ae repnz scas %es:(%edi),%al
10a7a7: f7 d1 not %ecx
10a7a9: 49 dec %ecx
10a7aa: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10a7b1: 8d 7d bc lea -0x44(%ebp),%edi
10a7b4: 57 push %edi
10a7b5: 6a 00 push $0x0
10a7b7: 51 push %ecx
10a7b8: 56 push %esi
10a7b9: e8 c6 d7 ff ff call 107f84 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
10a7be: 83 c4 20 add $0x20,%esp
10a7c1: 85 c0 test %eax,%eax
10a7c3: 74 13 je 10a7d8 <unlink+0xbc>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
10a7c5: 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 )
10a7c8: 84 db test %bl,%bl
10a7ca: 74 7c je 10a848 <unlink+0x12c> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
10a7cc: 83 ec 0c sub $0xc,%esp
10a7cf: 8d 55 d0 lea -0x30(%ebp),%edx
10a7d2: 52 push %edx
10a7d3: 89 45 b0 mov %eax,-0x50(%ebp)
10a7d6: eb 65 jmp 10a83d <unlink+0x121>
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
10a7d8: 83 ec 0c sub $0xc,%esp
10a7db: 57 push %edi
10a7dc: 8b 45 c8 mov -0x38(%ebp),%eax
10a7df: ff 50 10 call *0x10(%eax)
10a7e2: 83 c4 10 add $0x10,%esp
10a7e5: 48 dec %eax
10a7e6: 75 2f jne 10a817 <unlink+0xfb>
rtems_filesystem_freenode( &loc );
10a7e8: 83 ec 0c sub $0xc,%esp
10a7eb: 57 push %edi
10a7ec: e8 af d8 ff ff call 1080a0 <rtems_filesystem_freenode>
if ( free_parentloc )
10a7f1: 83 c4 10 add $0x10,%esp
10a7f4: 84 db test %bl,%bl
10a7f6: 74 0f je 10a807 <unlink+0xeb>
rtems_filesystem_freenode( &parentloc );
10a7f8: 83 ec 0c sub $0xc,%esp
10a7fb: 8d 45 d0 lea -0x30(%ebp),%eax
10a7fe: 50 push %eax
10a7ff: e8 9c d8 ff ff call 1080a0 <rtems_filesystem_freenode>
10a804: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( EISDIR );
10a807: e8 2c a0 00 00 call 114838 <__errno>
10a80c: c7 00 15 00 00 00 movl $0x15,(%eax)
10a812: 83 c8 ff or $0xffffffff,%eax
10a815: eb 31 jmp 10a848 <unlink+0x12c>
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
10a817: 50 push %eax
10a818: 50 push %eax
10a819: 57 push %edi
10a81a: 8d 75 d0 lea -0x30(%ebp),%esi
10a81d: 56 push %esi
10a81e: 8b 45 c8 mov -0x38(%ebp),%eax
10a821: ff 50 0c call *0xc(%eax)
rtems_filesystem_freenode( &loc );
10a824: 89 3c 24 mov %edi,(%esp)
10a827: 89 45 b0 mov %eax,-0x50(%ebp)
10a82a: e8 71 d8 ff ff call 1080a0 <rtems_filesystem_freenode>
if ( free_parentloc )
10a82f: 83 c4 10 add $0x10,%esp
10a832: 84 db test %bl,%bl
10a834: 8b 45 b0 mov -0x50(%ebp),%eax
10a837: 74 0f je 10a848 <unlink+0x12c>
rtems_filesystem_freenode( &parentloc );
10a839: 83 ec 0c sub $0xc,%esp
10a83c: 56 push %esi
10a83d: e8 5e d8 ff ff call 1080a0 <rtems_filesystem_freenode>
10a842: 83 c4 10 add $0x10,%esp
10a845: 8b 45 b0 mov -0x50(%ebp),%eax
return result;
}
10a848: 8d 65 f4 lea -0xc(%ebp),%esp
10a84b: 5b pop %ebx
10a84c: 5e pop %esi
10a84d: 5f pop %edi
10a84e: c9 leave
10a84f: c3 ret
0010a989 <unmount>:
*/
int unmount(
const char *path
)
{
10a989: 55 push %ebp
10a98a: 89 e5 mov %esp,%ebp
10a98c: 57 push %edi
10a98d: 56 push %esi
10a98e: 53 push %ebx
10a98f: 83 ec 38 sub $0x38,%esp
10a992: 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 ) )
10a995: 83 cb ff or $0xffffffff,%ebx
10a998: 31 c0 xor %eax,%eax
10a99a: 89 d9 mov %ebx,%ecx
10a99c: 89 d7 mov %edx,%edi
10a99e: f2 ae repnz scas %es:(%edi),%al
10a9a0: f7 d1 not %ecx
10a9a2: 49 dec %ecx
10a9a3: 6a 01 push $0x1
10a9a5: 8d 7d d4 lea -0x2c(%ebp),%edi
10a9a8: 57 push %edi
10a9a9: 6a 00 push $0x0
10a9ab: 51 push %ecx
10a9ac: 52 push %edx
10a9ad: e8 c4 d5 ff ff call 107f76 <rtems_filesystem_evaluate_path>
10a9b2: 83 c4 20 add $0x20,%esp
10a9b5: 85 c0 test %eax,%eax
10a9b7: 0f 85 f2 00 00 00 jne 10aaaf <unmount+0x126>
return -1;
mt_entry = loc.mt_entry;
10a9bd: 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 ){
10a9c0: 8b 45 d4 mov -0x2c(%ebp),%eax
10a9c3: 39 46 1c cmp %eax,0x1c(%esi)
10a9c6: 74 1c je 10a9e4 <unmount+0x5b>
rtems_filesystem_freenode( &loc );
10a9c8: 83 ec 0c sub $0xc,%esp
10a9cb: 57 push %edi
10a9cc: e8 63 d6 ff ff call 108034 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EACCES );
10a9d1: e8 ea 76 00 00 call 1120c0 <__errno>
10a9d6: c7 00 0d 00 00 00 movl $0xd,(%eax)
10a9dc: 83 c4 10 add $0x10,%esp
10a9df: e9 cb 00 00 00 jmp 10aaaf <unmount+0x126>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
10a9e4: 83 ec 0c sub $0xc,%esp
10a9e7: 57 push %edi
10a9e8: e8 47 d6 ff ff call 108034 <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 )
10a9ed: 83 c4 10 add $0x10,%esp
10a9f0: a1 0c 51 12 00 mov 0x12510c,%eax
10a9f5: 39 70 14 cmp %esi,0x14(%eax)
10a9f8: 74 25 je 10aa1f <unmount+0x96>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
10a9fa: 51 push %ecx
10a9fb: 51 push %ecx
10a9fc: ff 76 2c pushl 0x2c(%esi)
10a9ff: 68 78 a9 10 00 push $0x10a978
10aa04: e8 44 dd ff ff call 10874d <rtems_filesystem_mount_iterate>
10aa09: 83 c4 10 add $0x10,%esp
10aa0c: 84 c0 test %al,%al
10aa0e: 75 0f jne 10aa1f <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 )
10aa10: 83 ec 0c sub $0xc,%esp
10aa13: 56 push %esi
10aa14: e8 03 d9 ff ff call 10831c <rtems_libio_is_open_files_in_fs>
10aa19: 83 c4 10 add $0x10,%esp
10aa1c: 48 dec %eax
10aa1d: 75 10 jne 10aa2f <unmount+0xa6>
rtems_set_errno_and_return_minus_one( EBUSY );
10aa1f: e8 9c 76 00 00 call 1120c0 <__errno>
10aa24: c7 00 10 00 00 00 movl $0x10,(%eax)
10aa2a: e9 80 00 00 00 jmp 10aaaf <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 )
10aa2f: 83 ec 0c sub $0xc,%esp
10aa32: 8b 46 14 mov 0x14(%esi),%eax
10aa35: 56 push %esi
10aa36: ff 50 28 call *0x28(%eax)
10aa39: 83 c4 10 add $0x10,%esp
return -1;
10aa3c: 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 )
10aa3f: 85 c0 test %eax,%eax
10aa41: 75 6f jne 10aab2 <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){
10aa43: 83 ec 0c sub $0xc,%esp
10aa46: 8b 46 28 mov 0x28(%esi),%eax
10aa49: 56 push %esi
10aa4a: ff 50 2c call *0x2c(%eax)
10aa4d: 83 c4 10 add $0x10,%esp
10aa50: 85 c0 test %eax,%eax
10aa52: 74 1d je 10aa71 <unmount+0xe8> <== ALWAYS TAKEN
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
10aa54: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa57: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED
10aa5a: 56 push %esi <== NOT EXECUTED
10aa5b: ff 50 20 call *0x20(%eax) <== NOT EXECUTED
10aa5e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
return -1;
10aa61: 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 )
10aa63: 85 c0 test %eax,%eax <== NOT EXECUTED
10aa65: 74 4b je 10aab2 <unmount+0x129> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
10aa67: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa6a: 6a 00 push $0x0 <== NOT EXECUTED
10aa6c: e8 93 0e 00 00 call 10b904 <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 );
10aa71: 52 push %edx
10aa72: 6a 00 push $0x0
10aa74: 6a 00 push $0x0
10aa76: ff 35 48 73 12 00 pushl 0x127348
10aa7c: e8 fb 08 00 00 call 10b37c <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10aa81: 89 34 24 mov %esi,(%esp)
10aa84: e8 4b 11 00 00 call 10bbd4 <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10aa89: 58 pop %eax
10aa8a: ff 35 48 73 12 00 pushl 0x127348
10aa90: e8 d3 09 00 00 call 10b468 <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;
10aa95: 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 );
10aa98: 89 04 24 mov %eax,(%esp)
10aa9b: e8 94 d5 ff ff call 108034 <rtems_filesystem_freenode>
free( mt_entry );
10aaa0: 89 34 24 mov %esi,(%esp)
10aaa3: e8 a0 d5 ff ff call 108048 <free>
return 0;
10aaa8: 83 c4 10 add $0x10,%esp
10aaab: 31 d2 xor %edx,%edx
10aaad: eb 03 jmp 10aab2 <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;
10aaaf: 83 ca ff or $0xffffffff,%edx
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
10aab2: 89 d0 mov %edx,%eax
10aab4: 8d 65 f4 lea -0xc(%ebp),%esp
10aab7: 5b pop %ebx
10aab8: 5e pop %esi
10aab9: 5f pop %edi
10aaba: c9 leave
10aabb: c3 ret
0011d2fc <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
11d2fc: 55 push %ebp
11d2fd: 89 e5 mov %esp,%ebp
11d2ff: 56 push %esi
11d300: 53 push %ebx
11d301: 8b 5d 08 mov 0x8(%ebp),%ebx
11d304: 8b 55 0c mov 0xc(%ebp),%edx
11d307: 8b 4d 10 mov 0x10(%ebp),%ecx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11d30a: 3b 1d 44 11 12 00 cmp 0x121144,%ebx
11d310: 73 14 jae 11d326 <write+0x2a>
iop = rtems_libio_iop( fd );
11d312: 6b db 38 imul $0x38,%ebx,%ebx
11d315: 03 1d f8 51 12 00 add 0x1251f8,%ebx
rtems_libio_check_is_open( iop );
11d31b: 8b 73 14 mov 0x14(%ebx),%esi
11d31e: f7 c6 00 01 00 00 test $0x100,%esi
11d324: 75 0d jne 11d333 <write+0x37>
11d326: e8 0d 3e ff ff call 111138 <__errno>
11d32b: c7 00 09 00 00 00 movl $0x9,(%eax)
11d331: eb 1a jmp 11d34d <write+0x51>
rtems_libio_check_buffer( buffer );
11d333: 85 d2 test %edx,%edx
11d335: 74 0b je 11d342 <write+0x46> <== NEVER TAKEN
rtems_libio_check_count( count );
11d337: 31 c0 xor %eax,%eax
11d339: 85 c9 test %ecx,%ecx
11d33b: 74 31 je 11d36e <write+0x72>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
11d33d: 83 e6 04 and $0x4,%esi
11d340: 75 10 jne 11d352 <write+0x56>
11d342: e8 f1 3d ff ff call 111138 <__errno>
11d347: c7 00 16 00 00 00 movl $0x16,(%eax)
11d34d: 83 c8 ff or $0xffffffff,%eax
11d350: eb 1c jmp 11d36e <write+0x72>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
11d352: 50 push %eax
11d353: 8b 43 20 mov 0x20(%ebx),%eax
11d356: 51 push %ecx
11d357: 52 push %edx
11d358: 53 push %ebx
11d359: ff 50 0c call *0xc(%eax)
if ( rc > 0 )
11d35c: 83 c4 10 add $0x10,%esp
11d35f: 85 c0 test %eax,%eax
11d361: 7e 0b jle 11d36e <write+0x72>
iop->offset += rc;
11d363: 89 c1 mov %eax,%ecx
11d365: c1 f9 1f sar $0x1f,%ecx
11d368: 01 43 0c add %eax,0xc(%ebx)
11d36b: 11 4b 10 adc %ecx,0x10(%ebx)
return rc;
}
11d36e: 8d 65 f8 lea -0x8(%ebp),%esp
11d371: 5b pop %ebx
11d372: 5e pop %esi
11d373: c9 leave
11d374: c3 ret
0010a990 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
10a990: 55 push %ebp
10a991: 89 e5 mov %esp,%ebp
10a993: 57 push %edi
10a994: 56 push %esi
10a995: 53 push %ebx
10a996: 83 ec 1c sub $0x1c,%esp
10a999: 8b 75 08 mov 0x8(%ebp),%esi
10a99c: 8b 7d 0c mov 0xc(%ebp),%edi
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
10a99f: 3b 35 44 21 12 00 cmp 0x122144,%esi
10a9a5: 73 11 jae 10a9b8 <writev+0x28>
iop = rtems_libio_iop( fd );
10a9a7: 6b f6 38 imul $0x38,%esi,%esi
10a9aa: 03 35 f8 61 12 00 add 0x1261f8,%esi
rtems_libio_check_is_open( iop );
10a9b0: 8b 46 14 mov 0x14(%esi),%eax
10a9b3: f6 c4 01 test $0x1,%ah
10a9b6: 75 10 jne 10a9c8 <writev+0x38>
10a9b8: e8 4b 73 00 00 call 111d08 <__errno>
10a9bd: c7 00 09 00 00 00 movl $0x9,(%eax)
10a9c3: e9 ad 00 00 00 jmp 10aa75 <writev+0xe5>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10a9c8: a8 04 test $0x4,%al
10a9ca: 74 42 je 10aa0e <writev+0x7e> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
10a9cc: 85 ff test %edi,%edi
10a9ce: 74 3e je 10aa0e <writev+0x7e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
10a9d0: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a9d4: 7e 38 jle 10aa0e <writev+0x7e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
10a9d6: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp)
10a9dd: 7f 2f jg 10aa0e <writev+0x7e> <== NEVER TAKEN
10a9df: b2 01 mov $0x1,%dl
10a9e1: 31 c0 xor %eax,%eax
10a9e3: 31 c9 xor %ecx,%ecx
10a9e5: eb 02 jmp 10a9e9 <writev+0x59>
if ( iov[v].iov_len )
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
10a9e7: 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 )
10a9e9: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8)
10a9ed: 74 1f je 10aa0e <writev+0x7e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
10a9ef: 83 7c c7 04 00 cmpl $0x0,0x4(%edi,%eax,8)
10a9f4: 0f 94 c3 sete %bl
10a9f7: f7 db neg %ebx
10a9f9: 21 da and %ebx,%edx
/* check for wrap */
old = total;
total += iov[v].iov_len;
10a9fb: 8b 5c c7 04 mov 0x4(%edi,%eax,8),%ebx
10a9ff: 8d 1c 19 lea (%ecx,%ebx,1),%ebx
if ( total < old || total > SSIZE_MAX )
10aa02: 81 fb ff 7f 00 00 cmp $0x7fff,%ebx
10aa08: 7f 04 jg 10aa0e <writev+0x7e> <== NEVER TAKEN
10aa0a: 39 cb cmp %ecx,%ebx
10aa0c: 7d 0d jge 10aa1b <writev+0x8b>
rtems_set_errno_and_return_minus_one( EINVAL );
10aa0e: e8 f5 72 00 00 call 111d08 <__errno>
10aa13: c7 00 16 00 00 00 movl $0x16,(%eax)
10aa19: eb 5a jmp 10aa75 <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++ ) {
10aa1b: 40 inc %eax
10aa1c: 3b 45 10 cmp 0x10(%ebp),%eax
10aa1f: 7c c6 jl 10a9e7 <writev+0x57>
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
return 0;
10aa21: 31 db xor %ebx,%ebx
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
10aa23: 84 d2 test %dl,%dl
10aa25: 75 51 jne 10aa78 <writev+0xe8>
10aa27: 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 )
10aa2e: 8b 55 e4 mov -0x1c(%ebp),%edx
10aa31: 8b 44 d7 04 mov 0x4(%edi,%edx,8),%eax
10aa35: 85 c0 test %eax,%eax
10aa37: 74 2f je 10aa68 <writev+0xd8> <== NEVER TAKEN
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
10aa39: 52 push %edx
10aa3a: 8b 56 20 mov 0x20(%esi),%edx
10aa3d: 50 push %eax
10aa3e: 8b 45 e4 mov -0x1c(%ebp),%eax
10aa41: ff 34 c7 pushl (%edi,%eax,8)
10aa44: 56 push %esi
10aa45: ff 52 0c call *0xc(%edx)
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
10aa48: 83 c4 10 add $0x10,%esp
10aa4b: 83 f8 00 cmp $0x0,%eax
10aa4e: 7c 25 jl 10aa75 <writev+0xe5> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
10aa50: 74 0d je 10aa5f <writev+0xcf> <== NEVER TAKEN
iop->offset += bytes;
10aa52: 89 c1 mov %eax,%ecx
10aa54: c1 f9 1f sar $0x1f,%ecx
10aa57: 01 46 0c add %eax,0xc(%esi)
10aa5a: 11 4e 10 adc %ecx,0x10(%esi)
total += bytes;
10aa5d: 01 c3 add %eax,%ebx
}
if (bytes != iov[ v ].iov_len)
10aa5f: 8b 55 e4 mov -0x1c(%ebp),%edx
10aa62: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax
10aa66: 75 10 jne 10aa78 <writev+0xe8> <== NEVER TAKEN
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
10aa68: ff 45 e4 incl -0x1c(%ebp)
10aa6b: 8b 45 10 mov 0x10(%ebp),%eax
10aa6e: 39 45 e4 cmp %eax,-0x1c(%ebp)
10aa71: 7c bb jl 10aa2e <writev+0x9e>
10aa73: eb 03 jmp 10aa78 <writev+0xe8>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
10aa75: 83 cb ff or $0xffffffff,%ebx
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
10aa78: 89 d8 mov %ebx,%eax
10aa7a: 8d 65 f4 lea -0xc(%ebp),%esp
10aa7d: 5b pop %ebx
10aa7e: 5e pop %esi
10aa7f: 5f pop %edi
10aa80: c9 leave
10aa81: c3 ret