RTEMS 4.11Annotated Report
Mon Nov 1 14:21:40 2010
0010d5b8 <IMFS_Set_handlers>:
#define MAXSYMLINK 5
int IMFS_Set_handlers(
rtems_filesystem_location_info_t *loc
)
{
10d5b8: 55 push %ebp
10d5b9: 89 e5 mov %esp,%ebp
10d5bb: 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;
10d5be: 8b 50 10 mov 0x10(%eax),%edx
10d5c1: 8b 52 34 mov 0x34(%edx),%edx
switch( node->type ) {
10d5c4: 8b 08 mov (%eax),%ecx
10d5c6: 8b 49 4c mov 0x4c(%ecx),%ecx
10d5c9: 49 dec %ecx
10d5ca: 83 f9 06 cmp $0x6,%ecx
10d5cd: 77 29 ja 10d5f8 <IMFS_Set_handlers+0x40><== NEVER TAKEN
10d5cf: ff 24 8d 3c ea 11 00 jmp *0x11ea3c(,%ecx,4)
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
10d5d6: 8b 52 0c mov 0xc(%edx),%edx
10d5d9: eb 1a jmp 10d5f5 <IMFS_Set_handlers+0x3d>
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
10d5db: c7 40 08 60 ea 11 00 movl $0x11ea60,0x8(%eax)
break;
10d5e2: eb 14 jmp 10d5f8 <IMFS_Set_handlers+0x40>
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
10d5e4: c7 40 08 d0 ea 11 00 movl $0x11ead0,0x8(%eax)
break;
10d5eb: eb 0b jmp 10d5f8 <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;
10d5ed: 8b 52 08 mov 0x8(%edx),%edx
10d5f0: eb 03 jmp 10d5f5 <IMFS_Set_handlers+0x3d>
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
10d5f2: 8b 52 10 mov 0x10(%edx),%edx
10d5f5: 89 50 08 mov %edx,0x8(%eax)
break;
}
return 0;
}
10d5f8: 31 c0 xor %eax,%eax
10d5fa: c9 leave
10d5fb: c3 ret
0010d46b <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
10d46b: 55 push %ebp
10d46c: 89 e5 mov %esp,%ebp
10d46e: 57 push %edi
10d46f: 56 push %esi
10d470: 53 push %ebx
10d471: 83 ec 1c sub $0x1c,%esp
10d474: 8b 4d 08 mov 0x8(%ebp),%ecx
10d477: 8b 5d 0c mov 0xc(%ebp),%ebx
10d47a: 8b 75 18 mov 0x18(%ebp),%esi
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
return NULL;
10d47d: 31 c0 xor %eax,%eax
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
10d47f: 85 c9 test %ecx,%ecx
10d481: 0f 84 f4 00 00 00 je 10d57b <IMFS_create_node+0x110><== NEVER TAKEN
return NULL;
parent = parent_loc->node_access;
10d487: 8b 11 mov (%ecx),%edx
fs_info = parent_loc->mt_entry->fs_info;
10d489: 8b 49 10 mov 0x10(%ecx),%ecx
10d48c: 8b 79 34 mov 0x34(%ecx),%edi
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
10d48f: 83 fb 07 cmp $0x7,%ebx
10d492: 75 0d jne 10d4a1 <IMFS_create_node+0x36>
10d494: 81 7f 10 d4 e9 11 00 cmpl $0x11e9d4,0x10(%edi)
10d49b: 0f 84 da 00 00 00 je 10d57b <IMFS_create_node+0x110>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
10d4a1: 50 push %eax
10d4a2: a1 50 20 12 00 mov 0x122050,%eax
10d4a7: 8b 40 2c mov 0x2c(%eax),%eax
10d4aa: f7 d0 not %eax
10d4ac: 23 45 14 and 0x14(%ebp),%eax
10d4af: 50 push %eax
10d4b0: ff 75 10 pushl 0x10(%ebp)
10d4b3: 53 push %ebx
10d4b4: 89 55 e4 mov %edx,-0x1c(%ebp)
10d4b7: e8 40 ff ff ff call 10d3fc <IMFS_allocate_node>
if ( !node )
10d4bc: 83 c4 10 add $0x10,%esp
10d4bf: 85 c0 test %eax,%eax
10d4c1: 8b 55 e4 mov -0x1c(%ebp),%edx
10d4c4: 0f 84 b1 00 00 00 je 10d57b <IMFS_create_node+0x110>
return NULL;
/*
* Set the type specific information
*/
if ( type == IMFS_DIRECTORY ) {
10d4ca: 83 fb 01 cmp $0x1,%ebx
10d4cd: 75 15 jne 10d4e4 <IMFS_create_node+0x79>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10d4cf: 8d 48 54 lea 0x54(%eax),%ecx
10d4d2: 89 48 50 mov %ecx,0x50(%eax)
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
10d4d5: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
rtems_chain_initialize_empty(&node->info.directory.Entries);
10d4dc: 8d 48 50 lea 0x50(%eax),%ecx
10d4df: 89 48 58 mov %ecx,0x58(%eax)
10d4e2: eb 75 jmp 10d559 <IMFS_create_node+0xee>
} else if ( type == IMFS_HARD_LINK ) {
10d4e4: 83 fb 03 cmp $0x3,%ebx
10d4e7: 74 05 je 10d4ee <IMFS_create_node+0x83>
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
10d4e9: 83 fb 04 cmp $0x4,%ebx
10d4ec: 75 07 jne 10d4f5 <IMFS_create_node+0x8a>
node->info.sym_link.name = info->sym_link.name;
10d4ee: 8b 0e mov (%esi),%ecx
10d4f0: 89 48 50 mov %ecx,0x50(%eax)
10d4f3: eb 64 jmp 10d559 <IMFS_create_node+0xee>
} else if ( type == IMFS_DEVICE ) {
10d4f5: 83 fb 02 cmp $0x2,%ebx
10d4f8: 75 0d jne 10d507 <IMFS_create_node+0x9c>
node->info.device.major = info->device.major;
10d4fa: 8b 0e mov (%esi),%ecx
10d4fc: 89 48 50 mov %ecx,0x50(%eax)
node->info.device.minor = info->device.minor;
10d4ff: 8b 4e 04 mov 0x4(%esi),%ecx
10d502: 89 48 54 mov %ecx,0x54(%eax)
10d505: eb 52 jmp 10d559 <IMFS_create_node+0xee>
} else if ( type == IMFS_LINEAR_FILE ) {
10d507: 83 fb 06 cmp $0x6,%ebx
10d50a: 75 17 jne 10d523 <IMFS_create_node+0xb8>
node->info.linearfile.size = 0;
10d50c: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10d513: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.linearfile.direct = 0;
10d51a: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
10d521: eb 36 jmp 10d559 <IMFS_create_node+0xee>
} else if ( type == IMFS_MEMORY_FILE ) {
10d523: 83 fb 05 cmp $0x5,%ebx
10d526: 75 25 jne 10d54d <IMFS_create_node+0xe2>
node->info.file.size = 0;
10d528: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10d52f: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.file.indirect = 0;
10d536: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
node->info.file.doubly_indirect = 0;
10d53d: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
node->info.file.triply_indirect = 0;
10d544: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
10d54b: eb 0c jmp 10d559 <IMFS_create_node+0xee>
} else if ( type == IMFS_FIFO ) {
10d54d: 83 fb 07 cmp $0x7,%ebx
10d550: 75 07 jne 10d559 <IMFS_create_node+0xee> <== NEVER TAKEN
node->info.fifo.pipe = NULL;
10d552: 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;
10d559: 89 50 08 mov %edx,0x8(%eax)
node->st_ino = ++fs_info->ino_count;
10d55c: 8b 4f 04 mov 0x4(%edi),%ecx
10d55f: 41 inc %ecx
10d560: 89 4f 04 mov %ecx,0x4(%edi)
10d563: 89 48 38 mov %ecx,0x38(%eax)
10d566: 53 push %ebx
10d567: 53 push %ebx
10d568: 50 push %eax
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
10d569: 83 c2 50 add $0x50,%edx
10d56c: 52 push %edx
10d56d: 89 45 e4 mov %eax,-0x1c(%ebp)
10d570: e8 5b d4 ff ff call 10a9d0 <_Chain_Append>
return node;
10d575: 83 c4 10 add $0x10,%esp
10d578: 8b 45 e4 mov -0x1c(%ebp),%eax
}
10d57b: 8d 65 f4 lea -0xc(%ebp),%esp
10d57e: 5b pop %ebx
10d57f: 5e pop %esi
10d580: 5f pop %edi
10d581: c9 leave
10d582: c3 ret
0010d699 <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
10d699: 55 push %ebp
10d69a: 89 e5 mov %esp,%ebp
10d69c: 57 push %edi
10d69d: 56 push %esi
10d69e: 53 push %ebx
10d69f: 83 ec 5c sub $0x5c,%esp
10d6a2: 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 ) ) {
10d6a5: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp)
10d6ac: 74 0d je 10d6bb <IMFS_eval_path+0x22> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
10d6ae: e8 f9 39 00 00 call 1110ac <__errno> <== NOT EXECUTED
10d6b3: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
10d6b9: eb 42 jmp 10d6fd <IMFS_eval_path+0x64> <== NOT EXECUTED
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10d6bb: 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;
10d6bd: 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;
10d6c2: 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) ) {
10d6c9: e9 29 01 00 00 jmp 10d7f7 <IMFS_eval_path+0x15e>
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
10d6ce: 8d 45 e4 lea -0x1c(%ebp),%eax
10d6d1: 50 push %eax
10d6d2: 8d 4d af lea -0x51(%ebp),%ecx
10d6d5: 51 push %ecx
10d6d6: ff 75 0c pushl 0xc(%ebp)
10d6d9: 8b 45 08 mov 0x8(%ebp),%eax
10d6dc: 03 45 a4 add -0x5c(%ebp),%eax
10d6df: 50 push %eax
10d6e0: e8 b3 05 00 00 call 10dc98 <IMFS_get_token>
10d6e5: 89 c6 mov %eax,%esi
pathnamelen -= len;
10d6e7: 8b 55 e4 mov -0x1c(%ebp),%edx
i += len;
if ( !pathloc->node_access )
10d6ea: 83 c4 10 add $0x10,%esp
10d6ed: 83 3b 00 cmpl $0x0,(%ebx)
10d6f0: 75 13 jne 10d705 <IMFS_eval_path+0x6c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOENT );
10d6f2: e8 b5 39 00 00 call 1110ac <__errno>
10d6f7: c7 00 02 00 00 00 movl $0x2,(%eax)
10d6fd: 83 cf ff or $0xffffffff,%edi
10d700: e9 75 01 00 00 jmp 10d87a <IMFS_eval_path+0x1e1>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10d705: 85 c0 test %eax,%eax
10d707: 74 21 je 10d72a <IMFS_eval_path+0x91>
if ( node->type == IMFS_DIRECTORY )
10d709: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10d70d: 75 1b jne 10d72a <IMFS_eval_path+0x91>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10d70f: 57 push %edi
10d710: 57 push %edi
10d711: 6a 01 push $0x1
10d713: 53 push %ebx
10d714: 89 55 a0 mov %edx,-0x60(%ebp)
10d717: e8 e0 fe ff ff call 10d5fc <IMFS_evaluate_permission>
10d71c: 83 c4 10 add $0x10,%esp
10d71f: 85 c0 test %eax,%eax
10d721: 8b 55 a0 mov -0x60(%ebp),%edx
10d724: 0f 84 3e 01 00 00 je 10d868 <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;
10d72a: 29 55 0c sub %edx,0xc(%ebp)
i += len;
10d72d: 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;
10d730: 8b 3b mov (%ebx),%edi
switch( type ) {
10d732: 83 fe 03 cmp $0x3,%esi
10d735: 74 38 je 10d76f <IMFS_eval_path+0xd6>
10d737: 83 fe 04 cmp $0x4,%esi
10d73a: 0f 84 a7 00 00 00 je 10d7e7 <IMFS_eval_path+0x14e>
10d740: 83 fe 02 cmp $0x2,%esi
10d743: 0f 85 ae 00 00 00 jne 10d7f7 <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 )
10d749: a1 50 20 12 00 mov 0x122050,%eax
10d74e: 3b 78 18 cmp 0x18(%eax),%edi
10d751: 0f 84 a0 00 00 00 je 10d7f7 <IMFS_eval_path+0x15e>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access) {
10d757: 8b 43 10 mov 0x10(%ebx),%eax
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
10d75a: 3b 78 1c cmp 0x1c(%eax),%edi
10d75d: 75 0b jne 10d76a <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;
10d75f: 8d 7d d0 lea -0x30(%ebp),%edi
10d762: 8d 70 08 lea 0x8(%eax),%esi
10d765: e9 ad 00 00 00 jmp 10d817 <IMFS_eval_path+0x17e>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
10d76a: 8b 7f 08 mov 0x8(%edi),%edi
10d76d: eb 6c jmp 10d7db <IMFS_eval_path+0x142>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
10d76f: 8b 47 4c mov 0x4c(%edi),%eax
10d772: 83 f8 03 cmp $0x3,%eax
10d775: 75 11 jne 10d788 <IMFS_eval_path+0xef>
IMFS_evaluate_hard_link( pathloc, 0 );
10d777: 51 push %ecx
10d778: 51 push %ecx
10d779: 6a 00 push $0x0
10d77b: 53 push %ebx
10d77c: e8 d9 fe ff ff call 10d65a <IMFS_evaluate_hard_link>
node = pathloc->node_access;
10d781: 8b 3b mov (%ebx),%edi
10d783: 83 c4 10 add $0x10,%esp
10d786: eb 1d jmp 10d7a5 <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 ) {
10d788: 83 f8 04 cmp $0x4,%eax
10d78b: 75 18 jne 10d7a5 <IMFS_eval_path+0x10c>
result = IMFS_evaluate_sym_link( pathloc, 0 );
10d78d: 52 push %edx
10d78e: 52 push %edx
10d78f: 6a 00 push $0x0
10d791: 53 push %ebx
10d792: e8 ed 00 00 00 call 10d884 <IMFS_evaluate_sym_link>
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
10d797: 8b 3b mov (%ebx),%edi
if ( result == -1 )
10d799: 83 c4 10 add $0x10,%esp
10d79c: 83 f8 ff cmp $0xffffffff,%eax
10d79f: 0f 84 d3 00 00 00 je 10d878 <IMFS_eval_path+0x1df> <== NEVER TAKEN
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10d7a5: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10d7a9: 74 10 je 10d7bb <IMFS_eval_path+0x122>
rtems_set_errno_and_return_minus_one( ENOTDIR );
10d7ab: e8 fc 38 00 00 call 1110ac <__errno>
10d7b0: c7 00 14 00 00 00 movl $0x14,(%eax)
10d7b6: e9 42 ff ff ff jmp 10d6fd <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 ) {
10d7bb: 8b 47 5c mov 0x5c(%edi),%eax
10d7be: 85 c0 test %eax,%eax
10d7c0: 74 08 je 10d7ca <IMFS_eval_path+0x131>
newloc = node->info.directory.mt_fs->mt_fs_root;
10d7c2: 8d 7d d0 lea -0x30(%ebp),%edi
10d7c5: 8d 70 1c lea 0x1c(%eax),%esi
10d7c8: eb 4d jmp 10d817 <IMFS_eval_path+0x17e>
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10d7ca: 50 push %eax
10d7cb: 50 push %eax
10d7cc: 8d 45 af lea -0x51(%ebp),%eax
10d7cf: 50 push %eax
10d7d0: 57 push %edi
10d7d1: e8 56 04 00 00 call 10dc2c <IMFS_find_match_in_dir>
10d7d6: 89 c7 mov %eax,%edi
if ( !node )
10d7d8: 83 c4 10 add $0x10,%esp
10d7db: 85 ff test %edi,%edi
10d7dd: 0f 84 0f ff ff ff je 10d6f2 <IMFS_eval_path+0x59>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
10d7e3: 89 3b mov %edi,(%ebx)
10d7e5: eb 10 jmp 10d7f7 <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 );
10d7e7: e8 c0 38 00 00 call 1110ac <__errno>
10d7ec: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10d7f2: e9 06 ff ff ff jmp 10d6fd <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) ) {
10d7f7: 83 fe 04 cmp $0x4,%esi
10d7fa: 74 08 je 10d804 <IMFS_eval_path+0x16b> <== NEVER TAKEN
10d7fc: 85 f6 test %esi,%esi
10d7fe: 0f 85 ca fe ff ff jne 10d6ce <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 ) {
10d804: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10d808: 75 41 jne 10d84b <IMFS_eval_path+0x1b2>
if ( node->info.directory.mt_fs != NULL ) {
10d80a: 8b 77 5c mov 0x5c(%edi),%esi
10d80d: 85 f6 test %esi,%esi
10d80f: 74 3a je 10d84b <IMFS_eval_path+0x1b2>
newloc = node->info.directory.mt_fs->mt_fs_root;
10d811: 8d 7d d0 lea -0x30(%ebp),%edi
10d814: 83 c6 1c add $0x1c,%esi
10d817: b9 05 00 00 00 mov $0x5,%ecx
10d81c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10d81e: 8d 75 d0 lea -0x30(%ebp),%esi
10d821: b1 05 mov $0x5,%cl
10d823: 89 df mov %ebx,%edi
10d825: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
10d827: 8b 45 e4 mov -0x1c(%ebp),%eax
10d82a: 8b 53 0c mov 0xc(%ebx),%edx
10d82d: 53 push %ebx
10d82e: ff 75 10 pushl 0x10(%ebp)
10d831: 8b 4d 0c mov 0xc(%ebp),%ecx
10d834: 01 c1 add %eax,%ecx
10d836: 51 push %ecx
10d837: 8b 4d a4 mov -0x5c(%ebp),%ecx
10d83a: 29 c1 sub %eax,%ecx
10d83c: 8b 45 08 mov 0x8(%ebp),%eax
10d83f: 01 c8 add %ecx,%eax
10d841: 50 push %eax
10d842: ff 12 call *(%edx)
10d844: 89 c7 mov %eax,%edi
10d846: 83 c4 10 add $0x10,%esp
10d849: eb 2f jmp 10d87a <IMFS_eval_path+0x1e1>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
10d84b: 83 ec 0c sub $0xc,%esp
10d84e: 53 push %ebx
10d84f: e8 64 fd ff ff call 10d5b8 <IMFS_Set_handlers>
10d854: 89 c7 mov %eax,%edi
10d856: 5a pop %edx
10d857: 59 pop %ecx
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
10d858: ff 75 10 pushl 0x10(%ebp)
10d85b: 53 push %ebx
10d85c: e8 9b fd ff ff call 10d5fc <IMFS_evaluate_permission>
10d861: 83 c4 10 add $0x10,%esp
10d864: 85 c0 test %eax,%eax
10d866: 75 12 jne 10d87a <IMFS_eval_path+0x1e1>
rtems_set_errno_and_return_minus_one( EACCES );
10d868: e8 3f 38 00 00 call 1110ac <__errno>
10d86d: c7 00 0d 00 00 00 movl $0xd,(%eax)
10d873: e9 85 fe ff ff jmp 10d6fd <IMFS_eval_path+0x64>
10d878: 89 c7 mov %eax,%edi <== NOT EXECUTED
return result;
}
10d87a: 89 f8 mov %edi,%eax
10d87c: 8d 65 f4 lea -0xc(%ebp),%esp
10d87f: 5b pop %ebx
10d880: 5e pop %esi
10d881: 5f pop %edi
10d882: c9 leave
10d883: c3 ret
0010d978 <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 */
)
{
10d978: 55 push %ebp
10d979: 89 e5 mov %esp,%ebp
10d97b: 57 push %edi
10d97c: 56 push %esi
10d97d: 53 push %ebx
10d97e: 83 ec 5c sub $0x5c,%esp
10d981: 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;
10d984: 8b 1a mov (%edx),%ebx
/*
* Get the path length.
*/
pathlen = strlen( path );
10d986: 31 c0 xor %eax,%eax
10d988: 83 c9 ff or $0xffffffff,%ecx
10d98b: 8b 7d 08 mov 0x8(%ebp),%edi
10d98e: f2 ae repnz scas %es:(%edi),%al
10d990: f7 d1 not %ecx
10d992: 49 dec %ecx
10d993: 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;
10d996: 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 );
10d99d: 8d 7d af lea -0x51(%ebp),%edi
10d9a0: 89 d6 mov %edx,%esi
10d9a2: 8d 45 e4 lea -0x1c(%ebp),%eax
10d9a5: 50 push %eax
10d9a6: 57 push %edi
10d9a7: ff 75 a0 pushl -0x60(%ebp)
10d9aa: 8b 45 08 mov 0x8(%ebp),%eax
10d9ad: 03 45 a4 add -0x5c(%ebp),%eax
10d9b0: 50 push %eax
10d9b1: e8 e2 02 00 00 call 10dc98 <IMFS_get_token>
10d9b6: 89 c2 mov %eax,%edx
pathlen -= len;
10d9b8: 8b 4d e4 mov -0x1c(%ebp),%ecx
10d9bb: 29 4d a0 sub %ecx,-0x60(%ebp)
i += len;
if ( !pathloc->node_access )
10d9be: 83 c4 10 add $0x10,%esp
10d9c1: 83 3e 00 cmpl $0x0,(%esi)
10d9c4: 0f 84 79 01 00 00 je 10db43 <IMFS_evaluate_for_make+0x1cb><== NEVER TAKEN
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10d9ca: 85 c0 test %eax,%eax
10d9cc: 74 36 je 10da04 <IMFS_evaluate_for_make+0x8c>
if ( node->type == IMFS_DIRECTORY )
10d9ce: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10d9d2: 75 30 jne 10da04 <IMFS_evaluate_for_make+0x8c>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10d9d4: 53 push %ebx
10d9d5: 53 push %ebx
10d9d6: 6a 01 push $0x1
10d9d8: 56 push %esi
10d9d9: 89 45 9c mov %eax,-0x64(%ebp)
10d9dc: 89 4d 98 mov %ecx,-0x68(%ebp)
10d9df: e8 18 fc ff ff call 10d5fc <IMFS_evaluate_permission>
10d9e4: 83 c4 10 add $0x10,%esp
10d9e7: 85 c0 test %eax,%eax
10d9e9: 8b 55 9c mov -0x64(%ebp),%edx
10d9ec: 8b 4d 98 mov -0x68(%ebp),%ecx
10d9ef: 75 13 jne 10da04 <IMFS_evaluate_for_make+0x8c>
rtems_set_errno_and_return_minus_one( EACCES );
10d9f1: e8 b6 36 00 00 call 1110ac <__errno>
10d9f6: c7 00 0d 00 00 00 movl $0xd,(%eax)
10d9fc: 83 cb ff or $0xffffffff,%ebx
10d9ff: e9 99 01 00 00 jmp 10db9d <IMFS_evaluate_for_make+0x225>
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
10da04: 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;
10da07: 8b 1e mov (%esi),%ebx
switch( type ) {
10da09: 83 fa 02 cmp $0x2,%edx
10da0c: 74 1f je 10da2d <IMFS_evaluate_for_make+0xb5>
10da0e: 77 0a ja 10da1a <IMFS_evaluate_for_make+0xa2>
10da10: 85 d2 test %edx,%edx
10da12: 0f 84 d9 00 00 00 je 10daf1 <IMFS_evaluate_for_make+0x179>
10da18: eb 88 jmp 10d9a2 <IMFS_evaluate_for_make+0x2a>
10da1a: 83 fa 03 cmp $0x3,%edx
10da1d: 74 40 je 10da5f <IMFS_evaluate_for_make+0xe7>
10da1f: 83 fa 04 cmp $0x4,%edx
10da22: 0f 85 7a ff ff ff jne 10d9a2 <IMFS_evaluate_for_make+0x2a><== NEVER TAKEN
10da28: e9 d4 00 00 00 jmp 10db01 <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 )
10da2d: a1 50 20 12 00 mov 0x122050,%eax
10da32: 3b 58 18 cmp 0x18(%eax),%ebx
10da35: 0f 84 67 ff ff ff je 10d9a2 <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){
10da3b: 8b 46 10 mov 0x10(%esi),%eax
10da3e: 3b 58 1c cmp 0x1c(%eax),%ebx
10da41: 75 0c jne 10da4f <IMFS_evaluate_for_make+0xd7>
10da43: 89 f2 mov %esi,%edx
10da45: 89 c6 mov %eax,%esi
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
10da47: 8d 7d d0 lea -0x30(%ebp),%edi
10da4a: 83 c6 08 add $0x8,%esi
10da4d: eb 5a jmp 10daa9 <IMFS_evaluate_for_make+0x131>
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
10da4f: 8b 5b 08 mov 0x8(%ebx),%ebx
10da52: 85 db test %ebx,%ebx
10da54: 0f 85 90 00 00 00 jne 10daea <IMFS_evaluate_for_make+0x172>
10da5a: e9 e4 00 00 00 jmp 10db43 <IMFS_evaluate_for_make+0x1cb>
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
10da5f: 8b 43 4c mov 0x4c(%ebx),%eax
10da62: 83 f8 03 cmp $0x3,%eax
10da65: 74 05 je 10da6c <IMFS_evaluate_for_make+0xf4>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
10da67: 83 f8 04 cmp $0x4,%eax
10da6a: 75 16 jne 10da82 <IMFS_evaluate_for_make+0x10a>
result = IMFS_evaluate_link( pathloc, 0 );
10da6c: 50 push %eax
10da6d: 50 push %eax
10da6e: 6a 00 push $0x0
10da70: 56 push %esi
10da71: e8 7f fe ff ff call 10d8f5 <IMFS_evaluate_link>
if ( result == -1 )
10da76: 83 c4 10 add $0x10,%esp
10da79: 83 f8 ff cmp $0xffffffff,%eax
10da7c: 0f 84 19 01 00 00 je 10db9b <IMFS_evaluate_for_make+0x223><== NEVER TAKEN
return -1;
}
node = pathloc->node_access;
10da82: 8b 06 mov (%esi),%eax
if ( !node )
10da84: 85 c0 test %eax,%eax
10da86: 0f 84 e9 00 00 00 je 10db75 <IMFS_evaluate_for_make+0x1fd><== NEVER TAKEN
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10da8c: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10da90: 0f 85 df 00 00 00 jne 10db75 <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 ) {
10da96: 8b 50 5c mov 0x5c(%eax),%edx
10da99: 85 d2 test %edx,%edx
10da9b: 74 3b je 10dad8 <IMFS_evaluate_for_make+0x160>
10da9d: 89 f0 mov %esi,%eax
10da9f: 89 d6 mov %edx,%esi
10daa1: 89 c2 mov %eax,%edx
newloc = node->info.directory.mt_fs->mt_fs_root;
10daa3: 8d 7d d0 lea -0x30(%ebp),%edi
10daa6: 83 c6 1c add $0x1c,%esi
10daa9: b9 05 00 00 00 mov $0x5,%ecx
10daae: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10dab0: 8d 75 d0 lea -0x30(%ebp),%esi
10dab3: b1 05 mov $0x5,%cl
10dab5: 89 d7 mov %edx,%edi
10dab7: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
10dab9: 56 push %esi
10daba: 8b 42 0c mov 0xc(%edx),%eax
10dabd: ff 75 10 pushl 0x10(%ebp)
10dac0: 52 push %edx
10dac1: 8b 55 a4 mov -0x5c(%ebp),%edx
10dac4: 2b 55 e4 sub -0x1c(%ebp),%edx
10dac7: 03 55 08 add 0x8(%ebp),%edx
10daca: 52 push %edx
10dacb: ff 50 04 call *0x4(%eax)
10dace: 89 c3 mov %eax,%ebx
10dad0: 83 c4 10 add $0x10,%esp
10dad3: e9 c5 00 00 00 jmp 10db9d <IMFS_evaluate_for_make+0x225>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10dad8: 53 push %ebx
10dad9: 53 push %ebx
10dada: 57 push %edi
10dadb: 50 push %eax
10dadc: e8 4b 01 00 00 call 10dc2c <IMFS_find_match_in_dir>
10dae1: 89 c3 mov %eax,%ebx
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
10dae3: 83 c4 10 add $0x10,%esp
10dae6: 85 c0 test %eax,%eax
10dae8: 74 27 je 10db11 <IMFS_evaluate_for_make+0x199>
done = true;
else
pathloc->node_access = node;
10daea: 89 1e mov %ebx,(%esi)
10daec: e9 b1 fe ff ff jmp 10d9a2 <IMFS_evaluate_for_make+0x2a>
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
10daf1: e8 b6 35 00 00 call 1110ac <__errno>
10daf6: c7 00 11 00 00 00 movl $0x11,(%eax)
10dafc: e9 fb fe ff ff jmp 10d9fc <IMFS_evaluate_for_make+0x84>
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
10db01: e8 a6 35 00 00 call 1110ac <__errno>
10db06: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10db0c: e9 eb fe ff ff jmp 10d9fc <IMFS_evaluate_for_make+0x84>
10db11: 89 f2 mov %esi,%edx
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
10db13: 8b 45 a4 mov -0x5c(%ebp),%eax
10db16: 2b 45 e4 sub -0x1c(%ebp),%eax
10db19: 03 45 08 add 0x8(%ebp),%eax
10db1c: 8b 4d 10 mov 0x10(%ebp),%ecx
10db1f: 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(
10db21: 8b 5d 08 mov 0x8(%ebp),%ebx
10db24: 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++) {
10db27: eb 2a jmp 10db53 <IMFS_evaluate_for_make+0x1db>
if ( !IMFS_is_separator( path[ i ] ) )
10db29: 83 ec 0c sub $0xc,%esp
10db2c: 0f be c0 movsbl %al,%eax
10db2f: 50 push %eax
10db30: 89 55 9c mov %edx,-0x64(%ebp)
10db33: e8 c8 a4 ff ff call 108000 <rtems_filesystem_is_separator>
10db38: 43 inc %ebx
10db39: 83 c4 10 add $0x10,%esp
10db3c: 85 c0 test %eax,%eax
10db3e: 8b 55 9c mov -0x64(%ebp),%edx
10db41: 75 10 jne 10db53 <IMFS_evaluate_for_make+0x1db>
rtems_set_errno_and_return_minus_one( ENOENT );
10db43: e8 64 35 00 00 call 1110ac <__errno>
10db48: c7 00 02 00 00 00 movl $0x2,(%eax)
10db4e: e9 a9 fe ff ff jmp 10d9fc <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++) {
10db53: 8a 03 mov (%ebx),%al
10db55: 84 c0 test %al,%al
10db57: 75 d0 jne 10db29 <IMFS_evaluate_for_make+0x1b1>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
10db59: 83 ec 0c sub $0xc,%esp
10db5c: 52 push %edx
10db5d: 89 55 9c mov %edx,-0x64(%ebp)
10db60: e8 53 fa ff ff call 10d5b8 <IMFS_Set_handlers>
10db65: 89 c3 mov %eax,%ebx
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
10db67: 8b 55 9c mov -0x64(%ebp),%edx
10db6a: 8b 02 mov (%edx),%eax
10db6c: 83 c4 10 add $0x10,%esp
10db6f: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10db73: 74 10 je 10db85 <IMFS_evaluate_for_make+0x20d><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
10db75: e8 32 35 00 00 call 1110ac <__errno>
10db7a: c7 00 14 00 00 00 movl $0x14,(%eax)
10db80: e9 77 fe ff ff jmp 10d9fc <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 ) )
10db85: 51 push %ecx
10db86: 51 push %ecx
10db87: 6a 03 push $0x3
10db89: 52 push %edx
10db8a: e8 6d fa ff ff call 10d5fc <IMFS_evaluate_permission>
10db8f: 83 c4 10 add $0x10,%esp
10db92: 85 c0 test %eax,%eax
10db94: 75 07 jne 10db9d <IMFS_evaluate_for_make+0x225>
10db96: e9 56 fe ff ff jmp 10d9f1 <IMFS_evaluate_for_make+0x79>
10db9b: 89 c3 mov %eax,%ebx <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10db9d: 89 d8 mov %ebx,%eax
10db9f: 8d 65 f4 lea -0xc(%ebp),%esp
10dba2: 5b pop %ebx
10dba3: 5e pop %esi
10dba4: 5f pop %edi
10dba5: c9 leave
10dba6: c3 ret
0010d5fc <IMFS_evaluate_permission>:
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
10d5fc: 55 push %ebp
10d5fd: 89 e5 mov %esp,%ebp
10d5ff: 57 push %edi
10d600: 56 push %esi
10d601: 53 push %ebx
10d602: 83 ec 0c sub $0xc,%esp
10d605: 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 ) )
10d608: f7 c6 f8 ff ff ff test $0xfffffff8,%esi
10d60e: 74 10 je 10d620 <IMFS_evaluate_permission+0x24><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
10d610: e8 97 3a 00 00 call 1110ac <__errno> <== NOT EXECUTED
10d615: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10d61b: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10d61e: eb 32 jmp 10d652 <IMFS_evaluate_permission+0x56><== NOT EXECUTED
jnode = node->node_access;
10d620: 8b 45 08 mov 0x8(%ebp),%eax
10d623: 8b 18 mov (%eax),%ebx
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
10d625: e8 2e 0a 00 00 call 10e058 <geteuid>
10d62a: 89 c7 mov %eax,%edi
st_gid = getegid();
10d62c: e8 17 0a 00 00 call 10e048 <getegid>
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
10d631: 66 3b 7b 3c cmp 0x3c(%ebx),%di
10d635: 75 05 jne 10d63c <IMFS_evaluate_permission+0x40>
flags_to_test <<= 6;
10d637: c1 e6 06 shl $0x6,%esi
10d63a: eb 09 jmp 10d645 <IMFS_evaluate_permission+0x49>
else if ( st_gid == jnode->st_gid )
10d63c: 66 3b 43 3e cmp 0x3e(%ebx),%ax
10d640: 75 03 jne 10d645 <IMFS_evaluate_permission+0x49><== NEVER TAKEN
flags_to_test <<= 3;
10d642: 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 )
10d645: 8b 43 30 mov 0x30(%ebx),%eax
10d648: 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 );
10d64a: 39 f0 cmp %esi,%eax
10d64c: 0f 94 c0 sete %al
10d64f: 0f b6 c0 movzbl %al,%eax
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
10d652: 83 c4 0c add $0xc,%esp
10d655: 5b pop %ebx
10d656: 5e pop %esi
10d657: 5f pop %edi
10d658: c9 leave
10d659: c3 ret
00107b78 <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
107b78: 55 push %ebp
107b79: 89 e5 mov %esp,%ebp
107b7b: 53 push %ebx
107b7c: 83 ec 10 sub $0x10,%esp
107b7f: 8b 45 08 mov 0x8(%ebp),%eax
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
107b82: 50 push %eax
107b83: ff 75 14 pushl 0x14(%ebp)
107b86: ff 75 10 pushl 0x10(%ebp)
107b89: ff 75 0c pushl 0xc(%ebp)
107b8c: 8b 40 18 mov 0x18(%eax),%eax
107b8f: ff 70 50 pushl 0x50(%eax)
107b92: e8 a9 85 00 00 call 110140 <pipe_lseek>
107b97: 89 c3 mov %eax,%ebx
107b99: 99 cltd
IMFS_FIFO_RETURN(err);
107b9a: 83 c4 20 add $0x20,%esp
107b9d: 85 d2 test %edx,%edx
107b9f: 79 0e jns 107baf <IMFS_fifo_lseek+0x37> <== NEVER TAKEN
107ba1: e8 42 b3 00 00 call 112ee8 <__errno>
107ba6: f7 db neg %ebx
107ba8: 89 18 mov %ebx,(%eax)
107baa: 83 c8 ff or $0xffffffff,%eax
107bad: 89 c2 mov %eax,%edx
}
107baf: 8b 5d fc mov -0x4(%ebp),%ebx
107bb2: c9 leave
107bb3: c3 ret
00107c14 <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
107c14: 55 push %ebp
107c15: 89 e5 mov %esp,%ebp
107c17: 56 push %esi
107c18: 53 push %ebx
107c19: 83 ec 10 sub $0x10,%esp
107c1c: 8b 45 08 mov 0x8(%ebp),%eax
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
107c1f: 8b 70 18 mov 0x18(%eax),%esi
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
107c22: 50 push %eax
107c23: ff 75 10 pushl 0x10(%ebp)
107c26: ff 75 0c pushl 0xc(%ebp)
107c29: ff 76 50 pushl 0x50(%esi)
107c2c: e8 03 83 00 00 call 10ff34 <pipe_write>
107c31: 89 c3 mov %eax,%ebx
if (err > 0) {
107c33: 83 c4 10 add $0x10,%esp
107c36: 83 f8 00 cmp $0x0,%eax
107c39: 7e 1b jle 107c56 <IMFS_fifo_write+0x42>
IMFS_mtime_ctime_update(jnode);
107c3b: 50 push %eax
107c3c: 50 push %eax
107c3d: 6a 00 push $0x0
107c3f: 8d 45 f0 lea -0x10(%ebp),%eax
107c42: 50 push %eax
107c43: e8 e4 0d 00 00 call 108a2c <gettimeofday>
107c48: 8b 45 f0 mov -0x10(%ebp),%eax
107c4b: 89 46 44 mov %eax,0x44(%esi)
107c4e: 89 46 48 mov %eax,0x48(%esi)
107c51: 83 c4 10 add $0x10,%esp
107c54: eb 0e jmp 107c64 <IMFS_fifo_write+0x50>
}
IMFS_FIFO_RETURN(err);
107c56: 74 0c je 107c64 <IMFS_fifo_write+0x50> <== NEVER TAKEN
107c58: e8 8b b2 00 00 call 112ee8 <__errno>
107c5d: f7 db neg %ebx
107c5f: 89 18 mov %ebx,(%eax)
107c61: 83 cb ff or $0xffffffff,%ebx
}
107c64: 89 d8 mov %ebx,%eax
107c66: 8d 65 f8 lea -0x8(%ebp),%esp
107c69: 5b pop %ebx
107c6a: 5e pop %esi
107c6b: c9 leave
107c6c: c3 ret
0010dc2c <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
10dc2c: 55 push %ebp
10dc2d: 89 e5 mov %esp,%ebp
10dc2f: 57 push %edi
10dc30: 56 push %esi
10dc31: 53 push %ebx
10dc32: 83 ec 14 sub $0x14,%esp
10dc35: 8b 5d 08 mov 0x8(%ebp),%ebx
10dc38: 8b 7d 0c mov 0xc(%ebp),%edi
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
10dc3b: 68 58 ea 11 00 push $0x11ea58
10dc40: 57 push %edi
10dc41: e8 26 41 00 00 call 111d6c <strcmp>
10dc46: 83 c4 10 add $0x10,%esp
10dc49: 85 c0 test %eax,%eax
10dc4b: 74 40 je 10dc8d <IMFS_find_match_in_dir+0x61><== NEVER TAKEN
return directory;
if ( !strcmp( name, dotdotname ) )
10dc4d: 51 push %ecx
10dc4e: 51 push %ecx
10dc4f: 68 5a ea 11 00 push $0x11ea5a
10dc54: 57 push %edi
10dc55: e8 12 41 00 00 call 111d6c <strcmp>
10dc5a: 83 c4 10 add $0x10,%esp
10dc5d: 85 c0 test %eax,%eax
10dc5f: 75 05 jne 10dc66 <IMFS_find_match_in_dir+0x3a><== ALWAYS TAKEN
return directory->Parent;
10dc61: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED
10dc64: eb 27 jmp 10dc8d <IMFS_find_match_in_dir+0x61><== NOT EXECUTED
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
10dc66: 8b 73 50 mov 0x50(%ebx),%esi
10dc69: 83 c3 54 add $0x54,%ebx
10dc6c: eb 15 jmp 10dc83 <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 ) )
10dc6e: 8d 46 0c lea 0xc(%esi),%eax
10dc71: 52 push %edx
10dc72: 52 push %edx
10dc73: 50 push %eax
10dc74: 57 push %edi
10dc75: e8 f2 40 00 00 call 111d6c <strcmp>
10dc7a: 83 c4 10 add $0x10,%esp
10dc7d: 85 c0 test %eax,%eax
10dc7f: 74 0a je 10dc8b <IMFS_find_match_in_dir+0x5f>
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
10dc81: 8b 36 mov (%esi),%esi
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
10dc83: 39 de cmp %ebx,%esi
10dc85: 75 e7 jne 10dc6e <IMFS_find_match_in_dir+0x42>
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
10dc87: 31 db xor %ebx,%ebx
10dc89: eb 02 jmp 10dc8d <IMFS_find_match_in_dir+0x61>
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
10dc8b: 89 f3 mov %esi,%ebx
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
10dc8d: 89 d8 mov %ebx,%eax
10dc8f: 8d 65 f4 lea -0xc(%ebp),%esp
10dc92: 5b pop %ebx
10dc93: 5e pop %esi
10dc94: 5f pop %edi
10dc95: c9 leave
10dc96: c3 ret
0010dba8 <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
)
{
10dba8: 55 push %ebp
10dba9: 89 e5 mov %esp,%ebp
10dbab: 57 push %edi
10dbac: 56 push %esi
10dbad: 53 push %ebx
10dbae: 83 ec 2c sub $0x2c,%esp
10dbb1: 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;
10dbb4: 8b 58 1c mov 0x1c(%eax),%ebx
loc = temp_mt_entry->mt_fs_root;
10dbb7: 8d 7d d4 lea -0x2c(%ebp),%edi
10dbba: 8d 70 1c lea 0x1c(%eax),%esi
10dbbd: b9 05 00 00 00 mov $0x5,%ecx
10dbc2: 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;
10dbc4: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
10dbcb: 8d 75 d4 lea -0x2c(%ebp),%esi
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
10dbce: 8b 7b 08 mov 0x8(%ebx),%edi
loc.node_access = (void *)jnode;
10dbd1: 89 5d d4 mov %ebx,-0x2c(%ebp)
IMFS_Set_handlers( &loc );
10dbd4: 83 ec 0c sub $0xc,%esp
10dbd7: 56 push %esi
10dbd8: e8 db f9 ff ff call 10d5b8 <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
10dbdd: 83 c4 10 add $0x10,%esp
10dbe0: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10dbe4: 75 08 jne 10dbee <IMFS_fsunmount+0x46>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10dbe6: 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 ) ) {
10dbe9: 39 43 50 cmp %eax,0x50(%ebx)
10dbec: 75 13 jne 10dc01 <IMFS_fsunmount+0x59>
result = IMFS_unlink( NULL, &loc );
10dbee: 50 push %eax
10dbef: 50 push %eax
10dbf0: 56 push %esi
10dbf1: 6a 00 push $0x0
10dbf3: e8 ec 92 ff ff call 106ee4 <IMFS_unlink>
if (result != 0)
10dbf8: 83 c4 10 add $0x10,%esp
10dbfb: 85 c0 test %eax,%eax
10dbfd: 75 1d jne 10dc1c <IMFS_fsunmount+0x74> <== NEVER TAKEN
return -1;
jnode = next;
10dbff: 89 fb mov %edi,%ebx
}
if ( jnode != NULL ) {
10dc01: 85 db test %ebx,%ebx
10dc03: 74 1c je 10dc21 <IMFS_fsunmount+0x79>
if ( jnode->type == IMFS_DIRECTORY ) {
10dc05: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10dc09: 75 c3 jne 10dbce <IMFS_fsunmount+0x26> <== NEVER TAKEN
10dc0b: 8d 43 54 lea 0x54(%ebx),%eax
if ( jnode_has_children( jnode ) )
10dc0e: 39 43 50 cmp %eax,0x50(%ebx)
10dc11: 74 bb je 10dbce <IMFS_fsunmount+0x26>
jnode = jnode_get_first_child( jnode );
10dc13: 8b 5b 50 mov 0x50(%ebx),%ebx
}
}
} while (jnode != NULL);
10dc16: 85 db test %ebx,%ebx
10dc18: 75 b4 jne 10dbce <IMFS_fsunmount+0x26> <== ALWAYS TAKEN
10dc1a: eb 05 jmp 10dc21 <IMFS_fsunmount+0x79> <== NOT EXECUTED
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
10dc1c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10dc1f: eb 02 jmp 10dc23 <IMFS_fsunmount+0x7b> <== NOT EXECUTED
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
return 0;
10dc21: 31 c0 xor %eax,%eax
}
10dc23: 8d 65 f4 lea -0xc(%ebp),%esp
10dc26: 5b pop %ebx
10dc27: 5e pop %esi
10dc28: 5f pop %edi
10dc29: c9 leave
10dc2a: c3 ret
0010dc98 <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
10dc98: 55 push %ebp
10dc99: 89 e5 mov %esp,%ebp
10dc9b: 57 push %edi
10dc9c: 56 push %esi
10dc9d: 53 push %ebx
10dc9e: 83 ec 1c sub $0x1c,%esp
10dca1: 8b 7d 08 mov 0x8(%ebp),%edi
10dca4: 8b 75 10 mov 0x10(%ebp),%esi
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
10dca7: 8a 17 mov (%edi),%dl
int pathlen,
char *token,
int *token_len
)
{
register int i = 0;
10dca9: 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) ) {
10dcab: eb 10 jmp 10dcbd <IMFS_get_token+0x25>
token[i] = c;
10dcad: 88 14 1e mov %dl,(%esi,%ebx,1)
if ( i == IMFS_NAME_MAX )
10dcb0: 83 fb 20 cmp $0x20,%ebx
10dcb3: 0f 84 86 00 00 00 je 10dd3f <IMFS_get_token+0xa7>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
10dcb9: 43 inc %ebx
10dcba: 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) ) {
10dcbd: 83 ec 0c sub $0xc,%esp
10dcc0: 0f be c2 movsbl %dl,%eax
10dcc3: 50 push %eax
10dcc4: 88 55 e4 mov %dl,-0x1c(%ebp)
10dcc7: e8 34 a3 ff ff call 108000 <rtems_filesystem_is_separator>
10dccc: 83 c4 10 add $0x10,%esp
10dccf: 85 c0 test %eax,%eax
10dcd1: 8a 55 e4 mov -0x1c(%ebp),%dl
10dcd4: 75 05 jne 10dcdb <IMFS_get_token+0x43>
10dcd6: 3b 5d 0c cmp 0xc(%ebp),%ebx
10dcd9: 7c d2 jl 10dcad <IMFS_get_token+0x15>
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
10dcdb: 85 db test %ebx,%ebx
10dcdd: 75 10 jne 10dcef <IMFS_get_token+0x57>
token[i] = c;
10dcdf: 88 16 mov %dl,(%esi)
if ( (token[i] != '\0') && pathlen ) {
10dce1: 84 d2 test %dl,%dl
10dce3: 74 06 je 10dceb <IMFS_get_token+0x53>
10dce5: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10dce9: 75 16 jne 10dd01 <IMFS_get_token+0x69>
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
10dceb: 31 ff xor %edi,%edi
10dced: eb 1c jmp 10dd0b <IMFS_get_token+0x73>
char *token,
int *token_len
)
{
register int i = 0;
IMFS_token_types type = IMFS_NAME;
10dcef: 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') {
10dcf4: 80 7c 1e ff 00 cmpb $0x0,-0x1(%esi,%ebx,1)
10dcf9: 74 10 je 10dd0b <IMFS_get_token+0x73> <== NEVER TAKEN
token[i] = '\0';
10dcfb: c6 04 1e 00 movb $0x0,(%esi,%ebx,1)
10dcff: eb 0a jmp 10dd0b <IMFS_get_token+0x73>
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
type = IMFS_CURRENT_DIR;
10dd01: bf 01 00 00 00 mov $0x1,%edi
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
10dd06: bb 01 00 00 00 mov $0x1,%ebx
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
10dd0b: 8b 45 14 mov 0x14(%ebp),%eax
10dd0e: 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 ) {
10dd10: 83 ff 03 cmp $0x3,%edi
10dd13: 75 3d jne 10dd52 <IMFS_get_token+0xba>
if ( strcmp( token, "..") == 0 )
10dd15: 52 push %edx
10dd16: 52 push %edx
10dd17: 68 5d ea 11 00 push $0x11ea5d
10dd1c: 56 push %esi
10dd1d: e8 4a 40 00 00 call 111d6c <strcmp>
10dd22: 83 c4 10 add $0x10,%esp
10dd25: 85 c0 test %eax,%eax
10dd27: 74 1d je 10dd46 <IMFS_get_token+0xae>
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
10dd29: 50 push %eax
10dd2a: 50 push %eax
10dd2b: 68 5e ea 11 00 push $0x11ea5e
10dd30: 56 push %esi
10dd31: e8 36 40 00 00 call 111d6c <strcmp>
10dd36: 83 c4 10 add $0x10,%esp
10dd39: 85 c0 test %eax,%eax
10dd3b: 74 10 je 10dd4d <IMFS_get_token+0xb5>
10dd3d: eb 13 jmp 10dd52 <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;
10dd3f: bf 04 00 00 00 mov $0x4,%edi
10dd44: eb 0c jmp 10dd52 <IMFS_get_token+0xba>
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
10dd46: bf 02 00 00 00 mov $0x2,%edi
10dd4b: eb 05 jmp 10dd52 <IMFS_get_token+0xba>
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
10dd4d: bf 01 00 00 00 mov $0x1,%edi
}
return type;
}
10dd52: 89 f8 mov %edi,%eax
10dd54: 8d 65 f4 lea -0xc(%ebp),%esp
10dd57: 5b pop %ebx
10dd58: 5e pop %esi
10dd59: 5f pop %edi
10dd5a: c9 leave
10dd5b: c3 ret
00106b7c <IMFS_initialize_support>:
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
106b7c: 55 push %ebp
106b7d: 89 e5 mov %esp,%ebp
106b7f: 57 push %edi
106b80: 56 push %esi
106b81: 53 push %ebx
106b82: 83 ec 1c sub $0x1c,%esp
106b85: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
106b88: a1 48 01 12 00 mov 0x120148,%eax
106b8d: b9 06 00 00 00 mov $0x6,%ecx
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
106b92: ba 10 00 00 00 mov $0x10,%edx
if (bit_mask == requested_bytes_per_block) {
106b97: 39 c2 cmp %eax,%edx
106b99: 74 0c je 106ba7 <IMFS_initialize_support+0x2b>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
106b9b: 7f 05 jg 106ba2 <IMFS_initialize_support+0x26>
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
106b9d: d1 e2 shl %edx
106b9f: 49 dec %ecx
106ba0: 75 f5 jne 106b97 <IMFS_initialize_support+0x1b><== ALWAYS TAKEN
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
106ba2: b8 80 00 00 00 mov $0x80,%eax
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
106ba7: a3 8c 3e 12 00 mov %eax,0x123e8c
/*
* Create the root node
*
* NOTE: UNIX root is 755 and owned by root/root (0/0).
*/
temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
106bac: e8 d2 69 00 00 call 10d583 <IMFS_create_root_node>
106bb1: 89 c2 mov %eax,%edx
106bb3: 89 43 1c mov %eax,0x1c(%ebx)
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
106bb6: 8b 45 14 mov 0x14(%ebp),%eax
106bb9: 89 43 24 mov %eax,0x24(%ebx)
temp_mt_entry->mt_fs_root.ops = op_table;
106bbc: 8b 45 0c mov 0xc(%ebp),%eax
106bbf: 89 43 28 mov %eax,0x28(%ebx)
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
106bc2: 8d 7b 38 lea 0x38(%ebx),%edi
106bc5: be 0c ea 11 00 mov $0x11ea0c,%esi
106bca: b9 0c 00 00 00 mov $0xc,%ecx
106bcf: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
106bd1: 50 push %eax
106bd2: 50 push %eax
106bd3: 6a 14 push $0x14
106bd5: 6a 01 push $0x1
106bd7: 89 55 e4 mov %edx,-0x1c(%ebp)
106bda: e8 fd 05 00 00 call 1071dc <calloc>
if ( !fs_info ) {
106bdf: 83 c4 10 add $0x10,%esp
106be2: 85 c0 test %eax,%eax
106be4: 8b 55 e4 mov -0x1c(%ebp),%edx
106be7: 75 1c jne 106c05 <IMFS_initialize_support+0x89>
free(temp_mt_entry->mt_fs_root.node_access);
106be9: 83 ec 0c sub $0xc,%esp
106bec: 52 push %edx
106bed: e8 56 07 00 00 call 107348 <free>
rtems_set_errno_and_return_minus_one(ENOMEM);
106bf2: e8 b5 a4 00 00 call 1110ac <__errno>
106bf7: c7 00 0c 00 00 00 movl $0xc,(%eax)
106bfd: 83 c4 10 add $0x10,%esp
106c00: 83 c8 ff or $0xffffffff,%eax
106c03: eb 34 jmp 106c39 <IMFS_initialize_support+0xbd>
}
temp_mt_entry->fs_info = fs_info;
106c05: 89 43 34 mov %eax,0x34(%ebx)
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
106c08: 8b 0d 90 3e 12 00 mov 0x123e90,%ecx
106c0e: 89 08 mov %ecx,(%eax)
106c10: 41 inc %ecx
106c11: 89 0d 90 3e 12 00 mov %ecx,0x123e90
fs_info->ino_count = 1;
106c17: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
fs_info->memfile_handlers = memfile_handlers;
106c1e: 8b 4d 10 mov 0x10(%ebp),%ecx
106c21: 89 48 08 mov %ecx,0x8(%eax)
fs_info->directory_handlers = directory_handlers;
106c24: 8b 4d 14 mov 0x14(%ebp),%ecx
106c27: 89 48 0c mov %ecx,0xc(%eax)
fs_info->fifo_handlers = fifo_handlers;
106c2a: 8b 4d 18 mov 0x18(%ebp),%ecx
106c2d: 89 48 10 mov %ecx,0x10(%eax)
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
106c30: c7 42 38 01 00 00 00 movl $0x1,0x38(%edx)
return 0;
106c37: 31 c0 xor %eax,%eax
}
106c39: 8d 65 f4 lea -0xc(%ebp),%esp
106c3c: 5b pop %ebx
106c3d: 5e pop %esi
106c3e: 5f pop %edi
106c3f: c9 leave
106c40: c3 ret
0011008e <IMFS_memfile_extend>:
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
11008e: 55 push %ebp
11008f: 89 e5 mov %esp,%ebp
110091: 57 push %edi
110092: 56 push %esi
110093: 53 push %ebx
110094: 83 ec 2c sub $0x2c,%esp
110097: 8b 7d 08 mov 0x8(%ebp),%edi
11009a: 8b 5d 0c mov 0xc(%ebp),%ebx
11009d: 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 )
1100a0: a1 8c 3e 12 00 mov 0x123e8c,%eax
1100a5: 89 c1 mov %eax,%ecx
1100a7: c1 e9 02 shr $0x2,%ecx
1100aa: 8d 51 01 lea 0x1(%ecx),%edx
1100ad: 0f af d1 imul %ecx,%edx
1100b0: 42 inc %edx
1100b1: 0f af d1 imul %ecx,%edx
1100b4: 4a dec %edx
1100b5: 0f af d0 imul %eax,%edx
1100b8: 83 fe 00 cmp $0x0,%esi
1100bb: 7c 16 jl 1100d3 <IMFS_memfile_extend+0x45><== NEVER TAKEN
1100bd: 7f 04 jg 1100c3 <IMFS_memfile_extend+0x35><== NEVER TAKEN
1100bf: 39 d3 cmp %edx,%ebx
1100c1: 72 10 jb 1100d3 <IMFS_memfile_extend+0x45>
rtems_set_errno_and_return_minus_one( EINVAL );
1100c3: e8 e4 0f 00 00 call 1110ac <__errno>
1100c8: c7 00 16 00 00 00 movl $0x16,(%eax)
1100ce: e9 92 00 00 00 jmp 110165 <IMFS_memfile_extend+0xd7>
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
1100d3: 8b 57 50 mov 0x50(%edi),%edx
1100d6: 8b 4f 54 mov 0x54(%edi),%ecx
1100d9: 89 55 e0 mov %edx,-0x20(%ebp)
1100dc: 89 4d e4 mov %ecx,-0x1c(%ebp)
1100df: 39 ce cmp %ecx,%esi
1100e1: 0f 8c 8f 00 00 00 jl 110176 <IMFS_memfile_extend+0xe8><== NEVER TAKEN
1100e7: 7f 08 jg 1100f1 <IMFS_memfile_extend+0x63><== NEVER TAKEN
1100e9: 39 d3 cmp %edx,%ebx
1100eb: 0f 86 85 00 00 00 jbe 110176 <IMFS_memfile_extend+0xe8>
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
1100f1: 89 45 d8 mov %eax,-0x28(%ebp)
1100f4: 89 c1 mov %eax,%ecx
1100f6: c1 f9 1f sar $0x1f,%ecx
1100f9: 89 4d dc mov %ecx,-0x24(%ebp)
1100fc: ff 75 dc pushl -0x24(%ebp)
1100ff: ff 75 d8 pushl -0x28(%ebp)
110102: 56 push %esi
110103: 53 push %ebx
110104: e8 57 bf 00 00 call 11c060 <__divdi3>
110109: 83 c4 10 add $0x10,%esp
11010c: 89 45 d4 mov %eax,-0x2c(%ebp)
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
11010f: ff 75 dc pushl -0x24(%ebp)
110112: ff 75 d8 pushl -0x28(%ebp)
110115: ff 75 e4 pushl -0x1c(%ebp)
110118: ff 75 e0 pushl -0x20(%ebp)
11011b: e8 40 bf 00 00 call 11c060 <__divdi3>
110120: 83 c4 10 add $0x10,%esp
110123: 89 45 e0 mov %eax,-0x20(%ebp)
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
110126: 89 c2 mov %eax,%edx
110128: eb 41 jmp 11016b <IMFS_memfile_extend+0xdd>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
11012a: 51 push %ecx
11012b: 51 push %ecx
11012c: 52 push %edx
11012d: 57 push %edi
11012e: 89 55 d0 mov %edx,-0x30(%ebp)
110131: e8 99 fd ff ff call 10fecf <IMFS_memfile_addblock>
110136: 83 c4 10 add $0x10,%esp
110139: 85 c0 test %eax,%eax
11013b: 8b 55 d0 mov -0x30(%ebp),%edx
11013e: 74 2a je 11016a <IMFS_memfile_extend+0xdc>
110140: eb 13 jmp 110155 <IMFS_memfile_extend+0xc7>
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
110142: 50 push %eax
110143: 50 push %eax
110144: 52 push %edx
110145: 57 push %edi
110146: 89 55 d0 mov %edx,-0x30(%ebp)
110149: e8 16 ff ff ff call 110064 <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-- ) {
11014e: 8b 55 d0 mov -0x30(%ebp),%edx
110151: 4a dec %edx
110152: 83 c4 10 add $0x10,%esp
110155: 3b 55 e0 cmp -0x20(%ebp),%edx
110158: 73 e8 jae 110142 <IMFS_memfile_extend+0xb4>
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
11015a: e8 4d 0f 00 00 call 1110ac <__errno>
11015f: c7 00 1c 00 00 00 movl $0x1c,(%eax)
110165: 83 c8 ff or $0xffffffff,%eax
110168: eb 0e jmp 110178 <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++ ) {
11016a: 42 inc %edx
11016b: 3b 55 d4 cmp -0x2c(%ebp),%edx
11016e: 76 ba jbe 11012a <IMFS_memfile_extend+0x9c>
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
110170: 89 5f 50 mov %ebx,0x50(%edi)
110173: 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;
110176: 31 c0 xor %eax,%eax
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
return 0;
}
110178: 8d 65 f4 lea -0xc(%ebp),%esp
11017b: 5b pop %ebx
11017c: 5e pop %esi
11017d: 5f pop %edi
11017e: c9 leave
11017f: c3 ret
0010fbd4 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
10fbd4: 55 push %ebp
10fbd5: 89 e5 mov %esp,%ebp
10fbd7: 57 push %edi
10fbd8: 56 push %esi
10fbd9: 53 push %ebx
10fbda: 83 ec 1c sub $0x1c,%esp
10fbdd: 8b 75 08 mov 0x8(%ebp),%esi
10fbe0: 8b 7d 0c mov 0xc(%ebp),%edi
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
10fbe3: 8b 0d 8c 3e 12 00 mov 0x123e8c,%ecx
10fbe9: c1 e9 02 shr $0x2,%ecx
10fbec: 8d 41 ff lea -0x1(%ecx),%eax
10fbef: 39 c7 cmp %eax,%edi
10fbf1: 77 40 ja 10fc33 <IMFS_memfile_get_block_pointer+0x5f>
p = info->indirect;
10fbf3: 8b 46 58 mov 0x58(%esi),%eax
if ( malloc_it ) {
10fbf6: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10fbfa: 74 25 je 10fc21 <IMFS_memfile_get_block_pointer+0x4d>
if ( !p ) {
10fbfc: 85 c0 test %eax,%eax
10fbfe: 75 12 jne 10fc12 <IMFS_memfile_get_block_pointer+0x3e>
p = memfile_alloc_block();
10fc00: e8 ad ff ff ff call 10fbb2 <memfile_alloc_block>
if ( !p )
return 0;
10fc05: 31 db xor %ebx,%ebx
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
10fc07: 85 c0 test %eax,%eax
10fc09: 0f 84 f7 00 00 00 je 10fd06 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
info->indirect = p;
10fc0f: 89 46 58 mov %eax,0x58(%esi)
}
return &info->indirect[ my_block ];
10fc12: 8d 1c bd 00 00 00 00 lea 0x0(,%edi,4),%ebx
10fc19: 03 5e 58 add 0x58(%esi),%ebx
10fc1c: e9 e5 00 00 00 jmp 10fd06 <IMFS_memfile_get_block_pointer+0x132>
}
if ( !p )
return 0;
10fc21: 31 db xor %ebx,%ebx
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
10fc23: 85 c0 test %eax,%eax
10fc25: 0f 84 db 00 00 00 je 10fd06 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
return &info->indirect[ my_block ];
10fc2b: 8d 1c b8 lea (%eax,%edi,4),%ebx
10fc2e: e9 d3 00 00 00 jmp 10fd06 <IMFS_memfile_get_block_pointer+0x132>
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
10fc33: 8d 41 01 lea 0x1(%ecx),%eax
10fc36: 0f af c1 imul %ecx,%eax
10fc39: 8d 50 ff lea -0x1(%eax),%edx
10fc3c: 39 d7 cmp %edx,%edi
10fc3e: 77 40 ja 10fc80 <IMFS_memfile_get_block_pointer+0xac>
my_block -= FIRST_DOUBLY_INDIRECT;
10fc40: 29 cf sub %ecx,%edi
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
10fc42: 89 f8 mov %edi,%eax
10fc44: 31 d2 xor %edx,%edx
10fc46: f7 f1 div %ecx
10fc48: 89 55 e4 mov %edx,-0x1c(%ebp)
10fc4b: 89 c7 mov %eax,%edi
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
10fc4d: 8b 46 5c mov 0x5c(%esi),%eax
if ( malloc_it ) {
10fc50: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10fc54: 74 1b je 10fc71 <IMFS_memfile_get_block_pointer+0x9d>
if ( !p ) {
10fc56: 85 c0 test %eax,%eax
10fc58: 75 12 jne 10fc6c <IMFS_memfile_get_block_pointer+0x98>
p = memfile_alloc_block();
10fc5a: e8 53 ff ff ff call 10fbb2 <memfile_alloc_block>
if ( !p )
return 0;
10fc5f: 31 db xor %ebx,%ebx
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
10fc61: 85 c0 test %eax,%eax
10fc63: 0f 84 9d 00 00 00 je 10fd06 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
info->doubly_indirect = p;
10fc69: 89 46 5c mov %eax,0x5c(%esi)
}
p1 = (block_p *)p[ doubly ];
10fc6c: 8d 34 b8 lea (%eax,%edi,4),%esi
10fc6f: eb 65 jmp 10fcd6 <IMFS_memfile_get_block_pointer+0x102>
return (block_p *)&p1[ singly ];
}
if ( !p )
return 0;
10fc71: 31 db xor %ebx,%ebx
}
return (block_p *)&p1[ singly ];
}
if ( !p )
10fc73: 85 c0 test %eax,%eax
10fc75: 0f 84 8b 00 00 00 je 10fd06 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p = (block_p *)p[ doubly ];
10fc7b: 8b 04 b8 mov (%eax,%edi,4),%eax
10fc7e: eb 7c jmp 10fcfc <IMFS_memfile_get_block_pointer+0x128>
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
10fc80: 8d 50 01 lea 0x1(%eax),%edx
10fc83: 0f af d1 imul %ecx,%edx
10fc86: 4a dec %edx
}
/*
* This means the requested block number is out of range.
*/
return 0;
10fc87: 31 db xor %ebx,%ebx
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
10fc89: 39 d7 cmp %edx,%edi
10fc8b: 77 79 ja 10fd06 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
my_block -= FIRST_TRIPLY_INDIRECT;
10fc8d: 29 c7 sub %eax,%edi
10fc8f: 89 f8 mov %edi,%eax
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
10fc91: 31 d2 xor %edx,%edx
10fc93: f7 f1 div %ecx
10fc95: 89 55 e4 mov %edx,-0x1c(%ebp)
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
10fc98: 31 d2 xor %edx,%edx
10fc9a: f7 f1 div %ecx
10fc9c: 89 55 e0 mov %edx,-0x20(%ebp)
10fc9f: 89 c7 mov %eax,%edi
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
p = info->triply_indirect;
10fca1: 8b 46 60 mov 0x60(%esi),%eax
if ( malloc_it ) {
10fca4: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10fca8: 74 41 je 10fceb <IMFS_memfile_get_block_pointer+0x117>
if ( !p ) {
10fcaa: 85 c0 test %eax,%eax
10fcac: 75 0c jne 10fcba <IMFS_memfile_get_block_pointer+0xe6>
p = memfile_alloc_block();
10fcae: e8 ff fe ff ff call 10fbb2 <memfile_alloc_block>
if ( !p )
10fcb3: 85 c0 test %eax,%eax
10fcb5: 74 4f je 10fd06 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
info->triply_indirect = p;
10fcb7: 89 46 60 mov %eax,0x60(%esi)
}
p1 = (block_p *) p[ triply ];
10fcba: 8d 34 b8 lea (%eax,%edi,4),%esi
10fcbd: 8b 06 mov (%esi),%eax
if ( !p1 ) {
10fcbf: 85 c0 test %eax,%eax
10fcc1: 75 0d jne 10fcd0 <IMFS_memfile_get_block_pointer+0xfc>
p1 = memfile_alloc_block();
10fcc3: e8 ea fe ff ff call 10fbb2 <memfile_alloc_block>
if ( !p1 )
return 0;
10fcc8: 31 db xor %ebx,%ebx
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
10fcca: 85 c0 test %eax,%eax
10fccc: 74 38 je 10fd06 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p[ triply ] = (block_p) p1;
10fcce: 89 06 mov %eax,(%esi)
}
p2 = (block_p *)p1[ doubly ];
10fcd0: 8b 55 e0 mov -0x20(%ebp),%edx
10fcd3: 8d 34 90 lea (%eax,%edx,4),%esi
10fcd6: 8b 06 mov (%esi),%eax
if ( !p2 ) {
10fcd8: 85 c0 test %eax,%eax
10fcda: 75 24 jne 10fd00 <IMFS_memfile_get_block_pointer+0x12c>
p2 = memfile_alloc_block();
10fcdc: e8 d1 fe ff ff call 10fbb2 <memfile_alloc_block>
if ( !p2 )
return 0;
10fce1: 31 db xor %ebx,%ebx
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
if ( !p2 )
10fce3: 85 c0 test %eax,%eax
10fce5: 74 1f je 10fd06 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p1[ doubly ] = (block_p) p2;
10fce7: 89 06 mov %eax,(%esi)
10fce9: eb 15 jmp 10fd00 <IMFS_memfile_get_block_pointer+0x12c>
}
return (block_p *)&p2[ singly ];
}
if ( !p )
10fceb: 85 c0 test %eax,%eax
10fced: 74 17 je 10fd06 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p1 = (block_p *) p[ triply ];
10fcef: 8b 04 b8 mov (%eax,%edi,4),%eax
if ( !p1 )
10fcf2: 85 c0 test %eax,%eax
10fcf4: 74 10 je 10fd06 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p2 = (block_p *)p1[ doubly ];
10fcf6: 8b 55 e0 mov -0x20(%ebp),%edx
10fcf9: 8b 04 90 mov (%eax,%edx,4),%eax
if ( !p2 )
10fcfc: 85 c0 test %eax,%eax
10fcfe: 74 06 je 10fd06 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
return (block_p *)&p2[ singly ];
10fd00: 8b 55 e4 mov -0x1c(%ebp),%edx
10fd03: 8d 1c 90 lea (%eax,%edx,4),%ebx
/*
* This means the requested block number is out of range.
*/
return 0;
}
10fd06: 89 d8 mov %ebx,%eax
10fd08: 83 c4 1c add $0x1c,%esp
10fd0b: 5b pop %ebx
10fd0c: 5e pop %esi
10fd0d: 5f pop %edi
10fd0e: c9 leave
10fd0f: c3 ret
0010fd10 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
10fd10: 55 push %ebp
10fd11: 89 e5 mov %esp,%ebp
10fd13: 57 push %edi
10fd14: 56 push %esi
10fd15: 53 push %ebx
10fd16: 83 ec 4c sub $0x4c,%esp
10fd19: 8b 75 0c mov 0xc(%ebp),%esi
10fd1c: 8b 7d 10 mov 0x10(%ebp),%edi
10fd1f: 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) {
10fd22: 8b 45 08 mov 0x8(%ebp),%eax
10fd25: 83 78 4c 06 cmpl $0x6,0x4c(%eax)
10fd29: 75 3f jne 10fd6a <IMFS_memfile_read+0x5a>
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
10fd2b: 8b 48 58 mov 0x58(%eax),%ecx
if (my_length > (the_jnode->info.linearfile.size - start))
10fd2e: 89 c2 mov %eax,%edx
10fd30: 8b 40 50 mov 0x50(%eax),%eax
10fd33: 8b 52 54 mov 0x54(%edx),%edx
10fd36: 89 45 b0 mov %eax,-0x50(%ebp)
10fd39: 89 55 b4 mov %edx,-0x4c(%ebp)
10fd3c: 29 f0 sub %esi,%eax
10fd3e: 19 fa sbb %edi,%edx
10fd40: 89 45 d0 mov %eax,-0x30(%ebp)
10fd43: 89 55 d4 mov %edx,-0x2c(%ebp)
10fd46: 31 c0 xor %eax,%eax
10fd48: 39 d0 cmp %edx,%eax
10fd4a: 7c 0e jl 10fd5a <IMFS_memfile_read+0x4a><== NEVER TAKEN
10fd4c: 7f 05 jg 10fd53 <IMFS_memfile_read+0x43><== NEVER TAKEN
10fd4e: 3b 5d d0 cmp -0x30(%ebp),%ebx
10fd51: 76 07 jbe 10fd5a <IMFS_memfile_read+0x4a><== NEVER TAKEN
my_length = the_jnode->info.linearfile.size - start;
10fd53: 8b 55 b0 mov -0x50(%ebp),%edx
10fd56: 29 f2 sub %esi,%edx
10fd58: eb 02 jmp 10fd5c <IMFS_memfile_read+0x4c>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
10fd5a: 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);
10fd5c: 01 ce add %ecx,%esi
10fd5e: 8b 7d 14 mov 0x14(%ebp),%edi
10fd61: 89 d1 mov %edx,%ecx
10fd63: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10fd65: e9 1d 01 00 00 jmp 10fe87 <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;
10fd6a: 89 f0 mov %esi,%eax
if ( last_byte > the_jnode->info.file.size )
10fd6c: 8b 55 08 mov 0x8(%ebp),%edx
10fd6f: 8b 52 50 mov 0x50(%edx),%edx
10fd72: 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;
10fd75: 8d 0c 33 lea (%ebx,%esi,1),%ecx
10fd78: 89 4d d0 mov %ecx,-0x30(%ebp)
if ( last_byte > the_jnode->info.file.size )
10fd7b: 31 c9 xor %ecx,%ecx
10fd7d: 8b 55 08 mov 0x8(%ebp),%edx
10fd80: 3b 4a 54 cmp 0x54(%edx),%ecx
10fd83: 7c 14 jl 10fd99 <IMFS_memfile_read+0x89><== NEVER TAKEN
10fd85: 7f 08 jg 10fd8f <IMFS_memfile_read+0x7f><== NEVER TAKEN
10fd87: 8b 4d cc mov -0x34(%ebp),%ecx
10fd8a: 39 4d d0 cmp %ecx,-0x30(%ebp)
10fd8d: 76 0a jbe 10fd99 <IMFS_memfile_read+0x89>
my_length = the_jnode->info.file.size - start;
10fd8f: 8b 55 cc mov -0x34(%ebp),%edx
10fd92: 29 c2 sub %eax,%edx
10fd94: 89 55 d0 mov %edx,-0x30(%ebp)
10fd97: eb 03 jmp 10fd9c <IMFS_memfile_read+0x8c>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
10fd99: 89 5d d0 mov %ebx,-0x30(%ebp)
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
10fd9c: 8b 0d 8c 3e 12 00 mov 0x123e8c,%ecx
10fda2: 89 4d c4 mov %ecx,-0x3c(%ebp)
10fda5: 89 c8 mov %ecx,%eax
10fda7: 99 cltd
10fda8: 89 d3 mov %edx,%ebx
10fdaa: 52 push %edx
10fdab: 51 push %ecx
10fdac: 57 push %edi
10fdad: 56 push %esi
10fdae: 89 4d c0 mov %ecx,-0x40(%ebp)
10fdb1: e8 f6 c3 00 00 call 11c1ac <__moddi3>
10fdb6: 83 c4 10 add $0x10,%esp
10fdb9: 89 45 cc mov %eax,-0x34(%ebp)
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
10fdbc: 8b 4d c0 mov -0x40(%ebp),%ecx
10fdbf: 53 push %ebx
10fdc0: 51 push %ecx
10fdc1: 57 push %edi
10fdc2: 56 push %esi
10fdc3: e8 98 c2 00 00 call 11c060 <__divdi3>
10fdc8: 83 c4 10 add $0x10,%esp
10fdcb: 89 c3 mov %eax,%ebx
if ( start_offset ) {
10fdcd: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
10fdd1: 74 3d je 10fe10 <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 );
10fdd3: 57 push %edi
10fdd4: 6a 00 push $0x0
10fdd6: 50 push %eax
10fdd7: ff 75 08 pushl 0x8(%ebp)
10fdda: e8 f5 fd ff ff call 10fbd4 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
10fddf: 83 c4 10 add $0x10,%esp
return copied;
10fde2: 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 )
10fde4: 85 c0 test %eax,%eax
10fde6: 0f 84 ba 00 00 00 je 10fea6 <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;
10fdec: 8b 4d c4 mov -0x3c(%ebp),%ecx
10fdef: 2b 4d cc sub -0x34(%ebp),%ecx
10fdf2: 8b 55 d0 mov -0x30(%ebp),%edx
10fdf5: 39 ca cmp %ecx,%edx
10fdf7: 76 02 jbe 10fdfb <IMFS_memfile_read+0xeb>
10fdf9: 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 );
10fdfb: 8b 75 cc mov -0x34(%ebp),%esi
10fdfe: 03 30 add (%eax),%esi
dest += to_copy;
10fe00: 8b 7d 14 mov 0x14(%ebp),%edi
10fe03: 89 d1 mov %edx,%ecx
10fe05: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10fe07: 89 7d cc mov %edi,-0x34(%ebp)
block++;
10fe0a: 43 inc %ebx
my_length -= to_copy;
10fe0b: 29 55 d0 sub %edx,-0x30(%ebp)
10fe0e: eb 08 jmp 10fe18 <IMFS_memfile_read+0x108>
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
10fe10: 8b 45 14 mov 0x14(%ebp),%eax
10fe13: 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;
10fe16: 31 d2 xor %edx,%edx
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
10fe18: 8b 0d 8c 3e 12 00 mov 0x123e8c,%ecx
10fe1e: 89 4d c8 mov %ecx,-0x38(%ebp)
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
10fe21: eb 2f jmp 10fe52 <IMFS_memfile_read+0x142>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
10fe23: 56 push %esi
10fe24: 6a 00 push $0x0
10fe26: 53 push %ebx
10fe27: ff 75 08 pushl 0x8(%ebp)
10fe2a: 89 55 c0 mov %edx,-0x40(%ebp)
10fe2d: e8 a2 fd ff ff call 10fbd4 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
10fe32: 83 c4 10 add $0x10,%esp
10fe35: 85 c0 test %eax,%eax
10fe37: 8b 55 c0 mov -0x40(%ebp),%edx
10fe3a: 74 6a je 10fea6 <IMFS_memfile_read+0x196><== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
10fe3c: 8b 30 mov (%eax),%esi
10fe3e: 8b 7d cc mov -0x34(%ebp),%edi
10fe41: 8b 4d c8 mov -0x38(%ebp),%ecx
10fe44: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
dest += to_copy;
10fe46: 89 7d cc mov %edi,-0x34(%ebp)
block++;
10fe49: 43 inc %ebx
my_length -= to_copy;
10fe4a: 8b 7d c8 mov -0x38(%ebp),%edi
10fe4d: 29 7d d0 sub %edi,-0x30(%ebp)
copied += to_copy;
10fe50: 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 ) {
10fe52: 8b 45 d0 mov -0x30(%ebp),%eax
10fe55: 3b 05 8c 3e 12 00 cmp 0x123e8c,%eax
10fe5b: 73 c6 jae 10fe23 <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 ) {
10fe5d: 85 c0 test %eax,%eax
10fe5f: 74 26 je 10fe87 <IMFS_memfile_read+0x177>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
10fe61: 51 push %ecx
10fe62: 6a 00 push $0x0
10fe64: 53 push %ebx
10fe65: ff 75 08 pushl 0x8(%ebp)
10fe68: 89 55 c0 mov %edx,-0x40(%ebp)
10fe6b: e8 64 fd ff ff call 10fbd4 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
10fe70: 83 c4 10 add $0x10,%esp
10fe73: 85 c0 test %eax,%eax
10fe75: 8b 55 c0 mov -0x40(%ebp),%edx
10fe78: 74 2c je 10fea6 <IMFS_memfile_read+0x196><== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
10fe7a: 8b 30 mov (%eax),%esi
10fe7c: 8b 7d cc mov -0x34(%ebp),%edi
10fe7f: 8b 4d d0 mov -0x30(%ebp),%ecx
10fe82: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
copied += my_length;
10fe84: 03 55 d0 add -0x30(%ebp),%edx
}
IMFS_update_atime( the_jnode );
10fe87: 50 push %eax
10fe88: 50 push %eax
10fe89: 6a 00 push $0x0
10fe8b: 8d 45 e0 lea -0x20(%ebp),%eax
10fe8e: 50 push %eax
10fe8f: 89 55 c0 mov %edx,-0x40(%ebp)
10fe92: e8 29 75 ff ff call 1073c0 <gettimeofday>
10fe97: 8b 45 e0 mov -0x20(%ebp),%eax
10fe9a: 8b 4d 08 mov 0x8(%ebp),%ecx
10fe9d: 89 41 40 mov %eax,0x40(%ecx)
return copied;
10fea0: 8b 55 c0 mov -0x40(%ebp),%edx
10fea3: 83 c4 10 add $0x10,%esp
}
10fea6: 89 d0 mov %edx,%eax
10fea8: 8d 65 f4 lea -0xc(%ebp),%esp
10feab: 5b pop %ebx
10feac: 5e pop %esi
10fead: 5f pop %edi
10feae: c9 leave
10feaf: c3 ret
0010ff6e <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
10ff6e: 55 push %ebp
10ff6f: 89 e5 mov %esp,%ebp
10ff71: 57 push %edi
10ff72: 56 push %esi
10ff73: 53 push %ebx
10ff74: 83 ec 1c sub $0x1c,%esp
10ff77: 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;
10ff7a: 8b 35 8c 3e 12 00 mov 0x123e8c,%esi
10ff80: c1 ee 02 shr $0x2,%esi
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
10ff83: 83 7b 58 00 cmpl $0x0,0x58(%ebx)
10ff87: 74 0f je 10ff98 <IMFS_memfile_remove+0x2a>
memfile_free_blocks_in_table( &info->indirect, to_free );
10ff89: 57 push %edi
10ff8a: 57 push %edi
10ff8b: 56 push %esi
10ff8c: 8d 43 58 lea 0x58(%ebx),%eax
10ff8f: 50 push %eax
10ff90: e8 8c ff ff ff call 10ff21 <memfile_free_blocks_in_table>
10ff95: 83 c4 10 add $0x10,%esp
}
if ( info->doubly_indirect ) {
10ff98: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx)
10ff9c: 74 3e je 10ffdc <IMFS_memfile_remove+0x6e>
10ff9e: 31 ff xor %edi,%edi
10ffa0: eb 1f jmp 10ffc1 <IMFS_memfile_remove+0x53>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
10ffa2: 8b 43 5c mov 0x5c(%ebx),%eax
10ffa5: 8d 14 bd 00 00 00 00 lea 0x0(,%edi,4),%edx
10ffac: 83 3c b8 00 cmpl $0x0,(%eax,%edi,4)
10ffb0: 74 0e je 10ffc0 <IMFS_memfile_remove+0x52><== NEVER TAKEN
memfile_free_blocks_in_table(
10ffb2: 51 push %ecx
10ffb3: 51 push %ecx
10ffb4: 56 push %esi
10ffb5: 01 d0 add %edx,%eax
10ffb7: 50 push %eax
10ffb8: e8 64 ff ff ff call 10ff21 <memfile_free_blocks_in_table>
10ffbd: 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++ ) {
10ffc0: 47 inc %edi
10ffc1: a1 8c 3e 12 00 mov 0x123e8c,%eax
10ffc6: c1 e8 02 shr $0x2,%eax
10ffc9: 39 c7 cmp %eax,%edi
10ffcb: 72 d5 jb 10ffa2 <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 );
10ffcd: 57 push %edi
10ffce: 57 push %edi
10ffcf: 56 push %esi
10ffd0: 8d 43 5c lea 0x5c(%ebx),%eax
10ffd3: 50 push %eax
10ffd4: e8 48 ff ff ff call 10ff21 <memfile_free_blocks_in_table>
10ffd9: 83 c4 10 add $0x10,%esp
}
if ( info->triply_indirect ) {
10ffdc: 83 7b 60 00 cmpl $0x0,0x60(%ebx)
10ffe0: 74 78 je 11005a <IMFS_memfile_remove+0xec>
10ffe2: 31 ff xor %edi,%edi
10ffe4: eb 59 jmp 11003f <IMFS_memfile_remove+0xd1>
10ffe6: 8d 04 bd 00 00 00 00 lea 0x0(,%edi,4),%eax
10ffed: 89 45 e4 mov %eax,-0x1c(%ebp)
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
10fff0: 8b 43 60 mov 0x60(%ebx),%eax
10fff3: 8b 04 b8 mov (%eax,%edi,4),%eax
if ( !p ) /* ensure we have a valid pointer */
10fff6: 85 c0 test %eax,%eax
10fff8: 74 51 je 11004b <IMFS_memfile_remove+0xdd><== NEVER TAKEN
10fffa: 31 d2 xor %edx,%edx
10fffc: eb 21 jmp 11001f <IMFS_memfile_remove+0xb1>
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
10fffe: 83 38 00 cmpl $0x0,(%eax)
110001: 74 18 je 11001b <IMFS_memfile_remove+0xad><== NEVER TAKEN
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
110003: 51 push %ecx
110004: 51 push %ecx
110005: 56 push %esi
110006: 50 push %eax
110007: 89 45 dc mov %eax,-0x24(%ebp)
11000a: 89 55 e0 mov %edx,-0x20(%ebp)
11000d: e8 0f ff ff ff call 10ff21 <memfile_free_blocks_in_table>
110012: 83 c4 10 add $0x10,%esp
110015: 8b 55 e0 mov -0x20(%ebp),%edx
110018: 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++ ) {
11001b: 42 inc %edx
11001c: 83 c0 04 add $0x4,%eax
11001f: 8b 0d 8c 3e 12 00 mov 0x123e8c,%ecx
110025: c1 e9 02 shr $0x2,%ecx
110028: 39 ca cmp %ecx,%edx
11002a: 72 d2 jb 10fffe <IMFS_memfile_remove+0x90>
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
11002c: 52 push %edx
11002d: 52 push %edx
11002e: 56 push %esi
11002f: 8b 45 e4 mov -0x1c(%ebp),%eax
110032: 03 43 60 add 0x60(%ebx),%eax
110035: 50 push %eax
110036: e8 e6 fe ff ff call 10ff21 <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++ ) {
11003b: 47 inc %edi
11003c: 83 c4 10 add $0x10,%esp
11003f: a1 8c 3e 12 00 mov 0x123e8c,%eax
110044: c1 e8 02 shr $0x2,%eax
110047: 39 c7 cmp %eax,%edi
110049: 72 9b jb 10ffe6 <IMFS_memfile_remove+0x78>
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
11004b: 50 push %eax
11004c: 50 push %eax
11004d: 56 push %esi
(block_p **)&info->triply_indirect, to_free );
11004e: 83 c3 60 add $0x60,%ebx
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
110051: 53 push %ebx
110052: e8 ca fe ff ff call 10ff21 <memfile_free_blocks_in_table>
110057: 83 c4 10 add $0x10,%esp
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
11005a: 31 c0 xor %eax,%eax
11005c: 8d 65 f4 lea -0xc(%ebp),%esp
11005f: 5b pop %ebx
110060: 5e pop %esi
110061: 5f pop %edi
110062: c9 leave
110063: c3 ret
00110180 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
110180: 55 push %ebp
110181: 89 e5 mov %esp,%ebp
110183: 57 push %edi
110184: 56 push %esi
110185: 53 push %ebx
110186: 83 ec 3c sub $0x3c,%esp
110189: 8b 75 0c mov 0xc(%ebp),%esi
11018c: 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;
11018f: 8b 4d 18 mov 0x18(%ebp),%ecx
110192: 01 f1 add %esi,%ecx
if ( last_byte > the_jnode->info.file.size ) {
110194: 89 c8 mov %ecx,%eax
110196: 31 d2 xor %edx,%edx
110198: 8b 5d 08 mov 0x8(%ebp),%ebx
11019b: 3b 53 54 cmp 0x54(%ebx),%edx
11019e: 7c 2c jl 1101cc <IMFS_memfile_write+0x4c><== NEVER TAKEN
1101a0: 7f 05 jg 1101a7 <IMFS_memfile_write+0x27><== NEVER TAKEN
1101a2: 3b 4b 50 cmp 0x50(%ebx),%ecx
1101a5: 76 25 jbe 1101cc <IMFS_memfile_write+0x4c><== NEVER TAKEN
status = IMFS_memfile_extend( the_jnode, last_byte );
1101a7: 51 push %ecx
1101a8: 52 push %edx
1101a9: 50 push %eax
1101aa: ff 75 08 pushl 0x8(%ebp)
1101ad: e8 dc fe ff ff call 11008e <IMFS_memfile_extend>
if ( status )
1101b2: 83 c4 10 add $0x10,%esp
1101b5: 85 c0 test %eax,%eax
1101b7: 74 13 je 1101cc <IMFS_memfile_write+0x4c>
rtems_set_errno_and_return_minus_one( ENOSPC );
1101b9: e8 ee 0e 00 00 call 1110ac <__errno>
1101be: c7 00 1c 00 00 00 movl $0x1c,(%eax)
1101c4: 83 cb ff or $0xffffffff,%ebx
1101c7: e9 03 01 00 00 jmp 1102cf <IMFS_memfile_write+0x14f>
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
1101cc: a1 8c 3e 12 00 mov 0x123e8c,%eax
1101d1: 89 45 c8 mov %eax,-0x38(%ebp)
1101d4: 99 cltd
1101d5: 89 d3 mov %edx,%ebx
1101d7: 52 push %edx
1101d8: 50 push %eax
1101d9: 57 push %edi
1101da: 56 push %esi
1101db: 89 45 c4 mov %eax,-0x3c(%ebp)
1101de: e8 c9 bf 00 00 call 11c1ac <__moddi3>
1101e3: 83 c4 10 add $0x10,%esp
1101e6: 89 45 cc mov %eax,-0x34(%ebp)
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
1101e9: 8b 4d c4 mov -0x3c(%ebp),%ecx
1101ec: 53 push %ebx
1101ed: 51 push %ecx
1101ee: 57 push %edi
1101ef: 56 push %esi
1101f0: e8 6b be 00 00 call 11c060 <__divdi3>
1101f5: 83 c4 10 add $0x10,%esp
1101f8: 89 45 d0 mov %eax,-0x30(%ebp)
if ( start_offset ) {
1101fb: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
1101ff: 74 44 je 110245 <IMFS_memfile_write+0xc5>
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 );
110201: 52 push %edx
110202: 6a 00 push $0x0
110204: 50 push %eax
110205: ff 75 08 pushl 0x8(%ebp)
110208: e8 c7 f9 ff ff call 10fbd4 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
11020d: 83 c4 10 add $0x10,%esp
return copied;
110210: 31 db xor %ebx,%ebx
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 )
110212: 85 c0 test %eax,%eax
110214: 0f 84 b5 00 00 00 je 1102cf <IMFS_memfile_write+0x14f><== 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;
11021a: 8b 55 c8 mov -0x38(%ebp),%edx
11021d: 2b 55 cc sub -0x34(%ebp),%edx
110220: 3b 55 18 cmp 0x18(%ebp),%edx
110223: 76 03 jbe 110228 <IMFS_memfile_write+0xa8>
110225: 8b 55 18 mov 0x18(%ebp),%edx
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
110228: 8b 00 mov (%eax),%eax
11022a: 03 45 cc add -0x34(%ebp),%eax
src += to_copy;
11022d: 89 c7 mov %eax,%edi
11022f: 8b 75 14 mov 0x14(%ebp),%esi
110232: 89 d1 mov %edx,%ecx
110234: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
110236: ff 45 d0 incl -0x30(%ebp)
my_length -= to_copy;
110239: 8b 5d 18 mov 0x18(%ebp),%ebx
11023c: 29 d3 sub %edx,%ebx
11023e: 89 5d d4 mov %ebx,-0x2c(%ebp)
copied += to_copy;
110241: 89 d3 mov %edx,%ebx
110243: eb 0b jmp 110250 <IMFS_memfile_write+0xd0>
unsigned int last_byte;
unsigned int start_offset;
int copied;
const unsigned char *src;
src = source;
110245: 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 ) {
110248: 8b 45 18 mov 0x18(%ebp),%eax
11024b: 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;
11024e: 31 db xor %ebx,%ebx
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
110250: 8b 15 8c 3e 12 00 mov 0x123e8c,%edx
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
110256: eb 2b jmp 110283 <IMFS_memfile_write+0x103>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
110258: 50 push %eax
110259: 6a 00 push $0x0
11025b: ff 75 d0 pushl -0x30(%ebp)
11025e: ff 75 08 pushl 0x8(%ebp)
110261: 89 55 c4 mov %edx,-0x3c(%ebp)
110264: e8 6b f9 ff ff call 10fbd4 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
110269: 83 c4 10 add $0x10,%esp
11026c: 85 c0 test %eax,%eax
11026e: 8b 55 c4 mov -0x3c(%ebp),%edx
110271: 74 5c je 1102cf <IMFS_memfile_write+0x14f><== 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 );
110273: 8b 00 mov (%eax),%eax
src += to_copy;
110275: 89 c7 mov %eax,%edi
110277: 89 d1 mov %edx,%ecx
110279: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
11027b: ff 45 d0 incl -0x30(%ebp)
my_length -= to_copy;
11027e: 29 55 d4 sub %edx,-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(
110281: 01 d3 add %edx,%ebx
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
110283: 8b 45 d4 mov -0x2c(%ebp),%eax
110286: 3b 05 8c 3e 12 00 cmp 0x123e8c,%eax
11028c: 73 ca jae 110258 <IMFS_memfile_write+0xd8>
* 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 ) {
11028e: 85 c0 test %eax,%eax
110290: 74 21 je 1102b3 <IMFS_memfile_write+0x133>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
110292: 57 push %edi
110293: 6a 00 push $0x0
110295: ff 75 d0 pushl -0x30(%ebp)
110298: ff 75 08 pushl 0x8(%ebp)
11029b: e8 34 f9 ff ff call 10fbd4 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
1102a0: 83 c4 10 add $0x10,%esp
1102a3: 85 c0 test %eax,%eax
1102a5: 74 28 je 1102cf <IMFS_memfile_write+0x14f><== 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 );
1102a7: 8b 00 mov (%eax),%eax
1102a9: 89 c7 mov %eax,%edi
1102ab: 8b 4d d4 mov -0x2c(%ebp),%ecx
1102ae: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
my_length = 0;
copied += to_copy;
1102b0: 03 5d d4 add -0x2c(%ebp),%ebx
}
IMFS_mtime_ctime_update( the_jnode );
1102b3: 56 push %esi
1102b4: 56 push %esi
1102b5: 6a 00 push $0x0
1102b7: 8d 45 e0 lea -0x20(%ebp),%eax
1102ba: 50 push %eax
1102bb: e8 00 71 ff ff call 1073c0 <gettimeofday>
1102c0: 8b 45 e0 mov -0x20(%ebp),%eax
1102c3: 8b 55 08 mov 0x8(%ebp),%edx
1102c6: 89 42 44 mov %eax,0x44(%edx)
1102c9: 89 42 48 mov %eax,0x48(%edx)
return copied;
1102cc: 83 c4 10 add $0x10,%esp
}
1102cf: 89 d8 mov %ebx,%eax
1102d1: 8d 65 f4 lea -0xc(%ebp),%esp
1102d4: 5b pop %ebx
1102d5: 5e pop %esi
1102d6: 5f pop %edi
1102d7: c9 leave
1102d8: c3 ret
00106d90 <IMFS_mount>:
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
106d90: 55 push %ebp
106d91: 89 e5 mov %esp,%ebp
106d93: 83 ec 08 sub $0x8,%esp
106d96: 8b 55 08 mov 0x8(%ebp),%edx
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
106d99: 8b 42 08 mov 0x8(%edx),%eax
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
106d9c: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
106da0: 74 10 je 106db2 <IMFS_mount+0x22> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
106da2: e8 05 a3 00 00 call 1110ac <__errno> <== NOT EXECUTED
106da7: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
106dad: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106db0: eb 05 jmp 106db7 <IMFS_mount+0x27> <== NOT EXECUTED
/*
* Set mt_fs pointer to point to the mount table entry for
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
106db2: 89 50 5c mov %edx,0x5c(%eax)
return 0;
106db5: 31 c0 xor %eax,%eax
}
106db7: c9 leave
106db8: c3 ret
00109538 <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
109538: 55 push %ebp
109539: 89 e5 mov %esp,%ebp
10953b: 53 push %ebx
10953c: 83 ec 0c sub $0xc,%esp
10953f: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
109542: a1 20 81 12 00 mov 0x128120,%eax
109547: ff 70 08 pushl 0x8(%eax)
10954a: 8d 43 0c lea 0xc(%ebx),%eax
10954d: 50 push %eax
10954e: e8 dd bd 00 00 call 115330 <fputs>
switch( the_jnode->type ) {
109553: 8b 43 4c mov 0x4c(%ebx),%eax
109556: 83 c4 10 add $0x10,%esp
109559: 8d 50 ff lea -0x1(%eax),%edx
10955c: 83 fa 06 cmp $0x6,%edx
10955f: 77 75 ja 1095d6 <IMFS_print_jnode+0x9e> <== NEVER TAKEN
109561: a1 20 81 12 00 mov 0x128120,%eax
109566: ff 24 95 90 3f 12 00 jmp *0x123f90(,%edx,4)
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
10956d: 51 push %ecx
10956e: 51 push %ecx
10956f: ff 70 08 pushl 0x8(%eax)
109572: 6a 2f push $0x2f
109574: e8 0b bd 00 00 call 115284 <fputc>
109579: eb 2b jmp 1095a6 <IMFS_print_jnode+0x6e>
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
10957b: ff 73 54 pushl 0x54(%ebx)
10957e: ff 73 50 pushl 0x50(%ebx)
109581: 68 b5 3e 12 00 push $0x123eb5
109586: eb 16 jmp 10959e <IMFS_print_jnode+0x66>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
109588: ff 73 58 pushl 0x58(%ebx)
10958b: ff 73 50 pushl 0x50(%ebx)
10958e: 68 c8 3e 12 00 push $0x123ec8
109593: eb 09 jmp 10959e <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 ")",
109595: 52 push %edx
109596: ff 73 50 pushl 0x50(%ebx)
109599: 68 d7 3e 12 00 push $0x123ed7
10959e: ff 70 08 pushl 0x8(%eax)
1095a1: e8 7e bc 00 00 call 115224 <fprintf>
(uint32_t)the_jnode->info.file.size );
#endif
break;
1095a6: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
1095a9: c7 45 08 c1 41 12 00 movl $0x1241c1,0x8(%ebp)
}
1095b0: 8b 5d fc mov -0x4(%ebp),%ebx
1095b3: c9 leave
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
1095b4: e9 2f d5 00 00 jmp 116ae8 <puts>
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
1095b9: 53 push %ebx
1095ba: 53 push %ebx
1095bb: ff 70 08 pushl 0x8(%eax)
1095be: 68 e3 3e 12 00 push $0x123ee3
1095c3: eb 0a jmp 1095cf <IMFS_print_jnode+0x97>
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
1095c5: 51 push %ecx
1095c6: 51 push %ecx
1095c7: ff 70 08 pushl 0x8(%eax)
1095ca: 68 f7 3e 12 00 push $0x123ef7
1095cf: e8 5c bd 00 00 call 115330 <fputs>
1095d4: eb 14 jmp 1095ea <IMFS_print_jnode+0xb2>
return;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
1095d6: 52 push %edx <== NOT EXECUTED
1095d7: 50 push %eax <== NOT EXECUTED
1095d8: 68 0a 3f 12 00 push $0x123f0a <== NOT EXECUTED
1095dd: a1 20 81 12 00 mov 0x128120,%eax <== NOT EXECUTED
1095e2: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
1095e5: e8 3a bc 00 00 call 115224 <fprintf> <== NOT EXECUTED
return;
1095ea: 83 c4 10 add $0x10,%esp
}
puts("");
}
1095ed: 8b 5d fc mov -0x4(%ebp),%ebx
1095f0: c9 leave
1095f1: c3 ret
00106df8 <IMFS_rename>:
rtems_filesystem_location_info_t *old_parent_loc, /* IN */
rtems_filesystem_location_info_t *old_loc, /* IN */
rtems_filesystem_location_info_t *new_parent_loc, /* IN */
const char *new_name /* IN */
)
{
106df8: 55 push %ebp
106df9: 89 e5 mov %esp,%ebp
106dfb: 53 push %ebx
106dfc: 83 ec 18 sub $0x18,%esp
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
106dff: 8b 45 0c mov 0xc(%ebp),%eax
106e02: 8b 18 mov (%eax),%ebx
strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
106e04: 6a 20 push $0x20
106e06: ff 75 14 pushl 0x14(%ebp)
106e09: 8d 43 0c lea 0xc(%ebx),%eax
106e0c: 50 push %eax
106e0d: e8 6a b1 00 00 call 111f7c <strncpy>
if ( the_jnode->Parent != NULL )
106e12: 83 c4 10 add $0x10,%esp
106e15: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
106e19: 74 0c je 106e27 <IMFS_rename+0x2f> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
106e1b: 83 ec 0c sub $0xc,%esp
106e1e: 53 push %ebx
106e1f: e8 d0 3b 00 00 call 10a9f4 <_Chain_Extract>
106e24: 83 c4 10 add $0x10,%esp
rtems_chain_extract( (rtems_chain_node *) the_jnode );
new_parent = new_parent_loc->node_access;
106e27: 8b 45 10 mov 0x10(%ebp),%eax
106e2a: 8b 00 mov (%eax),%eax
the_jnode->Parent = new_parent;
106e2c: 89 43 08 mov %eax,0x8(%ebx)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
106e2f: 51 push %ecx
106e30: 51 push %ecx
106e31: 53 push %ebx
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
106e32: 83 c0 50 add $0x50,%eax
106e35: 50 push %eax
106e36: e8 95 3b 00 00 call 10a9d0 <_Chain_Append>
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
106e3b: 58 pop %eax
106e3c: 5a pop %edx
106e3d: 6a 00 push $0x0
106e3f: 8d 45 f0 lea -0x10(%ebp),%eax
106e42: 50 push %eax
106e43: e8 78 05 00 00 call 1073c0 <gettimeofday>
106e48: 8b 45 f0 mov -0x10(%ebp),%eax
106e4b: 89 43 48 mov %eax,0x48(%ebx)
return 0;
}
106e4e: 31 c0 xor %eax,%eax
106e50: 8b 5d fc mov -0x4(%ebp),%ebx
106e53: c9 leave
106e54: c3 ret
0010de28 <IMFS_stat>:
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
10de28: 55 push %ebp
10de29: 89 e5 mov %esp,%ebp
10de2b: 56 push %esi
10de2c: 53 push %ebx
10de2d: 8b 4d 08 mov 0x8(%ebp),%ecx
10de30: 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;
10de33: 8b 11 mov (%ecx),%edx
switch ( the_jnode->type ) {
10de35: 8b 5a 4c mov 0x4c(%edx),%ebx
10de38: 83 eb 02 sub $0x2,%ebx
10de3b: 83 fb 05 cmp $0x5,%ebx
10de3e: 77 33 ja 10de73 <IMFS_stat+0x4b> <== NEVER TAKEN
10de40: ff 24 9d 40 eb 11 00 jmp *0x11eb40(,%ebx,4)
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
10de47: 8b 5a 54 mov 0x54(%edx),%ebx
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
10de4a: 8b 72 50 mov 0x50(%edx),%esi
10de4d: 89 70 18 mov %esi,0x18(%eax)
10de50: 89 58 1c mov %ebx,0x1c(%eax)
break;
10de53: eb 2e jmp 10de83 <IMFS_stat+0x5b>
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
10de55: 8b 5a 50 mov 0x50(%edx),%ebx
10de58: 8b 72 54 mov 0x54(%edx),%esi
10de5b: 89 58 20 mov %ebx,0x20(%eax)
10de5e: 89 70 24 mov %esi,0x24(%eax)
break;
10de61: eb 20 jmp 10de83 <IMFS_stat+0x5b>
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
10de63: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
10de6a: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
break;
10de71: eb 10 jmp 10de83 <IMFS_stat+0x5b>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
10de73: e8 34 32 00 00 call 1110ac <__errno>
10de78: c7 00 86 00 00 00 movl $0x86,(%eax)
10de7e: 83 c8 ff or $0xffffffff,%eax
10de81: eb 47 jmp 10deca <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;
10de83: 8b 49 10 mov 0x10(%ecx),%ecx
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
10de86: 8b 49 34 mov 0x34(%ecx),%ecx
10de89: 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 =
10de8b: c7 00 fe ff 00 00 movl $0xfffe,(%eax)
10de91: 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;
10de94: 8b 4a 30 mov 0x30(%edx),%ecx
10de97: 89 48 0c mov %ecx,0xc(%eax)
buf->st_nlink = the_jnode->st_nlink;
10de9a: 8b 4a 34 mov 0x34(%edx),%ecx
10de9d: 66 89 48 10 mov %cx,0x10(%eax)
buf->st_ino = the_jnode->st_ino;
10dea1: 8b 4a 38 mov 0x38(%edx),%ecx
10dea4: 89 48 08 mov %ecx,0x8(%eax)
buf->st_uid = the_jnode->st_uid;
10dea7: 8b 4a 3c mov 0x3c(%edx),%ecx
10deaa: 66 89 48 12 mov %cx,0x12(%eax)
buf->st_gid = the_jnode->st_gid;
10deae: 66 8b 4a 3e mov 0x3e(%edx),%cx
10deb2: 66 89 48 14 mov %cx,0x14(%eax)
buf->st_atime = the_jnode->stat_atime;
10deb6: 8b 4a 40 mov 0x40(%edx),%ecx
10deb9: 89 48 28 mov %ecx,0x28(%eax)
buf->st_mtime = the_jnode->stat_mtime;
10debc: 8b 4a 44 mov 0x44(%edx),%ecx
10debf: 89 48 30 mov %ecx,0x30(%eax)
buf->st_ctime = the_jnode->stat_ctime;
10dec2: 8b 52 48 mov 0x48(%edx),%edx
10dec5: 89 50 38 mov %edx,0x38(%eax)
return 0;
10dec8: 31 c0 xor %eax,%eax
}
10deca: 5b pop %ebx
10decb: 5e pop %esi
10decc: c9 leave
10decd: c3 ret
00106ee4 <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
106ee4: 55 push %ebp
106ee5: 89 e5 mov %esp,%ebp
106ee7: 57 push %edi
106ee8: 56 push %esi
106ee9: 53 push %ebx
106eea: 83 ec 2c sub $0x2c,%esp
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
106eed: 8b 45 0c mov 0xc(%ebp),%eax
106ef0: 8b 18 mov (%eax),%ebx
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
106ef2: 83 7b 4c 03 cmpl $0x3,0x4c(%ebx)
106ef6: 75 7a jne 106f72 <IMFS_unlink+0x8e>
if ( !node->info.hard_link.link_node )
106ef8: 8b 43 50 mov 0x50(%ebx),%eax
106efb: 85 c0 test %eax,%eax
106efd: 75 10 jne 106f0f <IMFS_unlink+0x2b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
106eff: e8 a8 a1 00 00 call 1110ac <__errno> <== NOT EXECUTED
106f04: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
106f0a: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106f0d: eb 75 jmp 106f84 <IMFS_unlink+0xa0> <== NOT EXECUTED
the_link = *loc;
106f0f: 8d 7d cc lea -0x34(%ebp),%edi
106f12: b9 05 00 00 00 mov $0x5,%ecx
106f17: 8b 75 0c mov 0xc(%ebp),%esi
106f1a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_link.node_access = node->info.hard_link.link_node;
106f1c: 89 45 cc mov %eax,-0x34(%ebp)
IMFS_Set_handlers( &the_link );
106f1f: 83 ec 0c sub $0xc,%esp
106f22: 8d 75 cc lea -0x34(%ebp),%esi
106f25: 56 push %esi
106f26: e8 8d 66 00 00 call 10d5b8 <IMFS_Set_handlers>
/*
* If removing the last hard link to a node, then we need
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
106f2b: 8b 43 50 mov 0x50(%ebx),%eax
106f2e: 8b 50 34 mov 0x34(%eax),%edx
106f31: 83 c4 10 add $0x10,%esp
106f34: 66 83 fa 01 cmp $0x1,%dx
106f38: 75 1a jne 106f54 <IMFS_unlink+0x70>
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
106f3a: 51 push %ecx
106f3b: 51 push %ecx
106f3c: 56 push %esi
106f3d: ff 75 08 pushl 0x8(%ebp)
106f40: 8b 45 d4 mov -0x2c(%ebp),%eax
106f43: ff 50 34 call *0x34(%eax)
106f46: 89 c2 mov %eax,%edx
if ( result != 0 )
106f48: 83 c4 10 add $0x10,%esp
return -1;
106f4b: 83 c8 ff or $0xffffffff,%eax
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
if ( result != 0 )
106f4e: 85 d2 test %edx,%edx
106f50: 74 20 je 106f72 <IMFS_unlink+0x8e>
106f52: eb 30 jmp 106f84 <IMFS_unlink+0xa0>
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
106f54: 4a dec %edx
106f55: 66 89 50 34 mov %dx,0x34(%eax)
IMFS_update_ctime( node->info.hard_link.link_node );
106f59: 52 push %edx
106f5a: 52 push %edx
106f5b: 6a 00 push $0x0
106f5d: 8d 45 e0 lea -0x20(%ebp),%eax
106f60: 50 push %eax
106f61: e8 5a 04 00 00 call 1073c0 <gettimeofday>
106f66: 8b 43 50 mov 0x50(%ebx),%eax
106f69: 8b 55 e0 mov -0x20(%ebp),%edx
106f6c: 89 50 48 mov %edx,0x48(%eax)
106f6f: 83 c4 10 add $0x10,%esp
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
106f72: 50 push %eax
106f73: 50 push %eax
106f74: 8b 55 0c mov 0xc(%ebp),%edx
106f77: 8b 42 08 mov 0x8(%edx),%eax
106f7a: 52 push %edx
106f7b: ff 75 08 pushl 0x8(%ebp)
106f7e: ff 50 34 call *0x34(%eax)
return result;
106f81: 83 c4 10 add $0x10,%esp
}
106f84: 8d 65 f4 lea -0xc(%ebp),%esp
106f87: 5b pop %ebx
106f88: 5e pop %esi
106f89: 5f pop %edi
106f8a: c9 leave
106f8b: c3 ret
00106f8c <IMFS_unmount>:
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
106f8c: 55 push %ebp
106f8d: 89 e5 mov %esp,%ebp
106f8f: 83 ec 08 sub $0x8,%esp
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
106f92: 8b 45 08 mov 0x8(%ebp),%eax
106f95: 8b 40 08 mov 0x8(%eax),%eax
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
106f98: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
106f9c: 74 0d je 106fab <IMFS_unmount+0x1f> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
106f9e: e8 09 a1 00 00 call 1110ac <__errno> <== NOT EXECUTED
106fa3: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
106fa9: eb 11 jmp 106fbc <IMFS_unmount+0x30> <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
106fab: 83 78 5c 00 cmpl $0x0,0x5c(%eax)
106faf: 75 10 jne 106fc1 <IMFS_unmount+0x35> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
106fb1: e8 f6 a0 00 00 call 1110ac <__errno> <== NOT EXECUTED
106fb6: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
106fbc: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106fbf: eb 09 jmp 106fca <IMFS_unmount+0x3e> <== NOT EXECUTED
/*
* Set the mt_fs pointer to indicate that there is no longer
* a file system mounted to this point.
*/
node->info.directory.mt_fs = NULL;
106fc1: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
return 0;
106fc8: 31 c0 xor %eax,%eax
}
106fca: c9 leave
106fcb: c3 ret
00107118 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
107118: 55 push %ebp <== NOT EXECUTED
107119: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10711b: 57 push %edi <== NOT EXECUTED
10711c: 56 push %esi <== NOT EXECUTED
10711d: 53 push %ebx <== NOT EXECUTED
10711e: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED
107121: 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) {
107124: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED
107127: 75 1d jne 107146 <Stack_check_Dump_threads_usage+0x2e><== NOT EXECUTED
if (!Stack_check_Interrupt_stack.area)
107129: 83 3d dc 71 12 00 00 cmpl $0x0,0x1271dc <== NOT EXECUTED
107130: 0f 84 f5 00 00 00 je 10722b <Stack_check_Dump_threads_usage+0x113><== NOT EXECUTED
return;
stack = &Stack_check_Interrupt_stack;
107136: ba d8 71 12 00 mov $0x1271d8,%edx <== NOT EXECUTED
the_thread = 0;
current = 0;
10713b: 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;
107142: 31 db xor %ebx,%ebx <== NOT EXECUTED
107144: eb 0f jmp 107155 <Stack_check_Dump_threads_usage+0x3d><== NOT EXECUTED
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
107146: 8d 93 c4 00 00 00 lea 0xc4(%ebx),%edx <== NOT EXECUTED
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
10714c: 8b 83 d8 00 00 00 mov 0xd8(%ebx),%eax <== NOT EXECUTED
107152: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED
}
low = Stack_check_usable_stack_start(stack);
107155: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED
107158: 8d 48 10 lea 0x10(%eax),%ecx <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
10715b: 8b 32 mov (%edx),%esi <== NOT EXECUTED
10715d: 83 ee 10 sub $0x10,%esi <== NOT EXECUTED
107160: 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;
107163: 83 c0 20 add $0x20,%eax <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
107166: 83 e6 fc and $0xfffffffc,%esi <== NOT EXECUTED
107169: 8d 34 30 lea (%eax,%esi,1),%esi <== NOT EXECUTED
10716c: eb 0b jmp 107179 <Stack_check_Dump_threads_usage+0x61><== NOT EXECUTED
if (*base != U32_PATTERN)
10716e: 81 38 a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%eax) <== NOT EXECUTED
107174: 75 0b jne 107181 <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++)
107176: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
107179: 39 f0 cmp %esi,%eax <== NOT EXECUTED
10717b: 72 f1 jb 10716e <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;
10717d: 31 ff xor %edi,%edi <== NOT EXECUTED
10717f: eb 0e jmp 10718f <Stack_check_Dump_threads_usage+0x77><== NOT EXECUTED
107181: 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 )
107183: 85 c0 test %eax,%eax <== NOT EXECUTED
107185: 74 08 je 10718f <Stack_check_Dump_threads_usage+0x77><== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
107187: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED
10718a: 8d 3c 39 lea (%ecx,%edi,1),%edi <== NOT EXECUTED
10718d: 29 c7 sub %eax,%edi <== NOT EXECUTED
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
10718f: 85 db test %ebx,%ebx <== NOT EXECUTED
107191: 8b 35 b4 6e 12 00 mov 0x126eb4,%esi <== NOT EXECUTED
107197: 74 28 je 1071c1 <Stack_check_Dump_threads_usage+0xa9><== NOT EXECUTED
#endif
{
(*print_handler)(
107199: 50 push %eax <== NOT EXECUTED
10719a: 8d 45 e3 lea -0x1d(%ebp),%eax <== NOT EXECUTED
10719d: 50 push %eax <== NOT EXECUTED
10719e: 6a 05 push $0x5 <== NOT EXECUTED
1071a0: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
1071a3: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED
1071a6: e8 89 53 00 00 call 10c534 <rtems_object_get_name> <== NOT EXECUTED
1071ab: 50 push %eax <== NOT EXECUTED
1071ac: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
1071af: 68 ab 0c 12 00 push $0x120cab <== NOT EXECUTED
1071b4: ff 35 b0 6e 12 00 pushl 0x126eb0 <== NOT EXECUTED
1071ba: ff d6 call *%esi <== NOT EXECUTED
1071bc: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
1071bf: eb 16 jmp 1071d7 <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 );
1071c1: 53 push %ebx <== NOT EXECUTED
1071c2: 6a ff push $0xffffffff <== NOT EXECUTED
1071c4: 68 b8 0c 12 00 push $0x120cb8 <== NOT EXECUTED
1071c9: ff 35 b0 6e 12 00 pushl 0x126eb0 <== NOT EXECUTED
1071cf: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED
1071d2: ff d6 call *%esi <== NOT EXECUTED
1071d4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1071d7: 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,
1071da: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
1071dd: 51 push %ecx <== NOT EXECUTED
1071de: 51 push %ecx <== NOT EXECUTED
1071df: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED
1071e2: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
1071e5: 8b 12 mov (%edx),%edx <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
1071e7: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED
1071eb: 52 push %edx <== NOT EXECUTED
1071ec: 50 push %eax <== NOT EXECUTED
1071ed: 68 c6 0c 12 00 push $0x120cc6 <== NOT EXECUTED
1071f2: ff 35 b0 6e 12 00 pushl 0x126eb0 <== NOT EXECUTED
1071f8: ff 15 b4 6e 12 00 call *0x126eb4 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
1071fe: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
107201: 83 3d b8 6e 12 00 00 cmpl $0x0,0x126eb8 <== NOT EXECUTED
107208: 8b 35 b4 6e 12 00 mov 0x126eb4,%esi <== NOT EXECUTED
10720e: 75 09 jne 107219 <Stack_check_Dump_threads_usage+0x101><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
107210: 52 push %edx <== NOT EXECUTED
107211: 52 push %edx <== NOT EXECUTED
107212: 68 e4 0c 12 00 push $0x120ce4 <== NOT EXECUTED
107217: eb 07 jmp 107220 <Stack_check_Dump_threads_usage+0x108><== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
107219: 50 push %eax <== NOT EXECUTED
10721a: 57 push %edi <== NOT EXECUTED
10721b: 68 f1 0c 12 00 push $0x120cf1 <== NOT EXECUTED
107220: ff 35 b0 6e 12 00 pushl 0x126eb0 <== NOT EXECUTED
107226: ff d6 call *%esi <== NOT EXECUTED
107228: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
10722b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10722e: 5b pop %ebx <== NOT EXECUTED
10722f: 5e pop %esi <== NOT EXECUTED
107230: 5f pop %edi <== NOT EXECUTED
107231: c9 leave <== NOT EXECUTED
107232: c3 ret <== NOT EXECUTED
00107233 <Stack_check_Initialize>:
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
{
107233: 55 push %ebp
107234: 89 e5 mov %esp,%ebp
107236: 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 )
107237: 83 3d b8 6e 12 00 00 cmpl $0x0,0x126eb8
10723e: 75 5a jne 10729a <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 ];
107240: c7 05 c8 71 12 00 0d movl $0xfeedf00d,0x1271c8
107247: f0 ed fe
10724a: c7 05 cc 71 12 00 06 movl $0xbad0d06,0x1271cc
107251: 0d ad 0b
107254: c7 05 d0 71 12 00 0d movl $0xdeadf00d,0x1271d0
10725b: f0 ad de
10725e: c7 05 d4 71 12 00 06 movl $0x600d0d06,0x1271d4
107265: 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) {
107268: 8b 15 dc 78 12 00 mov 0x1278dc,%edx
10726e: 85 d2 test %edx,%edx
107270: 74 1e je 107290 <Stack_check_Initialize+0x5d><== NEVER TAKEN
107272: 8b 0d e0 78 12 00 mov 0x1278e0,%ecx
107278: 85 c9 test %ecx,%ecx
10727a: 74 14 je 107290 <Stack_check_Initialize+0x5d><== NEVER TAKEN
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
10727c: 89 15 dc 71 12 00 mov %edx,0x1271dc
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
107282: 29 d1 sub %edx,%ecx
107284: 89 0d d8 71 12 00 mov %ecx,0x1271d8
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
10728a: b0 a5 mov $0xa5,%al
10728c: 89 d7 mov %edx,%edi
10728e: f3 aa rep stos %al,%es:(%edi)
}
#endif
Stack_check_Initialized = 1;
107290: c7 05 b8 6e 12 00 01 movl $0x1,0x126eb8
107297: 00 00 00
}
10729a: 5f pop %edi
10729b: c9 leave
10729c: c3 ret
001072eb <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)
{
1072eb: 55 push %ebp <== NOT EXECUTED
1072ec: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1072ee: 56 push %esi <== NOT EXECUTED
1072ef: 53 push %ebx <== NOT EXECUTED
1072f0: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED
1072f3: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
1072f6: 8a 55 0c mov 0xc(%ebp),%dl <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern_area(stack);
1072f9: 8b b3 c8 00 00 00 mov 0xc8(%ebx),%esi <== NOT EXECUTED
char name [32];
printk("BLOWN STACK!!!\n");
1072ff: 68 f7 0c 12 00 push $0x120cf7 <== NOT EXECUTED
107304: 88 55 d4 mov %dl,-0x2c(%ebp) <== NOT EXECUTED
107307: e8 08 19 00 00 call 108c14 <printk> <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
10730c: 5a pop %edx <== NOT EXECUTED
10730d: 59 pop %ecx <== NOT EXECUTED
10730e: 53 push %ebx <== NOT EXECUTED
10730f: 68 07 0d 12 00 push $0x120d07 <== NOT EXECUTED
107314: e8 fb 18 00 00 call 108c14 <printk> <== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
107319: 59 pop %ecx <== NOT EXECUTED
10731a: 58 pop %eax <== NOT EXECUTED
10731b: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
10731e: 68 24 0d 12 00 push $0x120d24 <== NOT EXECUTED
107323: e8 ec 18 00 00 call 108c14 <printk> <== NOT EXECUTED
printk(
107328: 58 pop %eax <== NOT EXECUTED
107329: 5a pop %edx <== NOT EXECUTED
10732a: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED
10732d: 68 36 0d 12 00 push $0x120d36 <== NOT EXECUTED
107332: e8 dd 18 00 00 call 108c14 <printk> <== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
107337: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10733a: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED
10733d: 50 push %eax <== NOT EXECUTED
10733e: 6a 20 push $0x20 <== NOT EXECUTED
107340: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
107343: e8 ec 51 00 00 call 10c534 <rtems_object_get_name> <== NOT EXECUTED
107348: 5a pop %edx <== NOT EXECUTED
107349: 59 pop %ecx <== NOT EXECUTED
10734a: 50 push %eax <== NOT EXECUTED
10734b: 68 4a 0d 12 00 push $0x120d4a <== NOT EXECUTED
107350: e8 bf 18 00 00 call 108c14 <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)
107355: 8b 8b c8 00 00 00 mov 0xc8(%ebx),%ecx <== NOT EXECUTED
10735b: 8b 83 c4 00 00 00 mov 0xc4(%ebx),%eax <== NOT EXECUTED
);
printk(
"task name string: %s\n",
rtems_object_get_name(running->Object.id, sizeof(name), name)
);
printk(
107361: 8d 1c 01 lea (%ecx,%eax,1),%ebx <== NOT EXECUTED
107364: 53 push %ebx <== NOT EXECUTED
107365: 51 push %ecx <== NOT EXECUTED
107366: 50 push %eax <== NOT EXECUTED
107367: 68 60 0d 12 00 push $0x120d60 <== NOT EXECUTED
10736c: e8 a3 18 00 00 call 108c14 <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) {
107371: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
107374: 8a 55 d4 mov -0x2c(%ebp),%dl <== NOT EXECUTED
107377: 84 d2 test %dl,%dl <== NOT EXECUTED
107379: 75 17 jne 107392 <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_area(stack);
10737b: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
printk(
10737e: 83 c6 18 add $0x18,%esi <== NOT EXECUTED
107381: 56 push %esi <== NOT EXECUTED
107382: 50 push %eax <== NOT EXECUTED
107383: 6a 10 push $0x10 <== NOT EXECUTED
107385: 68 91 0d 12 00 push $0x120d91 <== NOT EXECUTED
10738a: e8 85 18 00 00 call 108c14 <printk> <== NOT EXECUTED
10738f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
107392: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107395: 68 81 00 00 00 push $0x81 <== NOT EXECUTED
10739a: e8 d9 58 00 00 call 10cc78 <rtems_fatal_error_occurred><== NOT EXECUTED
0010cdfc <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
10cdfc: 55 push %ebp
10cdfd: 89 e5 mov %esp,%ebp
10cdff: 53 push %ebx
10ce00: 83 ec 04 sub $0x4,%esp
10ce03: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10ce06: 8b 15 44 88 12 00 mov 0x128844,%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 );
10ce0c: 9c pushf
10ce0d: fa cli
10ce0e: 58 pop %eax
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
10ce0f: 8b 4b 44 mov 0x44(%ebx),%ecx
10ce12: 85 c9 test %ecx,%ecx
10ce14: 75 0b jne 10ce21 <_CORE_RWLock_Release+0x25>
_ISR_Enable( level );
10ce16: 50 push %eax
10ce17: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10ce18: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx)
return CORE_RWLOCK_SUCCESSFUL;
10ce1f: eb 72 jmp 10ce93 <_CORE_RWLock_Release+0x97>
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
10ce21: 49 dec %ecx
10ce22: 75 0f jne 10ce33 <_CORE_RWLock_Release+0x37>
the_rwlock->number_of_readers -= 1;
10ce24: 8b 4b 48 mov 0x48(%ebx),%ecx
10ce27: 49 dec %ecx
10ce28: 89 4b 48 mov %ecx,0x48(%ebx)
if ( the_rwlock->number_of_readers != 0 ) {
10ce2b: 85 c9 test %ecx,%ecx
10ce2d: 74 04 je 10ce33 <_CORE_RWLock_Release+0x37>
/* must be unlocked again */
_ISR_Enable( level );
10ce2f: 50 push %eax
10ce30: 9d popf
return CORE_RWLOCK_SUCCESSFUL;
10ce31: eb 60 jmp 10ce93 <_CORE_RWLock_Release+0x97>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10ce33: 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;
10ce3a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
_ISR_Enable( level );
10ce41: 50 push %eax
10ce42: 9d popf
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
10ce43: 83 ec 0c sub $0xc,%esp
10ce46: 53 push %ebx
10ce47: e8 68 15 00 00 call 10e3b4 <_Thread_queue_Dequeue>
if ( next ) {
10ce4c: 83 c4 10 add $0x10,%esp
10ce4f: 85 c0 test %eax,%eax
10ce51: 74 40 je 10ce93 <_CORE_RWLock_Release+0x97>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
10ce53: 83 78 30 01 cmpl $0x1,0x30(%eax)
10ce57: 75 09 jne 10ce62 <_CORE_RWLock_Release+0x66>
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
10ce59: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx)
return CORE_RWLOCK_SUCCESSFUL;
10ce60: eb 31 jmp 10ce93 <_CORE_RWLock_Release+0x97>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
10ce62: ff 43 48 incl 0x48(%ebx)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10ce65: 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 );
10ce6c: 83 ec 0c sub $0xc,%esp
10ce6f: 53 push %ebx
10ce70: e8 2b 19 00 00 call 10e7a0 <_Thread_queue_First>
if ( !next ||
10ce75: 83 c4 10 add $0x10,%esp
10ce78: 85 c0 test %eax,%eax
10ce7a: 74 17 je 10ce93 <_CORE_RWLock_Release+0x97>
10ce7c: 83 78 30 01 cmpl $0x1,0x30(%eax)
10ce80: 74 11 je 10ce93 <_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;
10ce82: ff 43 48 incl 0x48(%ebx)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
10ce85: 52 push %edx
10ce86: 52 push %edx
10ce87: 50 push %eax
10ce88: 53 push %ebx
10ce89: e8 06 18 00 00 call 10e694 <_Thread_queue_Extract>
}
10ce8e: 83 c4 10 add $0x10,%esp
10ce91: eb d9 jmp 10ce6c <_CORE_RWLock_Release+0x70>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10ce93: 31 c0 xor %eax,%eax
10ce95: 8b 5d fc mov -0x4(%ebp),%ebx
10ce98: c9 leave
10ce99: c3 ret
0010ce9c <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
10ce9c: 55 push %ebp
10ce9d: 89 e5 mov %esp,%ebp
10ce9f: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10cea2: 8d 45 f4 lea -0xc(%ebp),%eax
10cea5: 50 push %eax
10cea6: ff 75 08 pushl 0x8(%ebp)
10cea9: e8 aa 11 00 00 call 10e058 <_Thread_Get>
switch ( location ) {
10ceae: 83 c4 10 add $0x10,%esp
10ceb1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10ceb5: 75 17 jne 10cece <_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 );
10ceb7: 83 ec 0c sub $0xc,%esp
10ceba: 50 push %eax
10cebb: e8 ac 19 00 00 call 10e86c <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10cec0: a1 f4 82 12 00 mov 0x1282f4,%eax
10cec5: 48 dec %eax
10cec6: a3 f4 82 12 00 mov %eax,0x1282f4
10cecb: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10cece: c9 leave
10cecf: c3 ret
00117364 <_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
)
{
117364: 55 push %ebp
117365: 89 e5 mov %esp,%ebp
117367: 57 push %edi
117368: 56 push %esi
117369: 53 push %ebx
11736a: 83 ec 1c sub $0x1c,%esp
11736d: 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;
117370: 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 ) {
117375: 8b 55 10 mov 0x10(%ebp),%edx
117378: 3b 53 4c cmp 0x4c(%ebx),%edx
11737b: 77 4e ja 1173cb <_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 ) {
11737d: 83 7b 48 00 cmpl $0x0,0x48(%ebx)
117381: 75 09 jne 11738c <_CORE_message_queue_Broadcast+0x28>
117383: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
11738a: eb 23 jmp 1173af <_CORE_message_queue_Broadcast+0x4b>
*count = 0;
11738c: 8b 45 1c mov 0x1c(%ebp),%eax
11738f: c7 00 00 00 00 00 movl $0x0,(%eax)
117395: eb 32 jmp 1173c9 <_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;
117397: ff 45 e4 incl -0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
11739a: 8b 42 2c mov 0x2c(%edx),%eax
11739d: 89 c7 mov %eax,%edi
11739f: 8b 75 0c mov 0xc(%ebp),%esi
1173a2: 8b 4d 10 mov 0x10(%ebp),%ecx
1173a5: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
1173a7: 8b 42 28 mov 0x28(%edx),%eax
1173aa: 8b 55 10 mov 0x10(%ebp),%edx
1173ad: 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 =
1173af: 83 ec 0c sub $0xc,%esp
1173b2: 53 push %ebx
1173b3: e8 9c 22 00 00 call 119654 <_Thread_queue_Dequeue>
1173b8: 89 c2 mov %eax,%edx
1173ba: 83 c4 10 add $0x10,%esp
1173bd: 85 c0 test %eax,%eax
1173bf: 75 d6 jne 117397 <_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;
1173c1: 8b 55 e4 mov -0x1c(%ebp),%edx
1173c4: 8b 45 1c mov 0x1c(%ebp),%eax
1173c7: 89 10 mov %edx,(%eax)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
1173c9: 31 c0 xor %eax,%eax
}
1173cb: 8d 65 f4 lea -0xc(%ebp),%esp
1173ce: 5b pop %ebx
1173cf: 5e pop %esi
1173d0: 5f pop %edi
1173d1: c9 leave
1173d2: c3 ret
00112218 <_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
)
{
112218: 55 push %ebp
112219: 89 e5 mov %esp,%ebp
11221b: 57 push %edi
11221c: 56 push %esi
11221d: 53 push %ebx
11221e: 83 ec 1c sub $0x1c,%esp
112221: 8b 5d 08 mov 0x8(%ebp),%ebx
112224: 8b 7d 10 mov 0x10(%ebp),%edi
112227: 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;
11222a: 89 7b 44 mov %edi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
11222d: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
112234: 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;
112237: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
the_message_queue->notify_argument = the_argument;
11223e: 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)) {
112245: 89 d0 mov %edx,%eax
112247: f6 c2 03 test $0x3,%dl
11224a: 74 0c je 112258 <_CORE_message_queue_Initialize+0x40>
allocated_message_size += sizeof(uint32_t);
11224c: 83 c0 04 add $0x4,%eax
allocated_message_size &= ~(sizeof(uint32_t) - 1);
11224f: 83 e0 fc and $0xfffffffc,%eax
}
if (allocated_message_size < maximum_message_size)
return false;
112252: 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)
112254: 39 d0 cmp %edx,%eax
112256: 72 68 jb 1122c0 <_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));
112258: 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 *
11225b: 89 d1 mov %edx,%ecx
11225d: 0f af cf imul %edi,%ecx
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
return false;
112260: 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)
112262: 39 c1 cmp %eax,%ecx
112264: 72 5a jb 1122c0 <_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 );
112266: 83 ec 0c sub $0xc,%esp
112269: 51 push %ecx
11226a: 89 55 e4 mov %edx,-0x1c(%ebp)
11226d: e8 a0 26 00 00 call 114912 <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
112272: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
112275: 83 c4 10 add $0x10,%esp
112278: 85 c0 test %eax,%eax
11227a: 8b 55 e4 mov -0x1c(%ebp),%edx
11227d: 74 41 je 1122c0 <_CORE_message_queue_Initialize+0xa8>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
11227f: 52 push %edx
112280: 57 push %edi
112281: 50 push %eax
112282: 8d 43 68 lea 0x68(%ebx),%eax
112285: 50 push %eax
112286: e8 e1 49 00 00 call 116c6c <_Chain_Initialize>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
11228b: 8d 43 54 lea 0x54(%ebx),%eax
11228e: 89 43 50 mov %eax,0x50(%ebx)
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
112291: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
the_message_queue->message_buffers,
(size_t) maximum_pending_messages,
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
112298: 8d 43 50 lea 0x50(%ebx),%eax
11229b: 89 43 58 mov %eax,0x58(%ebx)
_Thread_queue_Initialize(
11229e: 6a 06 push $0x6
1122a0: 68 80 00 00 00 push $0x80
1122a5: 8b 45 0c mov 0xc(%ebp),%eax
1122a8: 83 38 01 cmpl $0x1,(%eax)
1122ab: 0f 94 c0 sete %al
1122ae: 0f b6 c0 movzbl %al,%eax
1122b1: 50 push %eax
1122b2: 53 push %ebx
1122b3: e8 04 1d 00 00 call 113fbc <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
1122b8: 83 c4 20 add $0x20,%esp
1122bb: be 01 00 00 00 mov $0x1,%esi
}
1122c0: 89 f0 mov %esi,%eax
1122c2: 8d 65 f4 lea -0xc(%ebp),%esp
1122c5: 5b pop %ebx
1122c6: 5e pop %esi
1122c7: 5f pop %edi
1122c8: c9 leave
1122c9: c3 ret
001122cc <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
1122cc: 55 push %ebp
1122cd: 89 e5 mov %esp,%ebp
1122cf: 57 push %edi
1122d0: 56 push %esi
1122d1: 53 push %ebx
1122d2: 83 ec 2c sub $0x2c,%esp
1122d5: 8b 55 08 mov 0x8(%ebp),%edx
1122d8: 8b 45 0c mov 0xc(%ebp),%eax
1122db: 89 45 dc mov %eax,-0x24(%ebp)
1122de: 8b 5d 10 mov 0x10(%ebp),%ebx
1122e1: 89 5d e0 mov %ebx,-0x20(%ebp)
1122e4: 8b 4d 14 mov 0x14(%ebp),%ecx
1122e7: 8b 75 1c mov 0x1c(%ebp),%esi
1122ea: 89 75 d4 mov %esi,-0x2c(%ebp)
1122ed: 8a 45 18 mov 0x18(%ebp),%al
1122f0: 88 45 db mov %al,-0x25(%ebp)
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
1122f3: a1 9c c9 12 00 mov 0x12c99c,%eax
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
1122f8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_ISR_Disable( level );
1122ff: 9c pushf
112300: fa cli
112301: 8f 45 e4 popl -0x1c(%ebp)
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
112304: 8b 5a 50 mov 0x50(%edx),%ebx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
112307: 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))
11230a: 39 f3 cmp %esi,%ebx
11230c: 0f 84 8a 00 00 00 je 11239c <_CORE_message_queue_Seize+0xd0>
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
112312: 8b 33 mov (%ebx),%esi
the_chain->first = new_first;
112314: 89 72 50 mov %esi,0x50(%edx)
CORE_message_queue_Buffer_control *_CORE_message_queue_Get_pending_message (
CORE_message_queue_Control *the_message_queue
)
{
return (CORE_message_queue_Buffer_control *)
_Chain_Get_unprotected( &the_message_queue->Pending_messages );
112317: 8d 7a 50 lea 0x50(%edx),%edi
11231a: 89 7e 04 mov %edi,0x4(%esi)
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
11231d: 85 db test %ebx,%ebx
11231f: 74 7b je 11239c <_CORE_message_queue_Seize+0xd0><== NEVER TAKEN
the_message_queue->number_of_pending_messages -= 1;
112321: ff 4a 48 decl 0x48(%edx)
_ISR_Enable( level );
112324: ff 75 e4 pushl -0x1c(%ebp)
112327: 9d popf
*size_p = the_message->Contents.size;
112328: 8b 43 0c mov 0xc(%ebx),%eax
11232b: 89 01 mov %eax,(%ecx)
_Thread_Executing->Wait.count =
11232d: 8b 73 08 mov 0x8(%ebx),%esi
112330: a1 9c c9 12 00 mov 0x12c99c,%eax
112335: 89 70 24 mov %esi,0x24(%eax)
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
112338: 8d 73 10 lea 0x10(%ebx),%esi
11233b: 89 75 e4 mov %esi,-0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
11233e: 8b 09 mov (%ecx),%ecx
112340: 8b 7d e0 mov -0x20(%ebp),%edi
112343: 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 );
112345: 83 ec 0c sub $0xc,%esp
112348: 52 push %edx
112349: 89 55 d0 mov %edx,-0x30(%ebp)
11234c: e8 3b 19 00 00 call 113c8c <_Thread_queue_Dequeue>
if ( !the_thread ) {
112351: 83 c4 10 add $0x10,%esp
112354: 85 c0 test %eax,%eax
112356: 8b 55 d0 mov -0x30(%ebp),%edx
112359: 75 15 jne 112370 <_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 );
11235b: 89 5d 0c mov %ebx,0xc(%ebp)
11235e: 83 c2 68 add $0x68,%edx
112361: 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 );
}
112364: 8d 65 f4 lea -0xc(%ebp),%esp
112367: 5b pop %ebx
112368: 5e pop %esi
112369: 5f pop %edi
11236a: c9 leave
11236b: e9 28 fe ff ff jmp 112198 <_Chain_Append>
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
112370: 8b 48 24 mov 0x24(%eax),%ecx
112373: 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;
112376: 8b 48 30 mov 0x30(%eax),%ecx
112379: 89 4b 0c mov %ecx,0xc(%ebx)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
11237c: 8b 70 2c mov 0x2c(%eax),%esi
11237f: 8b 7d e4 mov -0x1c(%ebp),%edi
112382: 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(
112384: 8b 43 08 mov 0x8(%ebx),%eax
112387: 89 45 10 mov %eax,0x10(%ebp)
11238a: 89 5d 0c mov %ebx,0xc(%ebp)
11238d: 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 );
}
112390: 8d 65 f4 lea -0xc(%ebp),%esp
112393: 5b pop %ebx
112394: 5e pop %esi
112395: 5f pop %edi
112396: c9 leave
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
112397: e9 08 49 00 00 jmp 116ca4 <_CORE_message_queue_Insert_message>
return;
}
#endif
}
if ( !wait ) {
11239c: 80 7d db 00 cmpb $0x0,-0x25(%ebp)
1123a0: 75 13 jne 1123b5 <_CORE_message_queue_Seize+0xe9>
_ISR_Enable( level );
1123a2: ff 75 e4 pushl -0x1c(%ebp)
1123a5: 9d popf
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
1123a6: 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 );
}
1123ad: 8d 65 f4 lea -0xc(%ebp),%esp
1123b0: 5b pop %ebx
1123b1: 5e pop %esi
1123b2: 5f pop %edi
1123b3: c9 leave
1123b4: 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;
1123b5: 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;
1123bc: 89 50 44 mov %edx,0x44(%eax)
executing->Wait.id = id;
1123bf: 8b 5d dc mov -0x24(%ebp),%ebx
1123c2: 89 58 20 mov %ebx,0x20(%eax)
executing->Wait.return_argument_second.mutable_object = buffer;
1123c5: 8b 75 e0 mov -0x20(%ebp),%esi
1123c8: 89 70 2c mov %esi,0x2c(%eax)
executing->Wait.return_argument = size_p;
1123cb: 89 48 28 mov %ecx,0x28(%eax)
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
1123ce: ff 75 e4 pushl -0x1c(%ebp)
1123d1: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
1123d2: c7 45 10 6c 40 11 00 movl $0x11406c,0x10(%ebp)
1123d9: 8b 45 d4 mov -0x2c(%ebp),%eax
1123dc: 89 45 0c mov %eax,0xc(%ebp)
1123df: 89 55 08 mov %edx,0x8(%ebp)
}
1123e2: 8d 65 f4 lea -0xc(%ebp),%esp
1123e5: 5b pop %ebx
1123e6: 5e pop %esi
1123e7: 5f pop %edi
1123e8: 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 );
1123e9: e9 a6 19 00 00 jmp 113d94 <_Thread_queue_Enqueue_with_handler>
0010ac1d <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10ac1d: 55 push %ebp
10ac1e: 89 e5 mov %esp,%ebp
10ac20: 53 push %ebx
10ac21: 83 ec 14 sub $0x14,%esp
10ac24: 8b 5d 08 mov 0x8(%ebp),%ebx
10ac27: 8a 55 10 mov 0x10(%ebp),%dl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10ac2a: a1 e4 42 12 00 mov 0x1242e4,%eax
10ac2f: 85 c0 test %eax,%eax
10ac31: 74 19 je 10ac4c <_CORE_mutex_Seize+0x2f>
10ac33: 84 d2 test %dl,%dl
10ac35: 74 15 je 10ac4c <_CORE_mutex_Seize+0x2f><== NEVER TAKEN
10ac37: 83 3d 64 44 12 00 01 cmpl $0x1,0x124464
10ac3e: 76 0c jbe 10ac4c <_CORE_mutex_Seize+0x2f>
10ac40: 53 push %ebx
10ac41: 6a 12 push $0x12
10ac43: 6a 00 push $0x0
10ac45: 6a 00 push $0x0
10ac47: e8 e4 05 00 00 call 10b230 <_Internal_error_Occurred>
10ac4c: 51 push %ecx
10ac4d: 51 push %ecx
10ac4e: 8d 45 18 lea 0x18(%ebp),%eax
10ac51: 50 push %eax
10ac52: 53 push %ebx
10ac53: 88 55 f4 mov %dl,-0xc(%ebp)
10ac56: e8 b9 46 00 00 call 10f314 <_CORE_mutex_Seize_interrupt_trylock>
10ac5b: 83 c4 10 add $0x10,%esp
10ac5e: 85 c0 test %eax,%eax
10ac60: 8a 55 f4 mov -0xc(%ebp),%dl
10ac63: 74 48 je 10acad <_CORE_mutex_Seize+0x90>
10ac65: 84 d2 test %dl,%dl
10ac67: 75 12 jne 10ac7b <_CORE_mutex_Seize+0x5e>
10ac69: ff 75 18 pushl 0x18(%ebp)
10ac6c: 9d popf
10ac6d: a1 34 48 12 00 mov 0x124834,%eax
10ac72: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
10ac79: eb 32 jmp 10acad <_CORE_mutex_Seize+0x90>
10ac7b: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
10ac82: a1 34 48 12 00 mov 0x124834,%eax
10ac87: 89 58 44 mov %ebx,0x44(%eax)
10ac8a: 8b 55 0c mov 0xc(%ebp),%edx
10ac8d: 89 50 20 mov %edx,0x20(%eax)
10ac90: a1 e4 42 12 00 mov 0x1242e4,%eax
10ac95: 40 inc %eax
10ac96: a3 e4 42 12 00 mov %eax,0x1242e4
10ac9b: ff 75 18 pushl 0x18(%ebp)
10ac9e: 9d popf
10ac9f: 50 push %eax
10aca0: 50 push %eax
10aca1: ff 75 14 pushl 0x14(%ebp)
10aca4: 53 push %ebx
10aca5: e8 26 ff ff ff call 10abd0 <_CORE_mutex_Seize_interrupt_blocking>
10acaa: 83 c4 10 add $0x10,%esp
}
10acad: 8b 5d fc mov -0x4(%ebp),%ebx
10acb0: c9 leave
10acb1: c3 ret
0010add8 <_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
)
{
10add8: 55 push %ebp
10add9: 89 e5 mov %esp,%ebp
10addb: 53 push %ebx
10addc: 83 ec 10 sub $0x10,%esp
10addf: 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)) ) {
10ade2: 53 push %ebx
10ade3: e8 64 14 00 00 call 10c24c <_Thread_queue_Dequeue>
10ade8: 89 c2 mov %eax,%edx
10adea: 83 c4 10 add $0x10,%esp
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10aded: 31 c0 xor %eax,%eax
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
10adef: 85 d2 test %edx,%edx
10adf1: 75 15 jne 10ae08 <_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 );
10adf3: 9c pushf
10adf4: fa cli
10adf5: 59 pop %ecx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10adf6: 8b 53 48 mov 0x48(%ebx),%edx
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
10adf9: 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 )
10adfb: 3b 53 40 cmp 0x40(%ebx),%edx
10adfe: 73 06 jae 10ae06 <_CORE_semaphore_Surrender+0x2e><== NEVER TAKEN
the_semaphore->count += 1;
10ae00: 42 inc %edx
10ae01: 89 53 48 mov %edx,0x48(%ebx)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10ae04: 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 );
10ae06: 51 push %ecx
10ae07: 9d popf
}
return status;
}
10ae08: 8b 5d fc mov -0x4(%ebp),%ebx
10ae0b: c9 leave
10ae0c: c3 ret
00109d48 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
109d48: 55 push %ebp
109d49: 89 e5 mov %esp,%ebp
109d4b: 57 push %edi
109d4c: 56 push %esi
109d4d: 53 push %ebx
109d4e: 83 ec 2c sub $0x2c,%esp
109d51: 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 ];
109d54: 8b bb f4 00 00 00 mov 0xf4(%ebx),%edi
option_set = (rtems_option) the_thread->Wait.option;
109d5a: 8b 43 30 mov 0x30(%ebx),%eax
109d5d: 89 45 e0 mov %eax,-0x20(%ebp)
_ISR_Disable( level );
109d60: 9c pushf
109d61: fa cli
109d62: 58 pop %eax
pending_events = api->pending_events;
109d63: 8b 17 mov (%edi),%edx
109d65: 89 55 d4 mov %edx,-0x2c(%ebp)
event_condition = (rtems_event_set) the_thread->Wait.count;
109d68: 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 ) ) {
109d6b: 21 f2 and %esi,%edx
109d6d: 75 07 jne 109d76 <_Event_Surrender+0x2e>
_ISR_Enable( level );
109d6f: 50 push %eax
109d70: 9d popf
return;
109d71: e9 af 00 00 00 jmp 109e25 <_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() &&
109d76: 83 3d 30 48 12 00 00 cmpl $0x0,0x124830
109d7d: 74 49 je 109dc8 <_Event_Surrender+0x80>
109d7f: 3b 1d 34 48 12 00 cmp 0x124834,%ebx
109d85: 75 41 jne 109dc8 <_Event_Surrender+0x80>
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
109d87: 8b 0d e4 4b 12 00 mov 0x124be4,%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 ) &&
109d8d: 83 f9 02 cmp $0x2,%ecx
109d90: 74 09 je 109d9b <_Event_Surrender+0x53> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
109d92: 8b 0d e4 4b 12 00 mov 0x124be4,%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) ||
109d98: 49 dec %ecx
109d99: 75 2d jne 109dc8 <_Event_Surrender+0x80>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
109d9b: 39 f2 cmp %esi,%edx
109d9d: 74 06 je 109da5 <_Event_Surrender+0x5d>
109d9f: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109da3: 74 1f je 109dc4 <_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) );
109da5: 89 d6 mov %edx,%esi
109da7: f7 d6 not %esi
109da9: 23 75 d4 and -0x2c(%ebp),%esi
109dac: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
109dae: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109db5: 8b 4b 28 mov 0x28(%ebx),%ecx
109db8: 89 11 mov %edx,(%ecx)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
109dba: c7 05 e4 4b 12 00 03 movl $0x3,0x124be4
109dc1: 00 00 00
}
_ISR_Enable( level );
109dc4: 50 push %eax
109dc5: 9d popf
return;
109dc6: eb 5d jmp 109e25 <_Event_Surrender+0xdd>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
109dc8: f6 43 11 01 testb $0x1,0x11(%ebx)
109dcc: 74 55 je 109e23 <_Event_Surrender+0xdb>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
109dce: 39 f2 cmp %esi,%edx
109dd0: 74 06 je 109dd8 <_Event_Surrender+0x90>
109dd2: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109dd6: 74 4b je 109e23 <_Event_Surrender+0xdb> <== NEVER TAKEN
109dd8: 89 d6 mov %edx,%esi
109dda: f7 d6 not %esi
109ddc: 23 75 d4 and -0x2c(%ebp),%esi
109ddf: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
109de1: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109de8: 8b 4b 28 mov 0x28(%ebx),%ecx
109deb: 89 11 mov %edx,(%ecx)
_ISR_Flash( level );
109ded: 50 push %eax
109dee: 9d popf
109def: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
109df0: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
109df4: 74 06 je 109dfc <_Event_Surrender+0xb4>
_ISR_Enable( level );
109df6: 50 push %eax
109df7: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
109df8: 51 push %ecx
109df9: 51 push %ecx
109dfa: eb 17 jmp 109e13 <_Event_Surrender+0xcb>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
109dfc: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
109e03: 50 push %eax
109e04: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
109e05: 83 ec 0c sub $0xc,%esp
109e08: 8d 43 48 lea 0x48(%ebx),%eax
109e0b: 50 push %eax
109e0c: e8 a7 2f 00 00 call 10cdb8 <_Watchdog_Remove>
109e11: 58 pop %eax
109e12: 5a pop %edx
109e13: 68 f8 ff 03 10 push $0x1003fff8
109e18: 53 push %ebx
109e19: e8 3e 1d 00 00 call 10bb5c <_Thread_Clear_state>
109e1e: 83 c4 10 add $0x10,%esp
109e21: eb 02 jmp 109e25 <_Event_Surrender+0xdd>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
109e23: 50 push %eax
109e24: 9d popf
}
109e25: 8d 65 f4 lea -0xc(%ebp),%esp
109e28: 5b pop %ebx
109e29: 5e pop %esi
109e2a: 5f pop %edi
109e2b: c9 leave
109e2c: c3 ret
00109e30 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
109e30: 55 push %ebp
109e31: 89 e5 mov %esp,%ebp
109e33: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
109e36: 8d 45 f4 lea -0xc(%ebp),%eax
109e39: 50 push %eax
109e3a: ff 75 08 pushl 0x8(%ebp)
109e3d: e8 ae 20 00 00 call 10bef0 <_Thread_Get>
switch ( location ) {
109e42: 83 c4 10 add $0x10,%esp
109e45: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
109e49: 75 49 jne 109e94 <_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 );
109e4b: 9c pushf
109e4c: fa cli
109e4d: 5a pop %edx
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
109e4e: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
109e55: 3b 05 34 48 12 00 cmp 0x124834,%eax
109e5b: 75 13 jne 109e70 <_Event_Timeout+0x40>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
109e5d: 8b 0d e4 4b 12 00 mov 0x124be4,%ecx
109e63: 49 dec %ecx
109e64: 75 0a jne 109e70 <_Event_Timeout+0x40>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
109e66: c7 05 e4 4b 12 00 02 movl $0x2,0x124be4
109e6d: 00 00 00
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
109e70: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax)
_ISR_Enable( level );
109e77: 52 push %edx
109e78: 9d popf
109e79: 52 push %edx
109e7a: 52 push %edx
109e7b: 68 f8 ff 03 10 push $0x1003fff8
109e80: 50 push %eax
109e81: e8 d6 1c 00 00 call 10bb5c <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
109e86: a1 e4 42 12 00 mov 0x1242e4,%eax
109e8b: 48 dec %eax
109e8c: a3 e4 42 12 00 mov %eax,0x1242e4
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
109e91: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
109e94: c9 leave
109e95: c3 ret
0010f973 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
10f973: 55 push %ebp
10f974: 89 e5 mov %esp,%ebp
10f976: 57 push %edi
10f977: 56 push %esi
10f978: 53 push %ebx
10f979: 83 ec 4c sub $0x4c,%esp
10f97c: 8b 5d 08 mov 0x8(%ebp),%ebx
10f97f: 8b 4d 10 mov 0x10(%ebp),%ecx
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
10f982: 8b 43 20 mov 0x20(%ebx),%eax
10f985: 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;
10f988: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
Heap_Block *extend_last_block = NULL;
10f98f: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
uintptr_t const page_size = heap->page_size;
10f996: 8b 53 10 mov 0x10(%ebx),%edx
10f999: 89 55 c4 mov %edx,-0x3c(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10f99c: 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;
10f99f: 8b 7b 30 mov 0x30(%ebx),%edi
10f9a2: 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;
10f9a5: 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 ) {
10f9a7: 8b 7d 0c mov 0xc(%ebp),%edi
10f9aa: 01 cf add %ecx,%edi
10f9ac: 0f 82 d4 01 00 00 jb 10fb86 <_Heap_Extend+0x213>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
10f9b2: 52 push %edx
10f9b3: 52 push %edx
10f9b4: 8d 55 e0 lea -0x20(%ebp),%edx
10f9b7: 52 push %edx
10f9b8: 8d 55 e4 lea -0x1c(%ebp),%edx
10f9bb: 52 push %edx
10f9bc: 50 push %eax
10f9bd: ff 75 c4 pushl -0x3c(%ebp)
10f9c0: 51 push %ecx
10f9c1: ff 75 0c pushl 0xc(%ebp)
10f9c4: e8 8a b9 ff ff call 10b353 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
10f9c9: 83 c4 20 add $0x20,%esp
10f9cc: 84 c0 test %al,%al
10f9ce: 0f 84 b2 01 00 00 je 10fb86 <_Heap_Extend+0x213>
10f9d4: 8b 4d c0 mov -0x40(%ebp),%ecx
10f9d7: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp)
10f9de: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
10f9e5: 31 f6 xor %esi,%esi
10f9e7: 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;
10f9ee: 8b 43 18 mov 0x18(%ebx),%eax
10f9f1: 89 5d b8 mov %ebx,-0x48(%ebp)
10f9f4: eb 02 jmp 10f9f8 <_Heap_Extend+0x85>
10f9f6: 89 c8 mov %ecx,%eax
uintptr_t const sub_area_end = start_block->prev_size;
10f9f8: 8b 19 mov (%ecx),%ebx
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
10f9fa: 39 c7 cmp %eax,%edi
10f9fc: 76 09 jbe 10fa07 <_Heap_Extend+0x94>
10f9fe: 39 5d 0c cmp %ebx,0xc(%ebp)
10fa01: 0f 82 7d 01 00 00 jb 10fb84 <_Heap_Extend+0x211>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10fa07: 39 c7 cmp %eax,%edi
10fa09: 74 06 je 10fa11 <_Heap_Extend+0x9e>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10fa0b: 39 df cmp %ebx,%edi
10fa0d: 72 07 jb 10fa16 <_Heap_Extend+0xa3>
10fa0f: eb 08 jmp 10fa19 <_Heap_Extend+0xa6>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10fa11: 89 4d d0 mov %ecx,-0x30(%ebp)
10fa14: eb 03 jmp 10fa19 <_Heap_Extend+0xa6>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10fa16: 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);
10fa19: 8d 43 f8 lea -0x8(%ebx),%eax
10fa1c: 89 45 d4 mov %eax,-0x2c(%ebp)
10fa1f: 89 d8 mov %ebx,%eax
10fa21: 31 d2 xor %edx,%edx
10fa23: 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);
10fa26: 29 55 d4 sub %edx,-0x2c(%ebp)
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
10fa29: 3b 5d 0c cmp 0xc(%ebp),%ebx
10fa2c: 75 07 jne 10fa35 <_Heap_Extend+0xc2>
start_block->prev_size = extend_area_end;
10fa2e: 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 )
10fa30: 8b 75 d4 mov -0x2c(%ebp),%esi
10fa33: eb 08 jmp 10fa3d <_Heap_Extend+0xca>
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
10fa35: 73 06 jae 10fa3d <_Heap_Extend+0xca>
10fa37: 8b 55 d4 mov -0x2c(%ebp),%edx
10fa3a: 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;
10fa3d: 8b 45 d4 mov -0x2c(%ebp),%eax
10fa40: 8b 48 04 mov 0x4(%eax),%ecx
10fa43: 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);
10fa46: 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 );
10fa48: 3b 4d c0 cmp -0x40(%ebp),%ecx
10fa4b: 75 a9 jne 10f9f6 <_Heap_Extend+0x83>
10fa4d: 8b 5d b8 mov -0x48(%ebp),%ebx
if ( extend_area_begin < heap->area_begin ) {
10fa50: 8b 55 0c mov 0xc(%ebp),%edx
10fa53: 3b 53 18 cmp 0x18(%ebx),%edx
10fa56: 73 05 jae 10fa5d <_Heap_Extend+0xea>
heap->area_begin = extend_area_begin;
10fa58: 89 53 18 mov %edx,0x18(%ebx)
10fa5b: eb 08 jmp 10fa65 <_Heap_Extend+0xf2>
} else if ( heap->area_end < extend_area_end ) {
10fa5d: 39 7b 1c cmp %edi,0x1c(%ebx)
10fa60: 73 03 jae 10fa65 <_Heap_Extend+0xf2>
heap->area_end = extend_area_end;
10fa62: 89 7b 1c mov %edi,0x1c(%ebx)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
10fa65: 8b 45 e0 mov -0x20(%ebp),%eax
10fa68: 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 =
10fa6b: 89 c1 mov %eax,%ecx
10fa6d: 29 d1 sub %edx,%ecx
10fa6f: 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;
10fa72: 89 3a mov %edi,(%edx)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
10fa74: 83 c9 01 or $0x1,%ecx
10fa77: 89 4a 04 mov %ecx,0x4(%edx)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
10fa7a: 8b 4d d4 mov -0x2c(%ebp),%ecx
10fa7d: 89 08 mov %ecx,(%eax)
extend_last_block->size_and_flag = 0;
10fa7f: 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 ) {
10fa86: 39 53 20 cmp %edx,0x20(%ebx)
10fa89: 76 05 jbe 10fa90 <_Heap_Extend+0x11d>
heap->first_block = extend_first_block;
10fa8b: 89 53 20 mov %edx,0x20(%ebx)
10fa8e: eb 08 jmp 10fa98 <_Heap_Extend+0x125>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
10fa90: 39 43 24 cmp %eax,0x24(%ebx)
10fa93: 73 03 jae 10fa98 <_Heap_Extend+0x125>
heap->last_block = extend_last_block;
10fa95: 89 43 24 mov %eax,0x24(%ebx)
}
if ( merge_below_block != NULL ) {
10fa98: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10fa9c: 74 3b je 10fad9 <_Heap_Extend+0x166>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
10fa9e: 8b 43 10 mov 0x10(%ebx),%eax
10faa1: 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 );
10faa4: 8b 4d 0c mov 0xc(%ebp),%ecx
10faa7: 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;
10faaa: 89 c8 mov %ecx,%eax
10faac: 31 d2 xor %edx,%edx
10faae: f7 75 d4 divl -0x2c(%ebp)
if ( remainder != 0 ) {
10fab1: 85 d2 test %edx,%edx
10fab3: 74 05 je 10faba <_Heap_Extend+0x147> <== ALWAYS TAKEN
return value - remainder + alignment;
10fab5: 03 4d d4 add -0x2c(%ebp),%ecx <== NOT EXECUTED
10fab8: 29 d1 sub %edx,%ecx <== NOT EXECUTED
uintptr_t const new_first_block_begin =
10faba: 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;
10fabd: 8b 45 d0 mov -0x30(%ebp),%eax
10fac0: 8b 00 mov (%eax),%eax
10fac2: 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 =
10fac5: 8b 45 d0 mov -0x30(%ebp),%eax
10fac8: 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;
10faca: 83 c8 01 or $0x1,%eax
10facd: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, new_first_block );
10fad0: 89 d8 mov %ebx,%eax
10fad2: e8 81 fe ff ff call 10f958 <_Heap_Free_block>
10fad7: eb 14 jmp 10faed <_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 ) {
10fad9: 83 7d c8 00 cmpl $0x0,-0x38(%ebp)
10fadd: 74 0e je 10faed <_Heap_Extend+0x17a>
_Heap_Link_below(
10fadf: 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;
10fae2: 8b 45 c8 mov -0x38(%ebp),%eax
10fae5: 29 d0 sub %edx,%eax
10fae7: 83 c8 01 or $0x1,%eax
10faea: 89 42 04 mov %eax,0x4(%edx)
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
10faed: 85 f6 test %esi,%esi
10faef: 74 30 je 10fb21 <_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,
10faf1: 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(
10faf4: 29 f7 sub %esi,%edi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10faf6: 89 f8 mov %edi,%eax
10faf8: 31 d2 xor %edx,%edx
10fafa: f7 73 10 divl 0x10(%ebx)
10fafd: 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)
10faff: 8b 46 04 mov 0x4(%esi),%eax
10fb02: 29 f8 sub %edi,%eax
| HEAP_PREV_BLOCK_USED;
10fb04: 83 c8 01 or $0x1,%eax
10fb07: 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;
10fb0b: 8b 46 04 mov 0x4(%esi),%eax
10fb0e: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
10fb11: 09 f8 or %edi,%eax
10fb13: 89 46 04 mov %eax,0x4(%esi)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
10fb16: 89 f2 mov %esi,%edx
10fb18: 89 d8 mov %ebx,%eax
10fb1a: e8 39 fe ff ff call 10f958 <_Heap_Free_block>
10fb1f: eb 21 jmp 10fb42 <_Heap_Extend+0x1cf>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
10fb21: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
10fb25: 74 1b je 10fb42 <_Heap_Extend+0x1cf>
_Heap_Link_above(
10fb27: 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 );
10fb2a: 8b 45 e4 mov -0x1c(%ebp),%eax
10fb2d: 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;
10fb30: 8b 7d cc mov -0x34(%ebp),%edi
10fb33: 8b 57 04 mov 0x4(%edi),%edx
10fb36: 83 e2 01 and $0x1,%edx
block->size_and_flag = size | flag;
10fb39: 09 d0 or %edx,%eax
10fb3b: 89 47 04 mov %eax,0x4(%edi)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
10fb3e: 83 49 04 01 orl $0x1,0x4(%ecx)
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
10fb42: 85 f6 test %esi,%esi
10fb44: 75 10 jne 10fb56 <_Heap_Extend+0x1e3>
10fb46: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10fb4a: 75 0a jne 10fb56 <_Heap_Extend+0x1e3>
_Heap_Free_block( heap, extend_first_block );
10fb4c: 8b 55 e4 mov -0x1c(%ebp),%edx
10fb4f: 89 d8 mov %ebx,%eax
10fb51: e8 02 fe ff ff call 10f958 <_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
10fb56: 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(
10fb59: 8b 43 20 mov 0x20(%ebx),%eax
10fb5c: 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;
10fb5e: 8b 4a 04 mov 0x4(%edx),%ecx
10fb61: 83 e1 01 and $0x1,%ecx
block->size_and_flag = size | flag;
10fb64: 09 c8 or %ecx,%eax
10fb66: 89 42 04 mov %eax,0x4(%edx)
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
10fb69: 8b 43 30 mov 0x30(%ebx),%eax
10fb6c: 2b 45 bc sub -0x44(%ebp),%eax
/* Statistics */
stats->size += extended_size;
10fb6f: 01 43 2c add %eax,0x2c(%ebx)
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
10fb72: 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 )
10fb77: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10fb7b: 74 09 je 10fb86 <_Heap_Extend+0x213> <== NEVER TAKEN
*extended_size_ptr = extended_size;
10fb7d: 8b 55 14 mov 0x14(%ebp),%edx
10fb80: 89 02 mov %eax,(%edx)
10fb82: eb 02 jmp 10fb86 <_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;
10fb84: 31 f6 xor %esi,%esi
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
10fb86: 89 f0 mov %esi,%eax
10fb88: 8d 65 f4 lea -0xc(%ebp),%esp
10fb8b: 5b pop %ebx
10fb8c: 5e pop %esi
10fb8d: 5f pop %edi
10fb8e: c9 leave
10fb8f: c3 ret
0010f5b8 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
10f5b8: 55 push %ebp
10f5b9: 89 e5 mov %esp,%ebp
10f5bb: 57 push %edi
10f5bc: 56 push %esi
10f5bd: 53 push %ebx
10f5be: 83 ec 14 sub $0x14,%esp
10f5c1: 8b 4d 08 mov 0x8(%ebp),%ecx
10f5c4: 8b 45 0c mov 0xc(%ebp),%eax
10f5c7: 8d 58 f8 lea -0x8(%eax),%ebx
10f5ca: 31 d2 xor %edx,%edx
10f5cc: 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);
10f5cf: 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
10f5d1: 8b 41 20 mov 0x20(%ecx),%eax
10f5d4: 89 45 ec mov %eax,-0x14(%ebp)
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10f5d7: 31 d2 xor %edx,%edx
10f5d9: 39 c3 cmp %eax,%ebx
10f5db: 72 08 jb 10f5e5 <_Heap_Free+0x2d>
10f5dd: 31 d2 xor %edx,%edx
10f5df: 39 59 24 cmp %ebx,0x24(%ecx)
10f5e2: 0f 93 c2 setae %dl
bool next_is_free = false;
_Heap_Protection_block_check( heap, block );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
return false;
10f5e5: 31 c0 xor %eax,%eax
uintptr_t next_block_size = 0;
bool next_is_free = false;
_Heap_Protection_block_check( heap, block );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
10f5e7: 85 d2 test %edx,%edx
10f5e9: 0f 84 21 01 00 00 je 10f710 <_Heap_Free+0x158>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f5ef: 8b 43 04 mov 0x4(%ebx),%eax
10f5f2: 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;
10f5f5: 89 c6 mov %eax,%esi
10f5f7: 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);
10f5fa: 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;
10f5fd: 31 ff xor %edi,%edi
10f5ff: 3b 55 ec cmp -0x14(%ebp),%edx
10f602: 72 0a jb 10f60e <_Heap_Free+0x56> <== NEVER TAKEN
10f604: 31 c0 xor %eax,%eax
10f606: 39 51 24 cmp %edx,0x24(%ecx)
10f609: 0f 93 c0 setae %al
10f60c: 89 c7 mov %eax,%edi
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
10f60e: 31 c0 xor %eax,%eax
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
10f610: 85 ff test %edi,%edi
10f612: 0f 84 f8 00 00 00 je 10f710 <_Heap_Free+0x158> <== NEVER TAKEN
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f618: 8b 7a 04 mov 0x4(%edx),%edi
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10f61b: f7 c7 01 00 00 00 test $0x1,%edi
10f621: 0f 84 e9 00 00 00 je 10f710 <_Heap_Free+0x158> <== NEVER TAKEN
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10f627: 83 e7 fe and $0xfffffffe,%edi
10f62a: 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
10f62d: 8b 41 24 mov 0x24(%ecx),%eax
10f630: 89 45 e4 mov %eax,-0x1c(%ebp)
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
10f633: 31 c0 xor %eax,%eax
10f635: 3b 55 e4 cmp -0x1c(%ebp),%edx
10f638: 74 0a je 10f644 <_Heap_Free+0x8c>
10f63a: 31 c0 xor %eax,%eax
10f63c: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1)
10f641: 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
10f644: 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 ) ) {
10f647: f6 45 f0 01 testb $0x1,-0x10(%ebp)
10f64b: 75 62 jne 10f6af <_Heap_Free+0xf7>
uintptr_t const prev_size = block->prev_size;
10f64d: 8b 03 mov (%ebx),%eax
10f64f: 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);
10f652: 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;
10f654: 31 ff xor %edi,%edi
10f656: 3b 5d ec cmp -0x14(%ebp),%ebx
10f659: 72 0a jb 10f665 <_Heap_Free+0xad> <== NEVER TAKEN
10f65b: 31 c0 xor %eax,%eax
10f65d: 39 5d e4 cmp %ebx,-0x1c(%ebp)
10f660: 0f 93 c0 setae %al
10f663: 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 );
10f665: 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 ) ) {
10f667: 85 ff test %edi,%edi
10f669: 0f 84 a1 00 00 00 je 10f710 <_Heap_Free+0x158> <== NEVER TAKEN
return( false );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
10f66f: f6 43 04 01 testb $0x1,0x4(%ebx)
10f673: 0f 84 97 00 00 00 je 10f710 <_Heap_Free+0x158> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
10f679: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f67d: 74 1a je 10f699 <_Heap_Free+0xe1>
uintptr_t const size = block_size + prev_size + next_block_size;
10f67f: 8b 45 e8 mov -0x18(%ebp),%eax
10f682: 8d 04 06 lea (%esi,%eax,1),%eax
10f685: 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;
10f688: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = block->prev;
10f68b: 8b 52 0c mov 0xc(%edx),%edx
prev->next = next;
10f68e: 89 7a 08 mov %edi,0x8(%edx)
next->prev = prev;
10f691: 89 57 0c mov %edx,0xc(%edi)
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
10f694: ff 49 38 decl 0x38(%ecx)
10f697: eb 33 jmp 10f6cc <_Heap_Free+0x114>
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
10f699: 8b 45 f0 mov -0x10(%ebp),%eax
10f69c: 8d 04 06 lea (%esi,%eax,1),%eax
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f69f: 89 c7 mov %eax,%edi
10f6a1: 83 cf 01 or $0x1,%edi
10f6a4: 89 7b 04 mov %edi,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f6a7: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = size;
10f6ab: 89 02 mov %eax,(%edx)
10f6ad: eb 56 jmp 10f705 <_Heap_Free+0x14d>
}
} else if ( next_is_free ) { /* coalesce next */
10f6af: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f6b3: 74 24 je 10f6d9 <_Heap_Free+0x121>
uintptr_t const size = block_size + next_block_size;
10f6b5: 8b 45 e8 mov -0x18(%ebp),%eax
10f6b8: 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;
10f6ba: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = old_block->prev;
10f6bd: 8b 52 0c mov 0xc(%edx),%edx
new_block->next = next;
10f6c0: 89 7b 08 mov %edi,0x8(%ebx)
new_block->prev = prev;
10f6c3: 89 53 0c mov %edx,0xc(%ebx)
next->prev = new_block;
10f6c6: 89 5f 0c mov %ebx,0xc(%edi)
prev->next = new_block;
10f6c9: 89 5a 08 mov %ebx,0x8(%edx)
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f6cc: 89 c2 mov %eax,%edx
10f6ce: 83 ca 01 or $0x1,%edx
10f6d1: 89 53 04 mov %edx,0x4(%ebx)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
10f6d4: 89 04 03 mov %eax,(%ebx,%eax,1)
10f6d7: eb 2c jmp 10f705 <_Heap_Free+0x14d>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
10f6d9: 8b 41 08 mov 0x8(%ecx),%eax
new_block->next = next;
10f6dc: 89 43 08 mov %eax,0x8(%ebx)
new_block->prev = block_before;
10f6df: 89 4b 0c mov %ecx,0xc(%ebx)
block_before->next = new_block;
10f6e2: 89 59 08 mov %ebx,0x8(%ecx)
next->prev = new_block;
10f6e5: 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;
10f6e8: 89 f0 mov %esi,%eax
10f6ea: 83 c8 01 or $0x1,%eax
10f6ed: 89 43 04 mov %eax,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f6f0: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = block_size;
10f6f4: 89 32 mov %esi,(%edx)
/* Statistics */
++stats->free_blocks;
10f6f6: 8b 41 38 mov 0x38(%ecx),%eax
10f6f9: 40 inc %eax
10f6fa: 89 41 38 mov %eax,0x38(%ecx)
if ( stats->max_free_blocks < stats->free_blocks ) {
10f6fd: 39 41 3c cmp %eax,0x3c(%ecx)
10f700: 73 03 jae 10f705 <_Heap_Free+0x14d>
stats->max_free_blocks = stats->free_blocks;
10f702: 89 41 3c mov %eax,0x3c(%ecx)
}
}
/* Statistics */
--stats->used_blocks;
10f705: ff 49 40 decl 0x40(%ecx)
++stats->frees;
10f708: ff 41 50 incl 0x50(%ecx)
stats->free_size += block_size;
10f70b: 01 71 30 add %esi,0x30(%ecx)
return( true );
10f70e: b0 01 mov $0x1,%al
}
10f710: 83 c4 14 add $0x14,%esp
10f713: 5b pop %ebx
10f714: 5e pop %esi
10f715: 5f pop %edi
10f716: c9 leave
10f717: c3 ret
0011cb80 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
11cb80: 55 push %ebp
11cb81: 89 e5 mov %esp,%ebp
11cb83: 57 push %edi
11cb84: 56 push %esi
11cb85: 53 push %ebx
11cb86: 8b 5d 08 mov 0x8(%ebp),%ebx
11cb89: 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);
11cb8c: 8d 4e f8 lea -0x8(%esi),%ecx
11cb8f: 89 f0 mov %esi,%eax
11cb91: 31 d2 xor %edx,%edx
11cb93: 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);
11cb96: 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
11cb98: 8b 53 20 mov 0x20(%ebx),%edx
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11cb9b: 31 ff xor %edi,%edi
11cb9d: 39 d1 cmp %edx,%ecx
11cb9f: 72 0a jb 11cbab <_Heap_Size_of_alloc_area+0x2b>
11cba1: 31 c0 xor %eax,%eax
11cba3: 39 4b 24 cmp %ecx,0x24(%ebx)
11cba6: 0f 93 c0 setae %al
11cba9: 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;
11cbab: 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 ) ) {
11cbad: 85 ff test %edi,%edi
11cbaf: 74 30 je 11cbe1 <_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;
11cbb1: 8b 41 04 mov 0x4(%ecx),%eax
11cbb4: 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);
11cbb7: 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;
11cbb9: 31 ff xor %edi,%edi
11cbbb: 39 d1 cmp %edx,%ecx
11cbbd: 72 0a jb 11cbc9 <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN
11cbbf: 31 c0 xor %eax,%eax
11cbc1: 39 4b 24 cmp %ecx,0x24(%ebx)
11cbc4: 0f 93 c0 setae %al
11cbc7: 89 c7 mov %eax,%edi
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
11cbc9: 31 c0 xor %eax,%eax
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
11cbcb: 85 ff test %edi,%edi
11cbcd: 74 12 je 11cbe1 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
11cbcf: f6 41 04 01 testb $0x1,0x4(%ecx)
11cbd3: 74 0c je 11cbe1 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
11cbd5: 29 f1 sub %esi,%ecx
11cbd7: 8d 51 04 lea 0x4(%ecx),%edx
11cbda: 8b 45 10 mov 0x10(%ebp),%eax
11cbdd: 89 10 mov %edx,(%eax)
return true;
11cbdf: b0 01 mov $0x1,%al
}
11cbe1: 5b pop %ebx
11cbe2: 5e pop %esi
11cbe3: 5f pop %edi
11cbe4: c9 leave
11cbe5: c3 ret
0010bc0e <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
10bc0e: 55 push %ebp
10bc0f: 89 e5 mov %esp,%ebp
10bc11: 57 push %edi
10bc12: 56 push %esi
10bc13: 53 push %ebx
10bc14: 83 ec 4c sub $0x4c,%esp
10bc17: 8b 75 08 mov 0x8(%ebp),%esi
10bc1a: 8b 5d 0c mov 0xc(%ebp),%ebx
uintptr_t const page_size = heap->page_size;
10bc1d: 8b 46 10 mov 0x10(%esi),%eax
10bc20: 89 45 d8 mov %eax,-0x28(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10bc23: 8b 4e 14 mov 0x14(%esi),%ecx
10bc26: 89 4d d4 mov %ecx,-0x2c(%ebp)
Heap_Block *const first_block = heap->first_block;
10bc29: 8b 46 20 mov 0x20(%esi),%eax
10bc2c: 89 45 d0 mov %eax,-0x30(%ebp)
Heap_Block *const last_block = heap->last_block;
10bc2f: 8b 4e 24 mov 0x24(%esi),%ecx
10bc32: 89 4d c8 mov %ecx,-0x38(%ebp)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10bc35: c7 45 e4 d0 bb 10 00 movl $0x10bbd0,-0x1c(%ebp)
10bc3c: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
10bc40: 74 07 je 10bc49 <_Heap_Walk+0x3b>
10bc42: c7 45 e4 d5 bb 10 00 movl $0x10bbd5,-0x1c(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
10bc49: 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() ) ) {
10bc4b: 83 3d ec 64 12 00 03 cmpl $0x3,0x1264ec
10bc52: 0f 85 e8 02 00 00 jne 10bf40 <_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)(
10bc58: 52 push %edx
10bc59: ff 76 0c pushl 0xc(%esi)
10bc5c: ff 76 08 pushl 0x8(%esi)
10bc5f: ff 75 c8 pushl -0x38(%ebp)
10bc62: ff 75 d0 pushl -0x30(%ebp)
10bc65: ff 76 1c pushl 0x1c(%esi)
10bc68: ff 76 18 pushl 0x18(%esi)
10bc6b: ff 75 d4 pushl -0x2c(%ebp)
10bc6e: ff 75 d8 pushl -0x28(%ebp)
10bc71: 68 09 f7 11 00 push $0x11f709
10bc76: 6a 00 push $0x0
10bc78: 53 push %ebx
10bc79: 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 ) {
10bc7c: 83 c4 30 add $0x30,%esp
10bc7f: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10bc83: 75 0b jne 10bc90 <_Heap_Walk+0x82>
(*printer)( source, true, "page size is zero\n" );
10bc85: 50 push %eax
10bc86: 68 9a f7 11 00 push $0x11f79a
10bc8b: e9 6b 02 00 00 jmp 10befb <_Heap_Walk+0x2ed>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
10bc90: f6 45 d8 03 testb $0x3,-0x28(%ebp)
10bc94: 74 0d je 10bca3 <_Heap_Walk+0x95>
(*printer)(
10bc96: ff 75 d8 pushl -0x28(%ebp)
10bc99: 68 ad f7 11 00 push $0x11f7ad
10bc9e: e9 58 02 00 00 jmp 10befb <_Heap_Walk+0x2ed>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bca3: 8b 45 d4 mov -0x2c(%ebp),%eax
10bca6: 31 d2 xor %edx,%edx
10bca8: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
10bcab: 85 d2 test %edx,%edx
10bcad: 74 0d je 10bcbc <_Heap_Walk+0xae>
(*printer)(
10bcaf: ff 75 d4 pushl -0x2c(%ebp)
10bcb2: 68 cb f7 11 00 push $0x11f7cb
10bcb7: e9 3f 02 00 00 jmp 10befb <_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;
10bcbc: 8b 45 d0 mov -0x30(%ebp),%eax
10bcbf: 83 c0 08 add $0x8,%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bcc2: 31 d2 xor %edx,%edx
10bcc4: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if (
10bcc7: 85 d2 test %edx,%edx
10bcc9: 74 0d je 10bcd8 <_Heap_Walk+0xca>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
10bccb: ff 75 d0 pushl -0x30(%ebp)
10bcce: 68 ef f7 11 00 push $0x11f7ef
10bcd3: e9 23 02 00 00 jmp 10befb <_Heap_Walk+0x2ed>
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
10bcd8: 8b 45 d0 mov -0x30(%ebp),%eax
10bcdb: f6 40 04 01 testb $0x1,0x4(%eax)
10bcdf: 75 0b jne 10bcec <_Heap_Walk+0xde>
(*printer)(
10bce1: 57 push %edi
10bce2: 68 20 f8 11 00 push $0x11f820
10bce7: e9 0f 02 00 00 jmp 10befb <_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;
10bcec: 8b 4d c8 mov -0x38(%ebp),%ecx
10bcef: 8b 79 04 mov 0x4(%ecx),%edi
10bcf2: 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);
10bcf5: 01 cf add %ecx,%edi
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
10bcf7: f6 47 04 01 testb $0x1,0x4(%edi)
10bcfb: 75 0b jne 10bd08 <_Heap_Walk+0xfa>
(*printer)(
10bcfd: 56 push %esi
10bcfe: 68 4e f8 11 00 push $0x11f84e
10bd03: e9 f3 01 00 00 jmp 10befb <_Heap_Walk+0x2ed>
);
return false;
}
if (
10bd08: 3b 7d d0 cmp -0x30(%ebp),%edi
10bd0b: 74 0b je 10bd18 <_Heap_Walk+0x10a> <== ALWAYS TAKEN
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
10bd0d: 51 push %ecx <== NOT EXECUTED
10bd0e: 68 63 f8 11 00 push $0x11f863 <== NOT EXECUTED
10bd13: e9 e3 01 00 00 jmp 10befb <_Heap_Walk+0x2ed> <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
10bd18: 8b 46 10 mov 0x10(%esi),%eax
10bd1b: 89 45 e0 mov %eax,-0x20(%ebp)
block = next_block;
} while ( block != first_block );
return true;
}
10bd1e: 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 );
10bd21: 89 75 dc mov %esi,-0x24(%ebp)
10bd24: eb 75 jmp 10bd9b <_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;
10bd26: 31 c0 xor %eax,%eax
10bd28: 39 4e 20 cmp %ecx,0x20(%esi)
10bd2b: 77 08 ja 10bd35 <_Heap_Walk+0x127>
10bd2d: 31 c0 xor %eax,%eax
10bd2f: 39 4e 24 cmp %ecx,0x24(%esi)
10bd32: 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 ) ) {
10bd35: 85 c0 test %eax,%eax
10bd37: 75 0b jne 10bd44 <_Heap_Walk+0x136>
(*printer)(
10bd39: 51 push %ecx
10bd3a: 68 92 f8 11 00 push $0x11f892
10bd3f: e9 b7 01 00 00 jmp 10befb <_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;
10bd44: 8d 41 08 lea 0x8(%ecx),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bd47: 31 d2 xor %edx,%edx
10bd49: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if (
10bd4c: 85 d2 test %edx,%edx
10bd4e: 74 0b je 10bd5b <_Heap_Walk+0x14d>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
10bd50: 51 push %ecx
10bd51: 68 b2 f8 11 00 push $0x11f8b2
10bd56: e9 a0 01 00 00 jmp 10befb <_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;
10bd5b: 8b 41 04 mov 0x4(%ecx),%eax
10bd5e: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10bd61: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1)
10bd66: 74 0b je 10bd73 <_Heap_Walk+0x165>
(*printer)(
10bd68: 51 push %ecx
10bd69: 68 e2 f8 11 00 push $0x11f8e2
10bd6e: e9 88 01 00 00 jmp 10befb <_Heap_Walk+0x2ed>
);
return false;
}
if ( free_block->prev != prev_block ) {
10bd73: 8b 41 0c mov 0xc(%ecx),%eax
10bd76: 3b 45 dc cmp -0x24(%ebp),%eax
10bd79: 74 1a je 10bd95 <_Heap_Walk+0x187>
(*printer)(
10bd7b: 83 ec 0c sub $0xc,%esp
10bd7e: 50 push %eax
10bd7f: 51 push %ecx
10bd80: 68 fe f8 11 00 push $0x11f8fe
10bd85: 6a 01 push $0x1
10bd87: 53 push %ebx
10bd88: ff 55 e4 call *-0x1c(%ebp)
10bd8b: 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;
10bd8e: 31 c0 xor %eax,%eax
10bd90: e9 ab 01 00 00 jmp 10bf40 <_Heap_Walk+0x332>
return false;
}
prev_block = free_block;
free_block = free_block->next;
10bd95: 89 4d dc mov %ecx,-0x24(%ebp)
10bd98: 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 ) {
10bd9b: 39 f1 cmp %esi,%ecx
10bd9d: 75 87 jne 10bd26 <_Heap_Walk+0x118>
10bd9f: 89 5d dc mov %ebx,-0x24(%ebp)
10bda2: eb 02 jmp 10bda6 <_Heap_Walk+0x198>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10bda4: 89 df mov %ebx,%edi
return true;
}
10bda6: 8b 4f 04 mov 0x4(%edi),%ecx
10bda9: 89 4d cc mov %ecx,-0x34(%ebp)
10bdac: 83 e1 fe and $0xfffffffe,%ecx
10bdaf: 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);
10bdb2: 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;
10bdb5: 31 c0 xor %eax,%eax
10bdb7: 39 5e 20 cmp %ebx,0x20(%esi)
10bdba: 77 08 ja 10bdc4 <_Heap_Walk+0x1b6> <== NEVER TAKEN
10bdbc: 31 c0 xor %eax,%eax
10bdbe: 39 5e 24 cmp %ebx,0x24(%esi)
10bdc1: 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 ) ) {
10bdc4: 85 c0 test %eax,%eax
10bdc6: 75 11 jne 10bdd9 <_Heap_Walk+0x1cb>
10bdc8: 89 d9 mov %ebx,%ecx
10bdca: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bdcd: 83 ec 0c sub $0xc,%esp
10bdd0: 51 push %ecx
10bdd1: 57 push %edi
10bdd2: 68 30 f9 11 00 push $0x11f930
10bdd7: eb ac jmp 10bd85 <_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;
10bdd9: 3b 7d c8 cmp -0x38(%ebp),%edi
10bddc: 0f 95 c1 setne %cl
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bddf: 8b 45 e0 mov -0x20(%ebp),%eax
10bde2: 31 d2 xor %edx,%edx
10bde4: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
10bde7: 85 d2 test %edx,%edx
10bde9: 74 15 je 10be00 <_Heap_Walk+0x1f2>
10bdeb: 84 c9 test %cl,%cl
10bded: 74 11 je 10be00 <_Heap_Walk+0x1f2>
10bdef: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bdf2: 83 ec 0c sub $0xc,%esp
10bdf5: ff 75 e0 pushl -0x20(%ebp)
10bdf8: 57 push %edi
10bdf9: 68 5d f9 11 00 push $0x11f95d
10bdfe: eb 85 jmp 10bd85 <_Heap_Walk+0x177>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
10be00: 8b 45 d4 mov -0x2c(%ebp),%eax
10be03: 39 45 e0 cmp %eax,-0x20(%ebp)
10be06: 73 18 jae 10be20 <_Heap_Walk+0x212>
10be08: 84 c9 test %cl,%cl
10be0a: 74 14 je 10be20 <_Heap_Walk+0x212> <== NEVER TAKEN
10be0c: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be0f: 52 push %edx
10be10: 52 push %edx
10be11: 50 push %eax
10be12: ff 75 e0 pushl -0x20(%ebp)
10be15: 57 push %edi
10be16: 68 8b f9 11 00 push $0x11f98b
10be1b: e9 65 ff ff ff jmp 10bd85 <_Heap_Walk+0x177>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
10be20: 39 fb cmp %edi,%ebx
10be22: 77 18 ja 10be3c <_Heap_Walk+0x22e>
10be24: 84 c9 test %cl,%cl
10be26: 74 14 je 10be3c <_Heap_Walk+0x22e>
10be28: 89 d9 mov %ebx,%ecx
10be2a: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be2d: 83 ec 0c sub $0xc,%esp
10be30: 51 push %ecx
10be31: 57 push %edi
10be32: 68 b6 f9 11 00 push $0x11f9b6
10be37: e9 49 ff ff ff jmp 10bd85 <_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;
10be3c: 8b 4d cc mov -0x34(%ebp),%ecx
10be3f: 83 e1 01 and $0x1,%ecx
10be42: 89 4d c4 mov %ecx,-0x3c(%ebp)
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10be45: f6 43 04 01 testb $0x1,0x4(%ebx)
10be49: 0f 85 ba 00 00 00 jne 10bf09 <_Heap_Walk+0x2fb>
block = next_block;
} while ( block != first_block );
return true;
}
10be4f: 8b 46 08 mov 0x8(%esi),%eax
10be52: 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 ?
10be55: 8b 4f 08 mov 0x8(%edi),%ecx
10be58: 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)(
10be5b: ba d6 f6 11 00 mov $0x11f6d6,%edx
10be60: 3b 4e 0c cmp 0xc(%esi),%ecx
10be63: 74 0e je 10be73 <_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)" : "")
10be65: ba 0d f6 11 00 mov $0x11f60d,%edx
10be6a: 39 f1 cmp %esi,%ecx
10be6c: 75 05 jne 10be73 <_Heap_Walk+0x265>
10be6e: ba e5 f6 11 00 mov $0x11f6e5,%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 ?
10be73: 8b 47 0c mov 0xc(%edi),%eax
10be76: 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)(
10be79: b8 ef f6 11 00 mov $0x11f6ef,%eax
10be7e: 8b 4d c0 mov -0x40(%ebp),%ecx
10be81: 39 4d cc cmp %ecx,-0x34(%ebp)
10be84: 74 0f je 10be95 <_Heap_Walk+0x287>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10be86: b8 0d f6 11 00 mov $0x11f60d,%eax
10be8b: 39 75 cc cmp %esi,-0x34(%ebp)
10be8e: 75 05 jne 10be95 <_Heap_Walk+0x287>
10be90: b8 ff f6 11 00 mov $0x11f6ff,%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)(
10be95: 83 ec 0c sub $0xc,%esp
10be98: 52 push %edx
10be99: ff 75 b4 pushl -0x4c(%ebp)
10be9c: 50 push %eax
10be9d: ff 75 cc pushl -0x34(%ebp)
10bea0: ff 75 e0 pushl -0x20(%ebp)
10bea3: 57 push %edi
10bea4: 68 ea f9 11 00 push $0x11f9ea
10bea9: 6a 00 push $0x0
10beab: ff 75 dc pushl -0x24(%ebp)
10beae: 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 ) {
10beb1: 8b 03 mov (%ebx),%eax
10beb3: 83 c4 30 add $0x30,%esp
10beb6: 39 45 e0 cmp %eax,-0x20(%ebp)
10beb9: 74 16 je 10bed1 <_Heap_Walk+0x2c3>
10bebb: 89 d9 mov %ebx,%ecx
10bebd: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bec0: 56 push %esi
10bec1: 51 push %ecx
10bec2: 50 push %eax
10bec3: ff 75 e0 pushl -0x20(%ebp)
10bec6: 57 push %edi
10bec7: 68 1f fa 11 00 push $0x11fa1f
10becc: e9 b4 fe ff ff jmp 10bd85 <_Heap_Walk+0x177>
);
return false;
}
if ( !prev_used ) {
10bed1: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bed5: 75 0b jne 10bee2 <_Heap_Walk+0x2d4>
10bed7: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10beda: 57 push %edi
10bedb: 68 58 fa 11 00 push $0x11fa58
10bee0: eb 19 jmp 10befb <_Heap_Walk+0x2ed>
block = next_block;
} while ( block != first_block );
return true;
}
10bee2: 8b 46 08 mov 0x8(%esi),%eax
10bee5: eb 07 jmp 10beee <_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 ) {
10bee7: 39 f8 cmp %edi,%eax
10bee9: 74 4a je 10bf35 <_Heap_Walk+0x327>
return true;
}
free_block = free_block->next;
10beeb: 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 ) {
10beee: 39 f0 cmp %esi,%eax
10bef0: 75 f5 jne 10bee7 <_Heap_Walk+0x2d9>
10bef2: 8b 5d dc mov -0x24(%ebp),%ebx
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10bef5: 57 push %edi
10bef6: 68 c3 fa 11 00 push $0x11fac3
10befb: 6a 01 push $0x1
10befd: 53 push %ebx
10befe: ff 55 e4 call *-0x1c(%ebp)
10bf01: 83 c4 10 add $0x10,%esp
10bf04: e9 85 fe ff ff jmp 10bd8e <_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) {
10bf09: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bf0d: 74 0e je 10bf1d <_Heap_Walk+0x30f>
(*printer)(
10bf0f: 83 ec 0c sub $0xc,%esp
10bf12: ff 75 e0 pushl -0x20(%ebp)
10bf15: 57 push %edi
10bf16: 68 87 fa 11 00 push $0x11fa87
10bf1b: eb 0d jmp 10bf2a <_Heap_Walk+0x31c>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
10bf1d: 51 push %ecx
10bf1e: 51 push %ecx
10bf1f: ff 37 pushl (%edi)
10bf21: ff 75 e0 pushl -0x20(%ebp)
10bf24: 57 push %edi
10bf25: 68 9e fa 11 00 push $0x11fa9e
10bf2a: 6a 00 push $0x0
10bf2c: ff 75 dc pushl -0x24(%ebp)
10bf2f: ff 55 e4 call *-0x1c(%ebp)
10bf32: 83 c4 20 add $0x20,%esp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10bf35: 3b 5d d0 cmp -0x30(%ebp),%ebx
10bf38: 0f 85 66 fe ff ff jne 10bda4 <_Heap_Walk+0x196>
return true;
10bf3e: b0 01 mov $0x1,%al
}
10bf40: 8d 65 f4 lea -0xc(%ebp),%esp
10bf43: 5b pop %ebx
10bf44: 5e pop %esi
10bf45: 5f pop %edi
10bf46: c9 leave
10bf47: c3 ret
0010b230 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10b230: 55 push %ebp
10b231: 89 e5 mov %esp,%ebp
10b233: 53 push %ebx
10b234: 83 ec 08 sub $0x8,%esp
10b237: 8b 45 08 mov 0x8(%ebp),%eax
10b23a: 8b 55 0c mov 0xc(%ebp),%edx
10b23d: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10b240: a3 7c 43 12 00 mov %eax,0x12437c
_Internal_errors_What_happened.is_internal = is_internal;
10b245: 88 15 80 43 12 00 mov %dl,0x124380
_Internal_errors_What_happened.the_error = the_error;
10b24b: 89 1d 84 43 12 00 mov %ebx,0x124384
_User_extensions_Fatal( the_source, is_internal, the_error );
10b251: 53 push %ebx
10b252: 0f b6 d2 movzbl %dl,%edx
10b255: 52 push %edx
10b256: 50 push %eax
10b257: e8 23 19 00 00 call 10cb7f <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
10b25c: c7 05 64 44 12 00 05 movl $0x5,0x124464 <== NOT EXECUTED
10b263: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10b266: fa cli <== NOT EXECUTED
10b267: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10b269: f4 hlt <== NOT EXECUTED
10b26a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b26d: eb fe jmp 10b26d <_Internal_error_Occurred+0x3d><== NOT EXECUTED
0010b2c0 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10b2c0: 55 push %ebp
10b2c1: 89 e5 mov %esp,%ebp
10b2c3: 56 push %esi
10b2c4: 53 push %ebx
10b2c5: 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;
10b2c8: 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 )
10b2ca: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
10b2ce: 74 53 je 10b323 <_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 );
10b2d0: 8d 73 20 lea 0x20(%ebx),%esi
10b2d3: 83 ec 0c sub $0xc,%esp
10b2d6: 56 push %esi
10b2d7: e8 30 f7 ff ff call 10aa0c <_Chain_Get>
10b2dc: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10b2de: 83 c4 10 add $0x10,%esp
10b2e1: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10b2e5: 74 3c je 10b323 <_Objects_Allocate+0x63>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10b2e7: 85 c0 test %eax,%eax
10b2e9: 75 1a jne 10b305 <_Objects_Allocate+0x45>
_Objects_Extend_information( information );
10b2eb: 83 ec 0c sub $0xc,%esp
10b2ee: 53 push %ebx
10b2ef: e8 60 00 00 00 call 10b354 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10b2f4: 89 34 24 mov %esi,(%esp)
10b2f7: e8 10 f7 ff ff call 10aa0c <_Chain_Get>
10b2fc: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10b2fe: 83 c4 10 add $0x10,%esp
10b301: 85 c0 test %eax,%eax
10b303: 74 1e je 10b323 <_Objects_Allocate+0x63>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
10b305: 0f b7 41 08 movzwl 0x8(%ecx),%eax
10b309: 0f b7 53 08 movzwl 0x8(%ebx),%edx
10b30d: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
10b30f: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10b313: 31 d2 xor %edx,%edx
10b315: f7 f6 div %esi
information->inactive_per_block[ block ]--;
10b317: c1 e0 02 shl $0x2,%eax
10b31a: 03 43 30 add 0x30(%ebx),%eax
10b31d: ff 08 decl (%eax)
information->inactive--;
10b31f: 66 ff 4b 2c decw 0x2c(%ebx)
);
}
#endif
return the_object;
}
10b323: 89 c8 mov %ecx,%eax
10b325: 8d 65 f8 lea -0x8(%ebp),%esp
10b328: 5b pop %ebx
10b329: 5e pop %esi
10b32a: c9 leave
10b32b: c3 ret
0010b648 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
10b648: 55 push %ebp
10b649: 89 e5 mov %esp,%ebp
10b64b: 57 push %edi
10b64c: 56 push %esi
10b64d: 53 push %ebx
10b64e: 83 ec 0c sub $0xc,%esp
10b651: 8b 75 08 mov 0x8(%ebp),%esi
10b654: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
10b657: 31 db xor %ebx,%ebx
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10b659: 66 85 ff test %di,%di
10b65c: 74 37 je 10b695 <_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 );
10b65e: 83 ec 0c sub $0xc,%esp
10b661: 56 push %esi
10b662: e8 b1 40 00 00 call 10f718 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10b667: 83 c4 10 add $0x10,%esp
10b66a: 85 c0 test %eax,%eax
10b66c: 74 27 je 10b695 <_Objects_Get_information+0x4d>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10b66e: 0f b7 ff movzwl %di,%edi
10b671: 39 c7 cmp %eax,%edi
10b673: 77 20 ja 10b695 <_Objects_Get_information+0x4d>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10b675: 8b 04 b5 bc 42 12 00 mov 0x1242bc(,%esi,4),%eax
10b67c: 85 c0 test %eax,%eax
10b67e: 74 15 je 10b695 <_Objects_Get_information+0x4d><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10b680: 8b 1c b8 mov (%eax,%edi,4),%ebx
if ( !info )
10b683: 85 db test %ebx,%ebx
10b685: 74 0e je 10b695 <_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;
10b687: 31 c0 xor %eax,%eax
10b689: 66 83 7b 10 00 cmpw $0x0,0x10(%ebx)
10b68e: 0f 95 c0 setne %al
10b691: f7 d8 neg %eax
10b693: 21 c3 and %eax,%ebx
#endif
return info;
}
10b695: 89 d8 mov %ebx,%eax
10b697: 8d 65 f4 lea -0xc(%ebp),%esp
10b69a: 5b pop %ebx
10b69b: 5e pop %esi
10b69c: 5f pop %edi
10b69d: c9 leave
10b69e: c3 ret
00118abc <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
118abc: 55 push %ebp
118abd: 89 e5 mov %esp,%ebp
118abf: 53 push %ebx
118ac0: 8b 55 08 mov 0x8(%ebp),%edx
118ac3: 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;
118ac6: b8 01 00 00 00 mov $0x1,%eax
118acb: 2b 42 08 sub 0x8(%edx),%eax
118ace: 03 45 0c add 0xc(%ebp),%eax
if ( information->maximum >= index ) {
118ad1: 0f b7 5a 10 movzwl 0x10(%edx),%ebx
118ad5: 39 c3 cmp %eax,%ebx
118ad7: 72 12 jb 118aeb <_Objects_Get_no_protection+0x2f>
if ( (the_object = information->local_table[ index ]) != NULL ) {
118ad9: 8b 52 1c mov 0x1c(%edx),%edx
118adc: 8b 04 82 mov (%edx,%eax,4),%eax
118adf: 85 c0 test %eax,%eax
118ae1: 74 08 je 118aeb <_Objects_Get_no_protection+0x2f><== NEVER TAKEN
*location = OBJECTS_LOCAL;
118ae3: c7 01 00 00 00 00 movl $0x0,(%ecx)
return the_object;
118ae9: eb 08 jmp 118af3 <_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;
118aeb: c7 01 01 00 00 00 movl $0x1,(%ecx)
return NULL;
118af1: 31 c0 xor %eax,%eax
}
118af3: 5b pop %ebx
118af4: c9 leave
118af5: c3 ret
0010c874 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10c874: 55 push %ebp
10c875: 89 e5 mov %esp,%ebp
10c877: 53 push %ebx
10c878: 83 ec 14 sub $0x14,%esp
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10c87b: 8b 45 08 mov 0x8(%ebp),%eax
10c87e: 85 c0 test %eax,%eax
10c880: 75 08 jne 10c88a <_Objects_Id_to_name+0x16>
10c882: a1 80 78 12 00 mov 0x127880,%eax
10c887: 8b 40 08 mov 0x8(%eax),%eax
10c88a: 89 c2 mov %eax,%edx
10c88c: c1 ea 18 shr $0x18,%edx
10c88f: 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 )
10c892: 8d 4a ff lea -0x1(%edx),%ecx
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
10c895: bb 03 00 00 00 mov $0x3,%ebx
10c89a: 83 f9 02 cmp $0x2,%ecx
10c89d: 77 36 ja 10c8d5 <_Objects_Id_to_name+0x61>
10c89f: eb 3b jmp 10c8dc <_Objects_Id_to_name+0x68>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10c8a1: 89 c1 mov %eax,%ecx
10c8a3: 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 ];
10c8a6: 8b 14 8a mov (%edx,%ecx,4),%edx
if ( !information )
10c8a9: 85 d2 test %edx,%edx
10c8ab: 74 28 je 10c8d5 <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
10c8ad: 80 7a 38 00 cmpb $0x0,0x38(%edx)
10c8b1: 75 22 jne 10c8d5 <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
10c8b3: 51 push %ecx
10c8b4: 8d 4d f4 lea -0xc(%ebp),%ecx
10c8b7: 51 push %ecx
10c8b8: 50 push %eax
10c8b9: 52 push %edx
10c8ba: e8 5d ff ff ff call 10c81c <_Objects_Get>
if ( !the_object )
10c8bf: 83 c4 10 add $0x10,%esp
10c8c2: 85 c0 test %eax,%eax
10c8c4: 74 0f je 10c8d5 <_Objects_Id_to_name+0x61>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10c8c6: 8b 50 0c mov 0xc(%eax),%edx
10c8c9: 8b 45 0c mov 0xc(%ebp),%eax
10c8cc: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10c8ce: e8 9f 07 00 00 call 10d072 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10c8d3: 31 db xor %ebx,%ebx
}
10c8d5: 89 d8 mov %ebx,%eax
10c8d7: 8b 5d fc mov -0x4(%ebp),%ebx
10c8da: c9 leave
10c8db: 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 ] )
10c8dc: 8b 14 95 08 73 12 00 mov 0x127308(,%edx,4),%edx
10c8e3: 85 d2 test %edx,%edx
10c8e5: 75 ba jne 10c8a1 <_Objects_Id_to_name+0x2d>
10c8e7: eb ec jmp 10c8d5 <_Objects_Id_to_name+0x61>
0010e2b8 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10e2b8: 55 push %ebp
10e2b9: 89 e5 mov %esp,%ebp
10e2bb: 57 push %edi
10e2bc: 56 push %esi
10e2bd: 53 push %ebx
10e2be: 83 ec 30 sub $0x30,%esp
10e2c1: 8b 75 08 mov 0x8(%ebp),%esi
10e2c4: 8b 5d 14 mov 0x14(%ebp),%ebx
10e2c7: 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 );
10e2ca: 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(
10e2cd: 50 push %eax
10e2ce: 56 push %esi
10e2cf: 68 7c d9 12 00 push $0x12d97c
10e2d4: 88 55 d4 mov %dl,-0x2c(%ebp)
10e2d7: e8 f0 2a 00 00 call 110dcc <_Objects_Get>
switch ( location ) {
10e2dc: 83 c4 10 add $0x10,%esp
10e2df: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10e2e3: 8a 55 d4 mov -0x2c(%ebp),%dl
10e2e6: 0f 85 aa 00 00 00 jne 10e396 <_POSIX_Message_queue_Receive_support+0xde>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
10e2ec: 8b 78 14 mov 0x14(%eax),%edi
10e2ef: 89 f9 mov %edi,%ecx
10e2f1: 83 e1 03 and $0x3,%ecx
10e2f4: 49 dec %ecx
10e2f5: 75 0a jne 10e301 <_POSIX_Message_queue_Receive_support+0x49>
_Thread_Enable_dispatch();
10e2f7: e8 22 33 00 00 call 11161e <_Thread_Enable_dispatch>
10e2fc: e9 95 00 00 00 jmp 10e396 <_POSIX_Message_queue_Receive_support+0xde>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10e301: 8b 40 10 mov 0x10(%eax),%eax
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
10e304: 8b 48 68 mov 0x68(%eax),%ecx
10e307: 39 4d 10 cmp %ecx,0x10(%ebp)
10e30a: 73 15 jae 10e321 <_POSIX_Message_queue_Receive_support+0x69>
_Thread_Enable_dispatch();
10e30c: e8 0d 33 00 00 call 11161e <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
10e311: e8 be 8a 00 00 call 116dd4 <__errno>
10e316: c7 00 7a 00 00 00 movl $0x7a,(%eax)
10e31c: e9 80 00 00 00 jmp 10e3a1 <_POSIX_Message_queue_Receive_support+0xe9>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
10e321: 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 )
10e328: 31 c9 xor %ecx,%ecx
10e32a: 84 d2 test %dl,%dl
10e32c: 74 09 je 10e337 <_POSIX_Message_queue_Receive_support+0x7f><== NEVER TAKEN
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
10e32e: 81 e7 00 40 00 00 and $0x4000,%edi
10e334: 0f 94 c1 sete %cl
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
10e337: 52 push %edx
10e338: 52 push %edx
10e339: ff 75 1c pushl 0x1c(%ebp)
10e33c: 0f b6 c9 movzbl %cl,%ecx
10e33f: 51 push %ecx
10e340: 8d 55 e0 lea -0x20(%ebp),%edx
10e343: 52 push %edx
10e344: ff 75 0c pushl 0xc(%ebp)
10e347: 56 push %esi
10e348: 83 c0 1c add $0x1c,%eax
10e34b: 50 push %eax
10e34c: e8 73 1c 00 00 call 10ffc4 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
10e351: 83 c4 20 add $0x20,%esp
10e354: e8 c5 32 00 00 call 11161e <_Thread_Enable_dispatch>
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
10e359: a1 f4 d9 12 00 mov 0x12d9f4,%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);
10e35e: 8b 50 24 mov 0x24(%eax),%edx
10e361: c1 fa 1f sar $0x1f,%edx
10e364: 8b 48 24 mov 0x24(%eax),%ecx
10e367: 31 d1 xor %edx,%ecx
10e369: 89 0b mov %ecx,(%ebx)
10e36b: 29 13 sub %edx,(%ebx)
if ( !_Thread_Executing->Wait.return_code )
10e36d: 83 78 34 00 cmpl $0x0,0x34(%eax)
10e371: 75 05 jne 10e378 <_POSIX_Message_queue_Receive_support+0xc0>
return length_out;
10e373: 8b 45 e0 mov -0x20(%ebp),%eax
10e376: eb 2c jmp 10e3a4 <_POSIX_Message_queue_Receive_support+0xec>
rtems_set_errno_and_return_minus_one(
10e378: e8 57 8a 00 00 call 116dd4 <__errno>
10e37d: 89 c3 mov %eax,%ebx
10e37f: 83 ec 0c sub $0xc,%esp
10e382: a1 f4 d9 12 00 mov 0x12d9f4,%eax
10e387: ff 70 34 pushl 0x34(%eax)
10e38a: e8 ed 01 00 00 call 10e57c <_POSIX_Message_queue_Translate_core_message_queue_return_code>
10e38f: 89 03 mov %eax,(%ebx)
10e391: 83 c4 10 add $0x10,%esp
10e394: eb 0b jmp 10e3a1 <_POSIX_Message_queue_Receive_support+0xe9>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10e396: e8 39 8a 00 00 call 116dd4 <__errno>
10e39b: c7 00 09 00 00 00 movl $0x9,(%eax)
10e3a1: 83 c8 ff or $0xffffffff,%eax
}
10e3a4: 8d 65 f4 lea -0xc(%ebp),%esp
10e3a7: 5b pop %ebx
10e3a8: 5e pop %esi
10e3a9: 5f pop %edi
10e3aa: c9 leave
10e3ab: c3 ret
0010e86c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
10e86c: 55 push %ebp
10e86d: 89 e5 mov %esp,%ebp
10e86f: 83 ec 08 sub $0x8,%esp
10e872: 8b 55 08 mov 0x8(%ebp),%edx
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
10e875: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
10e87b: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax)
10e882: 75 2c jne 10e8b0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NEVER TAKEN
10e884: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax)
10e88b: 75 23 jne 10e8b0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44>
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
10e88d: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax)
10e894: 74 1a je 10e8b0 <_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;
10e896: a1 d4 52 12 00 mov 0x1252d4,%eax
10e89b: 48 dec %eax
10e89c: a3 d4 52 12 00 mov %eax,0x1252d4
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
10e8a1: 50 push %eax
10e8a2: 50 push %eax
10e8a3: 6a ff push $0xffffffff
10e8a5: 52 push %edx
10e8a6: e8 51 08 00 00 call 10f0fc <_POSIX_Thread_Exit>
10e8ab: 83 c4 10 add $0x10,%esp
} else
_Thread_Enable_dispatch();
}
10e8ae: c9 leave
10e8af: c3 ret
10e8b0: 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();
10e8b1: e9 c0 d9 ff ff jmp 10c276 <_Thread_Enable_dispatch>
0010faf0 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
10faf0: 55 push %ebp
10faf1: 89 e5 mov %esp,%ebp
10faf3: 57 push %edi
10faf4: 56 push %esi
10faf5: 53 push %ebx
10faf6: 83 ec 28 sub $0x28,%esp
10faf9: 8b 55 08 mov 0x8(%ebp),%edx
10fafc: 8b 5d 0c mov 0xc(%ebp),%ebx
10faff: 8b 7d 10 mov 0x10(%ebp),%edi
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
10fb02: ff 33 pushl (%ebx)
10fb04: 89 55 e0 mov %edx,-0x20(%ebp)
10fb07: e8 c4 ff ff ff call 10fad0 <_POSIX_Priority_Is_valid>
10fb0c: 83 c4 10 add $0x10,%esp
return EINVAL;
10fb0f: 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 ) )
10fb14: 84 c0 test %al,%al
10fb16: 8b 55 e0 mov -0x20(%ebp),%edx
10fb19: 0f 84 a4 00 00 00 je 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
10fb1f: c7 07 00 00 00 00 movl $0x0,(%edi)
*budget_callout = NULL;
10fb25: 8b 45 14 mov 0x14(%ebp),%eax
10fb28: c7 00 00 00 00 00 movl $0x0,(%eax)
if ( policy == SCHED_OTHER ) {
10fb2e: 85 d2 test %edx,%edx
10fb30: 75 0b jne 10fb3d <_POSIX_Thread_Translate_sched_param+0x4d>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
10fb32: c7 07 01 00 00 00 movl $0x1,(%edi)
10fb38: e9 83 00 00 00 jmp 10fbc0 <_POSIX_Thread_Translate_sched_param+0xd0>
return 0;
}
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
10fb3d: 31 f6 xor %esi,%esi
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
10fb3f: 83 fa 01 cmp $0x1,%edx
10fb42: 74 7f je 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
10fb44: 83 fa 02 cmp $0x2,%edx
10fb47: 75 08 jne 10fb51 <_POSIX_Thread_Translate_sched_param+0x61>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
10fb49: c7 07 02 00 00 00 movl $0x2,(%edi)
return 0;
10fb4f: eb 72 jmp 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
10fb51: 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 ) {
10fb56: 83 fa 04 cmp $0x4,%edx
10fb59: 75 68 jne 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3>
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
10fb5b: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10fb5f: 75 06 jne 10fb67 <_POSIX_Thread_Translate_sched_param+0x77>
10fb61: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10fb65: 74 5c je 10fbc3 <_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) &&
10fb67: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10fb6b: 75 0b jne 10fb78 <_POSIX_Thread_Translate_sched_param+0x88>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
10fb6d: 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) &&
10fb72: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fb76: 74 4b je 10fbc3 <_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 ) <
10fb78: 83 ec 0c sub $0xc,%esp
10fb7b: 8d 43 08 lea 0x8(%ebx),%eax
10fb7e: 50 push %eax
10fb7f: e8 14 de ff ff call 10d998 <_Timespec_To_ticks>
10fb84: 89 45 e4 mov %eax,-0x1c(%ebp)
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
10fb87: 8d 43 10 lea 0x10(%ebx),%eax
10fb8a: 89 04 24 mov %eax,(%esp)
10fb8d: e8 06 de ff ff call 10d998 <_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 ) <
10fb92: 83 c4 10 add $0x10,%esp
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
10fb95: 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 ) <
10fb9a: 39 45 e4 cmp %eax,-0x1c(%ebp)
10fb9d: 72 24 jb 10fbc3 <_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 ) )
10fb9f: 83 ec 0c sub $0xc,%esp
10fba2: ff 73 04 pushl 0x4(%ebx)
10fba5: e8 26 ff ff ff call 10fad0 <_POSIX_Priority_Is_valid>
10fbaa: 83 c4 10 add $0x10,%esp
10fbad: 84 c0 test %al,%al
10fbaf: 74 12 je 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
10fbb1: c7 07 03 00 00 00 movl $0x3,(%edi)
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
10fbb7: 8b 45 14 mov 0x14(%ebp),%eax
10fbba: c7 00 e9 a7 10 00 movl $0x10a7e9,(%eax)
return 0;
10fbc0: 66 31 f6 xor %si,%si
}
return EINVAL;
}
10fbc3: 89 f0 mov %esi,%eax
10fbc5: 8d 65 f4 lea -0xc(%ebp),%esp
10fbc8: 5b pop %ebx
10fbc9: 5e pop %esi
10fbca: 5f pop %edi
10fbcb: c9 leave
10fbcc: c3 ret
0010a4ec <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
10a4ec: 55 push %ebp
10a4ed: 89 e5 mov %esp,%ebp
10a4ef: 57 push %edi
10a4f0: 56 push %esi
10a4f1: 53 push %ebx
10a4f2: 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;
10a4f5: 8b 3d 10 12 12 00 mov 0x121210,%edi
maximum = Configuration_POSIX_API.number_of_initialization_threads;
10a4fb: 8b 15 0c 12 12 00 mov 0x12120c,%edx
if ( !user_threads || maximum == 0 )
10a501: 85 d2 test %edx,%edx
10a503: 74 54 je 10a559 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a505: 85 ff test %edi,%edi
10a507: 74 50 je 10a559 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a509: 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 );
10a50b: 8d 75 a4 lea -0x5c(%ebp),%esi
10a50e: 83 ec 0c sub $0xc,%esp
10a511: 56 push %esi
10a512: 89 55 94 mov %edx,-0x6c(%ebp)
10a515: e8 b6 56 00 00 call 10fbd0 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
10a51a: 5a pop %edx
10a51b: 59 pop %ecx
10a51c: 6a 02 push $0x2
10a51e: 56 push %esi
10a51f: e8 d4 56 00 00 call 10fbf8 <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
10a524: 59 pop %ecx
10a525: 58 pop %eax
10a526: ff 74 df 04 pushl 0x4(%edi,%ebx,8)
10a52a: 56 push %esi
10a52b: e8 f4 56 00 00 call 10fc24 <pthread_attr_setstacksize>
status = pthread_create(
10a530: 6a 00 push $0x0
10a532: ff 34 df pushl (%edi,%ebx,8)
10a535: 56 push %esi
10a536: 8d 45 e4 lea -0x1c(%ebp),%eax
10a539: 50 push %eax
10a53a: e8 e5 fc ff ff call 10a224 <pthread_create>
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
10a53f: 83 c4 20 add $0x20,%esp
10a542: 85 c0 test %eax,%eax
10a544: 8b 55 94 mov -0x6c(%ebp),%edx
10a547: 74 0b je 10a554 <_POSIX_Threads_Initialize_user_threads_body+0x68>
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
10a549: 52 push %edx
10a54a: 50 push %eax
10a54b: 6a 01 push $0x1
10a54d: 6a 02 push $0x2
10a54f: e8 e4 1b 00 00 call 10c138 <_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++ ) {
10a554: 43 inc %ebx
10a555: 39 d3 cmp %edx,%ebx
10a557: 72 b5 jb 10a50e <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
10a559: 8d 65 f4 lea -0xc(%ebp),%esp
10a55c: 5b pop %ebx
10a55d: 5e pop %esi
10a55e: 5f pop %edi
10a55f: c9 leave
10a560: c3 ret
0010ec4f <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
10ec4f: 55 push %ebp
10ec50: 89 e5 mov %esp,%ebp
10ec52: 56 push %esi
10ec53: 53 push %ebx
10ec54: 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 ];
10ec57: 8b b3 f8 00 00 00 mov 0xf8(%ebx),%esi
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
10ec5d: 83 ec 0c sub $0xc,%esp
10ec60: 8d 86 98 00 00 00 lea 0x98(%esi),%eax
10ec66: 50 push %eax
10ec67: e8 94 0e 00 00 call 10fb00 <_Timespec_To_ticks>
the_thread->cpu_time_budget = ticks;
10ec6c: 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);
10ec6f: 0f b6 05 f4 01 12 00 movzbl 0x1201f4,%eax
10ec76: 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;
10ec7c: 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 ) {
10ec7f: 83 c4 10 add $0x10,%esp
10ec82: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx)
10ec86: 75 12 jne 10ec9a <_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 ) {
10ec88: 39 43 14 cmp %eax,0x14(%ebx)
10ec8b: 76 0d jbe 10ec9a <_POSIX_Threads_Sporadic_budget_TSR+0x4b>
_Thread_Change_priority( the_thread, new_priority, true );
10ec8d: 52 push %edx
10ec8e: 6a 01 push $0x1
10ec90: 50 push %eax
10ec91: 53 push %ebx
10ec92: e8 a5 cd ff ff call 10ba3c <_Thread_Change_priority>
10ec97: 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 );
10ec9a: 83 ec 0c sub $0xc,%esp
10ec9d: 8d 86 90 00 00 00 lea 0x90(%esi),%eax
10eca3: 50 push %eax
10eca4: e8 57 0e 00 00 call 10fb00 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10eca9: 89 86 b4 00 00 00 mov %eax,0xb4(%esi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10ecaf: 83 c4 10 add $0x10,%esp
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
10ecb2: 81 c6 a8 00 00 00 add $0xa8,%esi
10ecb8: 89 75 0c mov %esi,0xc(%ebp)
10ecbb: c7 45 08 ac 43 12 00 movl $0x1243ac,0x8(%ebp)
}
10ecc2: 8d 65 f8 lea -0x8(%ebp),%esp
10ecc5: 5b pop %ebx
10ecc6: 5e pop %esi
10ecc7: c9 leave
10ecc8: e9 d3 df ff ff jmp 10cca0 <_Watchdog_Insert>
0010eccd <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
10eccd: 55 push %ebp
10ecce: 89 e5 mov %esp,%ebp
10ecd0: 83 ec 08 sub $0x8,%esp
10ecd3: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10ecd6: 8b 88 f8 00 00 00 mov 0xf8(%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 */
10ecdc: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax)
10ece3: 0f b6 15 f4 01 12 00 movzbl 0x1201f4,%edx
10ecea: 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;
10ecf0: 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 ) {
10ecf3: 83 78 1c 00 cmpl $0x0,0x1c(%eax)
10ecf7: 75 12 jne 10ed0b <_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 ) {
10ecf9: 39 50 14 cmp %edx,0x14(%eax)
10ecfc: 73 0d jae 10ed0b <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN
_Thread_Change_priority( the_thread, new_priority, true );
10ecfe: 51 push %ecx
10ecff: 6a 01 push $0x1
10ed01: 52 push %edx
10ed02: 50 push %eax
10ed03: e8 34 cd ff ff call 10ba3c <_Thread_Change_priority>
10ed08: 83 c4 10 add $0x10,%esp
#if 0
printk( "lower priority\n" );
#endif
}
}
}
10ed0b: c9 leave
10ed0c: c3 ret
0010a2ac <_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)
{
10a2ac: 55 push %ebp
10a2ad: 89 e5 mov %esp,%ebp
10a2af: 53 push %ebx
10a2b0: 83 ec 04 sub $0x4,%esp
10a2b3: 8b 5d 0c mov 0xc(%ebp),%ebx
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
10a2b6: ff 43 68 incl 0x68(%ebx)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
10a2b9: 83 7b 54 00 cmpl $0x0,0x54(%ebx)
10a2bd: 75 06 jne 10a2c5 <_POSIX_Timer_TSR+0x19>
10a2bf: 83 7b 58 00 cmpl $0x0,0x58(%ebx)
10a2c3: 74 34 je 10a2f9 <_POSIX_Timer_TSR+0x4d> <== NEVER TAKEN
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
10a2c5: 83 ec 0c sub $0xc,%esp
10a2c8: 53 push %ebx
10a2c9: 68 ac a2 10 00 push $0x10a2ac
10a2ce: ff 73 08 pushl 0x8(%ebx)
10a2d1: ff 73 64 pushl 0x64(%ebx)
10a2d4: 8d 43 10 lea 0x10(%ebx),%eax
10a2d7: 50 push %eax
10a2d8: e8 d3 55 00 00 call 10f8b0 <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
10a2dd: 83 c4 20 add $0x20,%esp
10a2e0: 84 c0 test %al,%al
10a2e2: 74 30 je 10a314 <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
10a2e4: 83 ec 0c sub $0xc,%esp
10a2e7: 8d 43 6c lea 0x6c(%ebx),%eax
10a2ea: 50 push %eax
10a2eb: e8 50 14 00 00 call 10b740 <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a2f0: c6 43 3c 03 movb $0x3,0x3c(%ebx)
10a2f4: 83 c4 10 add $0x10,%esp
10a2f7: eb 04 jmp 10a2fd <_POSIX_Timer_TSR+0x51>
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a2f9: 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 ) ) {
10a2fd: 50 push %eax
10a2fe: 50 push %eax
10a2ff: ff 73 44 pushl 0x44(%ebx)
10a302: ff 73 38 pushl 0x38(%ebx)
10a305: e8 7a 51 00 00 call 10f484 <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
10a30a: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
10a311: 83 c4 10 add $0x10,%esp
}
10a314: 8b 5d fc mov -0x4(%ebp),%ebx
10a317: c9 leave
10a318: c3 ret
00110ac8 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
110ac8: 55 push %ebp
110ac9: 89 e5 mov %esp,%ebp
110acb: 57 push %edi
110acc: 56 push %esi
110acd: 53 push %ebx
110ace: 83 ec 68 sub $0x68,%esp
110ad1: 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,
110ad4: 6a 01 push $0x1
110ad6: 0f b6 45 10 movzbl 0x10(%ebp),%eax
110ada: 50 push %eax
110adb: 8d 45 dc lea -0x24(%ebp),%eax
110ade: 50 push %eax
110adf: 53 push %ebx
110ae0: ff 75 08 pushl 0x8(%ebp)
110ae3: e8 8c 00 00 00 call 110b74 <_POSIX_signals_Clear_signals>
110ae8: 83 c4 20 add $0x20,%esp
is_global, true ) )
return false;
110aeb: 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,
110aed: 84 c0 test %al,%al
110aef: 74 78 je 110b69 <_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 )
110af1: 6b d3 0c imul $0xc,%ebx,%edx
110af4: 8b 82 4c 48 12 00 mov 0x12484c(%edx),%eax
110afa: 83 f8 01 cmp $0x1,%eax
110afd: 74 6a je 110b69 <_POSIX_signals_Check_signal+0xa1><== NEVER TAKEN
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
110aff: 8b 4d 08 mov 0x8(%ebp),%ecx
110b02: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx
110b08: 89 4d a4 mov %ecx,-0x5c(%ebp)
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
110b0b: 0b 8a 48 48 12 00 or 0x124848(%edx),%ecx
110b11: 8b 75 08 mov 0x8(%ebp),%esi
110b14: 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,
110b1a: 8d 7d b4 lea -0x4c(%ebp),%edi
110b1d: 8b 35 34 48 12 00 mov 0x124834,%esi
110b23: 83 c6 20 add $0x20,%esi
110b26: b9 0a 00 00 00 mov $0xa,%ecx
110b2b: 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 ) {
110b2d: 83 ba 44 48 12 00 02 cmpl $0x2,0x124844(%edx)
110b34: 75 09 jne 110b3f <_POSIX_signals_Check_signal+0x77>
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
110b36: 52 push %edx
110b37: 6a 00 push $0x0
110b39: 8d 55 dc lea -0x24(%ebp),%edx
110b3c: 52 push %edx
110b3d: eb 03 jmp 110b42 <_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 );
110b3f: 83 ec 0c sub $0xc,%esp
110b42: 53 push %ebx
110b43: ff d0 call *%eax
break;
110b45: 83 c4 10 add $0x10,%esp
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
110b48: 8b 3d 34 48 12 00 mov 0x124834,%edi
110b4e: 83 c7 20 add $0x20,%edi
110b51: 8d 75 b4 lea -0x4c(%ebp),%esi
110b54: b9 0a 00 00 00 mov $0xa,%ecx
110b59: 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;
110b5b: 8b 75 a4 mov -0x5c(%ebp),%esi
110b5e: 8b 4d 08 mov 0x8(%ebp),%ecx
110b61: 89 b1 d0 00 00 00 mov %esi,0xd0(%ecx)
return true;
110b67: b1 01 mov $0x1,%cl
}
110b69: 88 c8 mov %cl,%al
110b6b: 8d 65 f4 lea -0xc(%ebp),%esp
110b6e: 5b pop %ebx
110b6f: 5e pop %esi
110b70: 5f pop %edi
110b71: c9 leave
110b72: c3 ret
0011105c <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
11105c: 55 push %ebp
11105d: 89 e5 mov %esp,%ebp
11105f: 53 push %ebx
111060: 8b 4d 08 mov 0x8(%ebp),%ecx
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
111063: 9c pushf
111064: fa cli
111065: 5a pop %edx
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
111066: 6b c1 0c imul $0xc,%ecx,%eax
111069: 83 b8 44 48 12 00 02 cmpl $0x2,0x124844(%eax)
111070: 75 0e jne 111080 <_POSIX_signals_Clear_process_signals+0x24>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
111072: 8d 98 40 4a 12 00 lea 0x124a40(%eax),%ebx
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
111078: 39 98 3c 4a 12 00 cmp %ebx,0x124a3c(%eax)
11107e: 75 0e jne 11108e <_POSIX_signals_Clear_process_signals+0x32><== NEVER TAKEN
111080: 49 dec %ecx
111081: b8 fe ff ff ff mov $0xfffffffe,%eax
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
111086: d3 c0 rol %cl,%eax
111088: 21 05 38 4a 12 00 and %eax,0x124a38
}
_ISR_Enable( level );
11108e: 52 push %edx
11108f: 9d popf
}
111090: 5b pop %ebx
111091: c9 leave
111092: c3 ret
0010ab64 <_POSIX_signals_Get_lowest>:
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
10ab64: 55 push %ebp
10ab65: 89 e5 mov %esp,%ebp
10ab67: 56 push %esi
10ab68: 53 push %ebx
10ab69: 8b 55 08 mov 0x8(%ebp),%edx
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10ab6c: b8 1b 00 00 00 mov $0x1b,%eax
10ab71: 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(
10ab76: 8d 48 ff lea -0x1(%eax),%ecx
10ab79: 89 de mov %ebx,%esi
10ab7b: d3 e6 shl %cl,%esi
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
10ab7d: 85 d6 test %edx,%esi
10ab7f: 75 1e jne 10ab9f <_POSIX_signals_Get_lowest+0x3b><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10ab81: 40 inc %eax
10ab82: 83 f8 20 cmp $0x20,%eax
10ab85: 75 ef jne 10ab76 <_POSIX_signals_Get_lowest+0x12>
10ab87: b0 01 mov $0x1,%al
10ab89: 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(
10ab8e: 8d 48 ff lea -0x1(%eax),%ecx
10ab91: 89 de mov %ebx,%esi
10ab93: 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 ) ) {
10ab95: 85 d6 test %edx,%esi
10ab97: 75 06 jne 10ab9f <_POSIX_signals_Get_lowest+0x3b>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
10ab99: 40 inc %eax
10ab9a: 83 f8 1b cmp $0x1b,%eax
10ab9d: 75 ef jne 10ab8e <_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;
}
10ab9f: 5b pop %ebx
10aba0: 5e pop %esi
10aba1: c9 leave
10aba2: c3 ret
00121868 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
121868: 55 push %ebp
121869: 89 e5 mov %esp,%ebp
12186b: 57 push %edi
12186c: 56 push %esi
12186d: 53 push %ebx
12186e: 83 ec 0c sub $0xc,%esp
121871: 8b 5d 08 mov 0x8(%ebp),%ebx
121874: 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 ];
121877: 8b 83 f8 00 00 00 mov 0xf8(%ebx),%eax
12187d: 8d 4e ff lea -0x1(%esi),%ecx
121880: ba 01 00 00 00 mov $0x1,%edx
121885: d3 e2 shl %cl,%edx
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
121887: 8b 4b 10 mov 0x10(%ebx),%ecx
12188a: 89 cf mov %ecx,%edi
12188c: 81 e7 00 80 00 10 and $0x10008000,%edi
121892: 81 ff 00 80 00 10 cmp $0x10008000,%edi
121898: 75 58 jne 1218f2 <_POSIX_signals_Unblock_thread+0x8a>
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
12189a: 85 53 30 test %edx,0x30(%ebx)
12189d: 75 12 jne 1218b1 <_POSIX_signals_Unblock_thread+0x49>
12189f: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
1218a5: f7 d0 not %eax
/*
* This should only be reached via pthread_kill().
*/
return false;
1218a7: 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) ) {
1218a9: 85 c2 test %eax,%edx
1218ab: 0f 84 b0 00 00 00 je 121961 <_POSIX_signals_Unblock_thread+0xf9>
the_thread->Wait.return_code = EINTR;
1218b1: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
1218b8: 8b 43 28 mov 0x28(%ebx),%eax
if ( !info ) {
1218bb: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
1218bf: 75 12 jne 1218d3 <_POSIX_signals_Unblock_thread+0x6b>
the_info->si_signo = signo;
1218c1: 89 30 mov %esi,(%eax)
the_info->si_code = SI_USER;
1218c3: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_info->si_value.sival_int = 0;
1218ca: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
1218d1: eb 0c jmp 1218df <_POSIX_signals_Unblock_thread+0x77>
} else {
*the_info = *info;
1218d3: b9 03 00 00 00 mov $0x3,%ecx
1218d8: 89 c7 mov %eax,%edi
1218da: 8b 75 10 mov 0x10(%ebp),%esi
1218dd: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
_Thread_queue_Extract_with_proxy( the_thread );
1218df: 83 ec 0c sub $0xc,%esp
1218e2: 53 push %ebx
1218e3: e8 0c f4 fe ff call 110cf4 <_Thread_queue_Extract_with_proxy>
return true;
1218e8: 83 c4 10 add $0x10,%esp
1218eb: bf 01 00 00 00 mov $0x1,%edi
1218f0: eb 6f jmp 121961 <_POSIX_signals_Unblock_thread+0xf9>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
1218f2: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
1218f8: 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;
1218fa: 31 ff xor %edi,%edi
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
1218fc: 85 c2 test %eax,%edx
1218fe: 74 61 je 121961 <_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 ) ) {
121900: f7 c1 00 00 00 10 test $0x10000000,%ecx
121906: 74 3d je 121945 <_POSIX_signals_Unblock_thread+0xdd>
the_thread->Wait.return_code = EINTR;
121908: 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) )
12190f: f7 c1 e0 be 03 00 test $0x3bee0,%ecx
121915: 74 0b je 121922 <_POSIX_signals_Unblock_thread+0xba>
_Thread_queue_Extract_with_proxy( the_thread );
121917: 83 ec 0c sub $0xc,%esp
12191a: 53 push %ebx
12191b: e8 d4 f3 fe ff call 110cf4 <_Thread_queue_Extract_with_proxy>
121920: eb 1e jmp 121940 <_POSIX_signals_Unblock_thread+0xd8>
else if ( _States_Is_delaying(the_thread->current_state) ) {
121922: 80 e1 08 and $0x8,%cl
121925: 74 3a je 121961 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
121927: 83 ec 0c sub $0xc,%esp
12192a: 8d 43 48 lea 0x48(%ebx),%eax
12192d: 50 push %eax
12192e: e8 4d fc fe ff call 111580 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
121933: 58 pop %eax
121934: 5a pop %edx
121935: 68 f8 ff 03 10 push $0x1003fff8
12193a: 53 push %ebx
12193b: e8 e4 e9 fe ff call 110324 <_Thread_Clear_state>
121940: 83 c4 10 add $0x10,%esp
121943: eb 1c jmp 121961 <_POSIX_signals_Unblock_thread+0xf9>
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
121945: 85 c9 test %ecx,%ecx
121947: 75 18 jne 121961 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
121949: 83 3d a4 a9 12 00 00 cmpl $0x0,0x12a9a4
121950: 74 0f je 121961 <_POSIX_signals_Unblock_thread+0xf9>
121952: 3b 1d a8 a9 12 00 cmp 0x12a9a8,%ebx
121958: 75 07 jne 121961 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
12195a: c6 05 b4 a9 12 00 01 movb $0x1,0x12a9b4
}
}
return false;
}
121961: 89 f8 mov %edi,%eax
121963: 8d 65 f4 lea -0xc(%ebp),%esp
121966: 5b pop %ebx
121967: 5e pop %esi
121968: 5f pop %edi
121969: c9 leave
12196a: c3 ret
0010b3b4 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10b3b4: 55 push %ebp
10b3b5: 89 e5 mov %esp,%ebp
10b3b7: 53 push %ebx
10b3b8: 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 );
10b3bb: 8d 45 f4 lea -0xc(%ebp),%eax
10b3be: 50 push %eax
10b3bf: ff 75 08 pushl 0x8(%ebp)
10b3c2: 68 14 73 12 00 push $0x127314
10b3c7: e8 cc 1a 00 00 call 10ce98 <_Objects_Get>
10b3cc: 89 c3 mov %eax,%ebx
switch ( location ) {
10b3ce: 83 c4 10 add $0x10,%esp
10b3d1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10b3d5: 75 64 jne 10b43b <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10b3d7: 8b 40 40 mov 0x40(%eax),%eax
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10b3da: f6 40 11 40 testb $0x40,0x11(%eax)
10b3de: 74 18 je 10b3f8 <_Rate_monotonic_Timeout+0x44>
10b3e0: 8b 53 08 mov 0x8(%ebx),%edx
10b3e3: 39 50 20 cmp %edx,0x20(%eax)
10b3e6: 75 10 jne 10b3f8 <_Rate_monotonic_Timeout+0x44>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10b3e8: 52 push %edx
10b3e9: 52 push %edx
10b3ea: 68 f8 ff 03 10 push $0x1003fff8
10b3ef: 50 push %eax
10b3f0: e8 0f 1f 00 00 call 10d304 <_Thread_Clear_state>
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
10b3f5: 59 pop %ecx
10b3f6: eb 10 jmp 10b408 <_Rate_monotonic_Timeout+0x54>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
10b3f8: 83 7b 38 01 cmpl $0x1,0x38(%ebx)
10b3fc: 75 2b jne 10b429 <_Rate_monotonic_Timeout+0x75>
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
10b3fe: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx)
_Rate_monotonic_Initiate_statistics( the_period );
10b405: 83 ec 0c sub $0xc,%esp
10b408: 53 push %ebx
10b409: e8 ec fa ff ff call 10aefa <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b40e: 8b 43 3c mov 0x3c(%ebx),%eax
10b411: 89 43 1c mov %eax,0x1c(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b414: 58 pop %eax
10b415: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
10b416: 83 c3 10 add $0x10,%ebx
10b419: 53 push %ebx
10b41a: 68 d0 74 12 00 push $0x1274d0
10b41f: e8 b8 31 00 00 call 10e5dc <_Watchdog_Insert>
10b424: 83 c4 10 add $0x10,%esp
10b427: eb 07 jmp 10b430 <_Rate_monotonic_Timeout+0x7c>
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
10b429: 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;
10b430: a1 08 74 12 00 mov 0x127408,%eax
10b435: 48 dec %eax
10b436: a3 08 74 12 00 mov %eax,0x127408
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10b43b: 8b 5d fc mov -0x4(%ebp),%ebx
10b43e: c9 leave
10b43f: c3 ret
0010acb4 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
10acb4: 55 push %ebp
10acb5: 89 e5 mov %esp,%ebp
10acb7: 56 push %esi
10acb8: 53 push %ebx
10acb9: 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();
10acbc: 8b 35 44 42 12 00 mov 0x124244,%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;
10acc2: 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) ||
10acc4: 85 c9 test %ecx,%ecx
10acc6: 74 57 je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
10acc8: b8 40 42 0f 00 mov $0xf4240,%eax
10accd: 31 d2 xor %edx,%edx
10accf: f7 f6 div %esi
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
10acd1: 39 41 18 cmp %eax,0x18(%ecx)
10acd4: 73 49 jae 10ad1f <_TOD_Validate+0x6b>
(the_tod->ticks >= ticks_per_second) ||
10acd6: 83 79 14 3b cmpl $0x3b,0x14(%ecx)
10acda: 77 43 ja 10ad1f <_TOD_Validate+0x6b>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
10acdc: 83 79 10 3b cmpl $0x3b,0x10(%ecx)
10ace0: 77 3d ja 10ad1f <_TOD_Validate+0x6b>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
10ace2: 83 79 0c 17 cmpl $0x17,0xc(%ecx)
10ace6: 77 37 ja 10ad1f <_TOD_Validate+0x6b>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
10ace8: 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) ||
10aceb: 85 c0 test %eax,%eax
10aced: 74 30 je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->month == 0) ||
10acef: 83 f8 0c cmp $0xc,%eax
10acf2: 77 2b ja 10ad1f <_TOD_Validate+0x6b>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10acf4: 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) ||
10acf6: 81 fe c3 07 00 00 cmp $0x7c3,%esi
10acfc: 76 21 jbe 10ad1f <_TOD_Validate+0x6b>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
10acfe: 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) ||
10ad01: 85 d2 test %edx,%edx
10ad03: 74 1a je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
10ad05: 83 e6 03 and $0x3,%esi
10ad08: 75 09 jne 10ad13 <_TOD_Validate+0x5f>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
10ad0a: 8b 04 85 24 14 12 00 mov 0x121424(,%eax,4),%eax
10ad11: eb 07 jmp 10ad1a <_TOD_Validate+0x66>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
10ad13: 8b 04 85 f0 13 12 00 mov 0x1213f0(,%eax,4),%eax
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
10ad1a: 39 c2 cmp %eax,%edx
10ad1c: 0f 96 c3 setbe %bl
if ( the_tod->day > days_in_month )
return false;
return true;
}
10ad1f: 88 d8 mov %bl,%al
10ad21: 5b pop %ebx
10ad22: 5e pop %esi
10ad23: c9 leave
10ad24: c3 ret
0010ba3c <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10ba3c: 55 push %ebp
10ba3d: 89 e5 mov %esp,%ebp
10ba3f: 57 push %edi
10ba40: 56 push %esi
10ba41: 53 push %ebx
10ba42: 83 ec 28 sub $0x28,%esp
10ba45: 8b 5d 08 mov 0x8(%ebp),%ebx
10ba48: 8b 7d 0c mov 0xc(%ebp),%edi
10ba4b: 8a 45 10 mov 0x10(%ebp),%al
10ba4e: 88 45 e7 mov %al,-0x19(%ebp)
*/
/*
* Save original state
*/
original_state = the_thread->current_state;
10ba51: 8b 73 10 mov 0x10(%ebx),%esi
/*
* 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 );
10ba54: 53 push %ebx
10ba55: e8 3e 0d 00 00 call 10c798 <_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 )
10ba5a: 83 c4 10 add $0x10,%esp
10ba5d: 39 7b 14 cmp %edi,0x14(%ebx)
10ba60: 74 0c je 10ba6e <_Thread_Change_priority+0x32>
_Thread_Set_priority( the_thread, new_priority );
10ba62: 50 push %eax
10ba63: 50 push %eax
10ba64: 57 push %edi
10ba65: 53 push %ebx
10ba66: e8 f5 0b 00 00 call 10c660 <_Thread_Set_priority>
10ba6b: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10ba6e: 9c pushf
10ba6f: fa cli
10ba70: 59 pop %ecx
/*
* 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;
10ba71: 8b 43 10 mov 0x10(%ebx),%eax
if ( state != STATES_TRANSIENT ) {
10ba74: 83 f8 04 cmp $0x4,%eax
10ba77: 74 2f je 10baa8 <_Thread_Change_priority+0x6c>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10ba79: 83 e6 04 and $0x4,%esi
10ba7c: 75 08 jne 10ba86 <_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);
10ba7e: 89 c2 mov %eax,%edx
10ba80: 83 e2 fb and $0xfffffffb,%edx
10ba83: 89 53 10 mov %edx,0x10(%ebx)
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
10ba86: 51 push %ecx
10ba87: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10ba88: a9 e0 be 03 00 test $0x3bee0,%eax
10ba8d: 0f 84 c0 00 00 00 je 10bb53 <_Thread_Change_priority+0x117>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
10ba93: 89 5d 0c mov %ebx,0xc(%ebp)
10ba96: 8b 43 44 mov 0x44(%ebx),%eax
10ba99: 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 );
}
10ba9c: 8d 65 f4 lea -0xc(%ebp),%esp
10ba9f: 5b pop %ebx
10baa0: 5e pop %esi
10baa1: 5f pop %edi
10baa2: 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 );
10baa3: e9 30 0b 00 00 jmp 10c5d8 <_Thread_queue_Requeue>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10baa8: 83 e6 04 and $0x4,%esi
10baab: 75 53 jne 10bb00 <_Thread_Change_priority+0xc4><== 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 );
10baad: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10bab4: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax
10baba: 66 8b 93 96 00 00 00 mov 0x96(%ebx),%dx
10bac1: 66 09 10 or %dx,(%eax)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10bac4: 66 a1 88 43 12 00 mov 0x124388,%ax
10baca: 0b 83 94 00 00 00 or 0x94(%ebx),%eax
10bad0: 66 a3 88 43 12 00 mov %ax,0x124388
_Priority_bit_map_Add( &the_thread->Priority_map );
if ( prepend_it )
10bad6: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10bada: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax
10bae0: 74 0e je 10baf0 <_Thread_Change_priority+0xb4>
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10bae2: 89 43 04 mov %eax,0x4(%ebx)
before_node = after_node->next;
10bae5: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10bae7: 89 18 mov %ebx,(%eax)
the_node->next = before_node;
10bae9: 89 13 mov %edx,(%ebx)
before_node->previous = the_node;
10baeb: 89 5a 04 mov %ebx,0x4(%edx)
10baee: eb 10 jmp 10bb00 <_Thread_Change_priority+0xc4>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10baf0: 8d 50 04 lea 0x4(%eax),%edx
10baf3: 89 13 mov %edx,(%ebx)
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
10baf5: 8b 50 08 mov 0x8(%eax),%edx
the_chain->last = the_node;
10baf8: 89 58 08 mov %ebx,0x8(%eax)
old_last_node->next = the_node;
10bafb: 89 1a mov %ebx,(%edx)
the_node->previous = old_last_node;
10bafd: 89 53 04 mov %edx,0x4(%ebx)
_Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node );
else
_Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );
}
_ISR_Flash( level );
10bb00: 51 push %ecx
10bb01: 9d popf
10bb02: fa cli
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 );
10bb03: 66 8b 1d 88 43 12 00 mov 0x124388,%bx
10bb0a: 31 c0 xor %eax,%eax
10bb0c: 89 c2 mov %eax,%edx
10bb0e: 66 0f bc d3 bsf %bx,%dx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10bb12: 0f b7 d2 movzwl %dx,%edx
10bb15: 66 8b 9c 12 f8 43 12 mov 0x1243f8(%edx,%edx,1),%bx
10bb1c: 00
10bb1d: 66 0f bc c3 bsf %bx,%ax
return (_Priority_Bits_index( major ) << 4) +
10bb21: c1 e2 04 shl $0x4,%edx
10bb24: 0f b7 c0 movzwl %ax,%eax
*/
RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
_Thread_Heir = (Thread_Control *)
_Thread_Ready_chain[ _Priority_bit_map_Get_highest() ].first;
10bb27: 8d 04 02 lea (%edx,%eax,1),%eax
10bb2a: 6b c0 0c imul $0xc,%eax,%eax
10bb2d: 03 05 b0 42 12 00 add 0x1242b0,%eax
* ready thread.
*/
RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
_Thread_Heir = (Thread_Control *)
10bb33: 8b 10 mov (%eax),%edx
10bb35: 89 15 38 48 12 00 mov %edx,0x124838
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
10bb3b: a1 34 48 12 00 mov 0x124834,%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.
*/
_Thread_Calculate_heir();
if ( !_Thread_Is_executing_also_the_heir() &&
10bb40: 39 d0 cmp %edx,%eax
10bb42: 74 0d je 10bb51 <_Thread_Change_priority+0x115>
10bb44: 80 78 74 00 cmpb $0x0,0x74(%eax)
10bb48: 74 07 je 10bb51 <_Thread_Change_priority+0x115>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
10bb4a: c6 05 40 48 12 00 01 movb $0x1,0x124840
_ISR_Enable( level );
10bb51: 51 push %ecx
10bb52: 9d popf
}
10bb53: 8d 65 f4 lea -0xc(%ebp),%esp
10bb56: 5b pop %ebx
10bb57: 5e pop %esi
10bb58: 5f pop %edi
10bb59: c9 leave
10bb5a: c3 ret
0010bb5c <_Thread_Clear_state>:
void _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
10bb5c: 55 push %ebp
10bb5d: 89 e5 mov %esp,%ebp
10bb5f: 53 push %ebx
10bb60: 8b 45 08 mov 0x8(%ebp),%eax
10bb63: 8b 55 0c mov 0xc(%ebp),%edx
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10bb66: 9c pushf
10bb67: fa cli
10bb68: 59 pop %ecx
current_state = the_thread->current_state;
10bb69: 8b 58 10 mov 0x10(%eax),%ebx
if ( current_state & state ) {
10bb6c: 85 da test %ebx,%edx
10bb6e: 74 71 je 10bbe1 <_Thread_Clear_state+0x85>
10bb70: f7 d2 not %edx
10bb72: 21 da and %ebx,%edx
current_state =
the_thread->current_state = _States_Clear( state, current_state );
10bb74: 89 50 10 mov %edx,0x10(%eax)
if ( _States_Is_ready( current_state ) ) {
10bb77: 85 d2 test %edx,%edx
10bb79: 75 66 jne 10bbe1 <_Thread_Clear_state+0x85>
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10bb7b: 8b 90 90 00 00 00 mov 0x90(%eax),%edx
10bb81: 66 8b 98 96 00 00 00 mov 0x96(%eax),%bx
10bb88: 66 09 1a or %bx,(%edx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10bb8b: 66 8b 15 88 43 12 00 mov 0x124388,%dx
10bb92: 0b 90 94 00 00 00 or 0x94(%eax),%edx
10bb98: 66 89 15 88 43 12 00 mov %dx,0x124388
_Priority_bit_map_Add( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
10bb9f: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10bba5: 8d 5a 04 lea 0x4(%edx),%ebx
10bba8: 89 18 mov %ebx,(%eax)
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
10bbaa: 8b 5a 08 mov 0x8(%edx),%ebx
the_chain->last = the_node;
10bbad: 89 42 08 mov %eax,0x8(%edx)
old_last_node->next = the_node;
10bbb0: 89 03 mov %eax,(%ebx)
the_node->previous = old_last_node;
10bbb2: 89 58 04 mov %ebx,0x4(%eax)
_ISR_Flash( level );
10bbb5: 51 push %ecx
10bbb6: 9d popf
10bbb7: fa cli
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
10bbb8: 8b 50 14 mov 0x14(%eax),%edx
10bbbb: 8b 1d 38 48 12 00 mov 0x124838,%ebx
10bbc1: 3b 53 14 cmp 0x14(%ebx),%edx
10bbc4: 73 1b jae 10bbe1 <_Thread_Clear_state+0x85>
_Thread_Heir = the_thread;
10bbc6: a3 38 48 12 00 mov %eax,0x124838
if ( _Thread_Executing->is_preemptible ||
10bbcb: a1 34 48 12 00 mov 0x124834,%eax
10bbd0: 80 78 74 00 cmpb $0x0,0x74(%eax)
10bbd4: 75 04 jne 10bbda <_Thread_Clear_state+0x7e>
10bbd6: 85 d2 test %edx,%edx
10bbd8: 75 07 jne 10bbe1 <_Thread_Clear_state+0x85><== ALWAYS TAKEN
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
10bbda: c6 05 40 48 12 00 01 movb $0x1,0x124840
}
}
}
_ISR_Enable( level );
10bbe1: 51 push %ecx
10bbe2: 9d popf
}
10bbe3: 5b pop %ebx
10bbe4: c9 leave
10bbe5: c3 ret
0010bd5c <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10bd5c: 55 push %ebp
10bd5d: 89 e5 mov %esp,%ebp
10bd5f: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10bd62: 8d 45 f4 lea -0xc(%ebp),%eax
10bd65: 50 push %eax
10bd66: ff 75 08 pushl 0x8(%ebp)
10bd69: e8 82 01 00 00 call 10bef0 <_Thread_Get>
switch ( location ) {
10bd6e: 83 c4 10 add $0x10,%esp
10bd71: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10bd75: 75 1b jne 10bd92 <_Thread_Delay_ended+0x36><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
10bd77: 52 push %edx
10bd78: 52 push %edx
10bd79: 68 18 00 00 10 push $0x10000018
10bd7e: 50 push %eax
10bd7f: e8 d8 fd ff ff call 10bb5c <_Thread_Clear_state>
10bd84: a1 e4 42 12 00 mov 0x1242e4,%eax
10bd89: 48 dec %eax
10bd8a: a3 e4 42 12 00 mov %eax,0x1242e4
10bd8f: 83 c4 10 add $0x10,%esp
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
10bd92: c9 leave
10bd93: c3 ret
0010bd94 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10bd94: 55 push %ebp
10bd95: 89 e5 mov %esp,%ebp
10bd97: 57 push %edi
10bd98: 56 push %esi
10bd99: 53 push %ebx
10bd9a: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10bd9d: 8b 1d 34 48 12 00 mov 0x124834,%ebx
_ISR_Disable( level );
10bda3: 9c pushf
10bda4: fa cli
10bda5: 58 pop %eax
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
10bda6: 8d 7d d8 lea -0x28(%ebp),%edi
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10bda9: e9 f9 00 00 00 jmp 10bea7 <_Thread_Dispatch+0x113>
heir = _Thread_Heir;
10bdae: 8b 35 38 48 12 00 mov 0x124838,%esi
_Thread_Dispatch_disable_level = 1;
10bdb4: c7 05 e4 42 12 00 01 movl $0x1,0x1242e4
10bdbb: 00 00 00
_Thread_Dispatch_necessary = false;
10bdbe: c6 05 40 48 12 00 00 movb $0x0,0x124840
_Thread_Executing = heir;
10bdc5: 89 35 34 48 12 00 mov %esi,0x124834
/*
* 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 )
10bdcb: 39 de cmp %ebx,%esi
10bdcd: 0f 84 e2 00 00 00 je 10beb5 <_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 )
10bdd3: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10bdd7: 75 09 jne 10bde2 <_Thread_Dispatch+0x4e>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10bdd9: 8b 15 b4 42 12 00 mov 0x1242b4,%edx
10bddf: 89 56 78 mov %edx,0x78(%esi)
_ISR_Enable( level );
10bde2: 50 push %eax
10bde3: 9d popf
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
10bde4: 83 ec 0c sub $0xc,%esp
10bde7: 8d 45 e0 lea -0x20(%ebp),%eax
10bdea: 50 push %eax
10bdeb: e8 08 36 00 00 call 10f3f8 <_TOD_Get_uptime>
_Timestamp_Subtract(
10bdf0: 83 c4 0c add $0xc,%esp
10bdf3: 57 push %edi
10bdf4: 8d 45 e0 lea -0x20(%ebp),%eax
10bdf7: 50 push %eax
10bdf8: 68 98 43 12 00 push $0x124398
10bdfd: e8 32 0c 00 00 call 10ca34 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
10be02: 58 pop %eax
10be03: 5a pop %edx
10be04: 57 push %edi
10be05: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax
10be0b: 50 push %eax
10be0c: e8 f3 0b 00 00 call 10ca04 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10be11: 8b 45 e0 mov -0x20(%ebp),%eax
10be14: 8b 55 e4 mov -0x1c(%ebp),%edx
10be17: a3 98 43 12 00 mov %eax,0x124398
10be1c: 89 15 9c 43 12 00 mov %edx,0x12439c
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10be22: a1 6c 43 12 00 mov 0x12436c,%eax
10be27: 83 c4 10 add $0x10,%esp
10be2a: 85 c0 test %eax,%eax
10be2c: 74 10 je 10be3e <_Thread_Dispatch+0xaa> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10be2e: 8b 10 mov (%eax),%edx
10be30: 89 93 f0 00 00 00 mov %edx,0xf0(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10be36: 8b 96 f0 00 00 00 mov 0xf0(%esi),%edx
10be3c: 89 10 mov %edx,(%eax)
}
_User_extensions_Thread_switch( executing, heir );
10be3e: 51 push %ecx
10be3f: 51 push %ecx
10be40: 56 push %esi
10be41: 53 push %ebx
10be42: e8 25 0e 00 00 call 10cc6c <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10be47: 58 pop %eax
10be48: 5a pop %edx
10be49: 81 c6 d4 00 00 00 add $0xd4,%esi
10be4f: 56 push %esi
10be50: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax
10be56: 50 push %eax
10be57: e8 d4 10 00 00 call 10cf30 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10be5c: 83 c4 10 add $0x10,%esp
10be5f: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx)
10be66: 74 36 je 10be9e <_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 );
10be68: a1 68 43 12 00 mov 0x124368,%eax
10be6d: 39 c3 cmp %eax,%ebx
10be6f: 74 2d je 10be9e <_Thread_Dispatch+0x10a>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10be71: 85 c0 test %eax,%eax
10be73: 74 11 je 10be86 <_Thread_Dispatch+0xf2>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10be75: 83 ec 0c sub $0xc,%esp
10be78: 05 ec 00 00 00 add $0xec,%eax
10be7d: 50 push %eax
10be7e: e8 e1 10 00 00 call 10cf64 <_CPU_Context_save_fp>
10be83: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10be86: 83 ec 0c sub $0xc,%esp
10be89: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax
10be8f: 50 push %eax
10be90: e8 d9 10 00 00 call 10cf6e <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10be95: 89 1d 68 43 12 00 mov %ebx,0x124368
10be9b: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10be9e: 8b 1d 34 48 12 00 mov 0x124834,%ebx
_ISR_Disable( level );
10bea4: 9c pushf
10bea5: fa cli
10bea6: 58 pop %eax
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10bea7: 8a 15 40 48 12 00 mov 0x124840,%dl
10bead: 84 d2 test %dl,%dl
10beaf: 0f 85 f9 fe ff ff jne 10bdae <_Thread_Dispatch+0x1a>
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
10beb5: c7 05 e4 42 12 00 00 movl $0x0,0x1242e4
10bebc: 00 00 00
_ISR_Enable( level );
10bebf: 50 push %eax
10bec0: 9d popf
_API_extensions_Run_postswitch();
10bec1: e8 0d ea ff ff call 10a8d3 <_API_extensions_Run_postswitch>
}
10bec6: 8d 65 f4 lea -0xc(%ebp),%esp
10bec9: 5b pop %ebx
10beca: 5e pop %esi
10becb: 5f pop %edi
10becc: c9 leave
10becd: c3 ret
00110f10 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
110f10: 55 push %ebp
110f11: 89 e5 mov %esp,%ebp
110f13: 53 push %ebx
110f14: 83 ec 14 sub $0x14,%esp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
110f17: 8b 1d 34 48 12 00 mov 0x124834,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
110f1d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
_ISR_Set_level(level);
110f23: 85 c0 test %eax,%eax
110f25: 74 03 je 110f2a <_Thread_Handler+0x1a>
110f27: fa cli
110f28: eb 01 jmp 110f2b <_Thread_Handler+0x1b>
110f2a: fb sti
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
110f2b: a0 a0 3f 12 00 mov 0x123fa0,%al
110f30: 88 45 f7 mov %al,-0x9(%ebp)
doneConstructors = 1;
110f33: c6 05 a0 3f 12 00 01 movb $0x1,0x123fa0
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
110f3a: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx)
110f41: 74 24 je 110f67 <_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 );
110f43: a1 68 43 12 00 mov 0x124368,%eax
110f48: 39 c3 cmp %eax,%ebx
110f4a: 74 1b je 110f67 <_Thread_Handler+0x57>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
110f4c: 85 c0 test %eax,%eax
110f4e: 74 11 je 110f61 <_Thread_Handler+0x51>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
110f50: 83 ec 0c sub $0xc,%esp
110f53: 05 ec 00 00 00 add $0xec,%eax
110f58: 50 push %eax
110f59: e8 06 c0 ff ff call 10cf64 <_CPU_Context_save_fp>
110f5e: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
110f61: 89 1d 68 43 12 00 mov %ebx,0x124368
/*
* 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 );
110f67: 83 ec 0c sub $0xc,%esp
110f6a: 53 push %ebx
110f6b: e8 ac bb ff ff call 10cb1c <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
110f70: e8 59 af ff ff call 10bece <_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) */ {
110f75: 83 c4 10 add $0x10,%esp
110f78: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
110f7c: 75 05 jne 110f83 <_Thread_Handler+0x73>
INIT_NAME ();
110f7e: e8 5d be 00 00 call 11cde0 <__start_set_sysctl_set>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
110f83: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
110f89: 85 c0 test %eax,%eax
110f8b: 75 0b jne 110f98 <_Thread_Handler+0x88>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
110f8d: 83 ec 0c sub $0xc,%esp
110f90: ff b3 a8 00 00 00 pushl 0xa8(%ebx)
110f96: eb 0c jmp 110fa4 <_Thread_Handler+0x94>
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
110f98: 48 dec %eax
110f99: 75 15 jne 110fb0 <_Thread_Handler+0xa0> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
110f9b: 83 ec 0c sub $0xc,%esp
110f9e: ff b3 a4 00 00 00 pushl 0xa4(%ebx)
110fa4: ff 93 9c 00 00 00 call *0x9c(%ebx)
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
110faa: 89 43 28 mov %eax,0x28(%ebx)
110fad: 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 );
110fb0: 83 ec 0c sub $0xc,%esp
110fb3: 53 push %ebx
110fb4: e8 94 bb ff ff call 10cb4d <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
110fb9: 83 c4 0c add $0xc,%esp
110fbc: 6a 05 push $0x5
110fbe: 6a 01 push $0x1
110fc0: 6a 00 push $0x0
110fc2: e8 69 a2 ff ff call 10b230 <_Internal_error_Occurred>
0010bf60 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10bf60: 55 push %ebp
10bf61: 89 e5 mov %esp,%ebp
10bf63: 57 push %edi
10bf64: 56 push %esi
10bf65: 53 push %ebx
10bf66: 83 ec 1c sub $0x1c,%esp
10bf69: 8b 5d 0c mov 0xc(%ebp),%ebx
10bf6c: 8b 4d 10 mov 0x10(%ebp),%ecx
10bf6f: 8b 75 14 mov 0x14(%ebp),%esi
10bf72: 8a 55 18 mov 0x18(%ebp),%dl
10bf75: 8a 45 20 mov 0x20(%ebp),%al
10bf78: 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;
10bf7b: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx)
10bf82: 00 00 00
10bf85: c7 83 f8 00 00 00 00 movl $0x0,0xf8(%ebx)
10bf8c: 00 00 00
extensions_area = NULL;
the_thread->libc_reent = NULL;
10bf8f: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx)
10bf96: 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 ) {
10bf99: 85 c9 test %ecx,%ecx
10bf9b: 75 31 jne 10bfce <_Thread_Initialize+0x6e>
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10bf9d: 51 push %ecx
10bf9e: 51 push %ecx
10bf9f: 56 push %esi
10bfa0: 53 push %ebx
10bfa1: 88 55 e0 mov %dl,-0x20(%ebp)
10bfa4: e8 63 08 00 00 call 10c80c <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10bfa9: 83 c4 10 add $0x10,%esp
10bfac: 39 f0 cmp %esi,%eax
10bfae: 8a 55 e0 mov -0x20(%ebp),%dl
10bfb1: 0f 82 c1 01 00 00 jb 10c178 <_Thread_Initialize+0x218>
10bfb7: 85 c0 test %eax,%eax
10bfb9: 0f 84 b9 01 00 00 je 10c178 <_Thread_Initialize+0x218><== NEVER TAKEN
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
10bfbf: 8b 8b d0 00 00 00 mov 0xd0(%ebx),%ecx
the_thread->Start.core_allocated_stack = true;
10bfc5: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx)
10bfcc: eb 09 jmp 10bfd7 <_Thread_Initialize+0x77>
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
10bfce: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx)
10bfd5: 89 f0 mov %esi,%eax
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
10bfd7: 89 8b c8 00 00 00 mov %ecx,0xc8(%ebx)
the_stack->size = size;
10bfdd: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx)
extensions_area = NULL;
the_thread->libc_reent = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
fp_area = NULL;
10bfe3: 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 ) {
10bfe5: 84 d2 test %dl,%dl
10bfe7: 74 17 je 10c000 <_Thread_Initialize+0xa0>
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
10bfe9: 83 ec 0c sub $0xc,%esp
10bfec: 6a 6c push $0x6c
10bfee: e8 df 0e 00 00 call 10ced2 <_Workspace_Allocate>
10bff3: 89 c7 mov %eax,%edi
if ( !fp_area )
10bff5: 83 c4 10 add $0x10,%esp
10bff8: 85 c0 test %eax,%eax
10bffa: 0f 84 08 01 00 00 je 10c108 <_Thread_Initialize+0x1a8>
goto failed;
fp_area = _Context_Fp_start( fp_area, 0 );
}
the_thread->fp_context = fp_area;
10c000: 89 bb ec 00 00 00 mov %edi,0xec(%ebx)
the_thread->Start.fp_context = fp_area;
10c006: 89 bb cc 00 00 00 mov %edi,0xcc(%ebx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10c00c: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10c013: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
the_watchdog->id = id;
10c01a: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
the_watchdog->user_data = user_data;
10c021: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c028: a1 78 43 12 00 mov 0x124378,%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;
10c02d: 31 f6 xor %esi,%esi
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c02f: 85 c0 test %eax,%eax
10c031: 74 1d je 10c050 <_Thread_Initialize+0xf0>
extensions_area = _Workspace_Allocate(
10c033: 83 ec 0c sub $0xc,%esp
10c036: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax
10c03d: 50 push %eax
10c03e: e8 8f 0e 00 00 call 10ced2 <_Workspace_Allocate>
10c043: 89 c6 mov %eax,%esi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
10c045: 83 c4 10 add $0x10,%esp
10c048: 85 c0 test %eax,%eax
10c04a: 0f 84 ba 00 00 00 je 10c10a <_Thread_Initialize+0x1aa>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10c050: 89 b3 fc 00 00 00 mov %esi,0xfc(%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 ) {
10c056: 85 f6 test %esi,%esi
10c058: 74 16 je 10c070 <_Thread_Initialize+0x110>
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
10c05a: 8b 15 78 43 12 00 mov 0x124378,%edx
10c060: 31 c0 xor %eax,%eax
10c062: eb 08 jmp 10c06c <_Thread_Initialize+0x10c>
the_thread->extensions[i] = NULL;
10c064: 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++ )
10c06b: 40 inc %eax
10c06c: 39 d0 cmp %edx,%eax
10c06e: 76 f4 jbe 10c064 <_Thread_Initialize+0x104>
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10c070: 8a 45 e7 mov -0x19(%ebp),%al
10c073: 88 83 ac 00 00 00 mov %al,0xac(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10c079: 8b 45 24 mov 0x24(%ebp),%eax
10c07c: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx)
the_thread->Start.budget_callout = budget_callout;
10c082: 8b 45 28 mov 0x28(%ebp),%eax
10c085: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx)
switch ( budget_algorithm ) {
10c08b: 83 7d 24 02 cmpl $0x2,0x24(%ebp)
10c08f: 75 08 jne 10c099 <_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;
10c091: a1 b4 42 12 00 mov 0x1242b4,%eax
10c096: 89 43 78 mov %eax,0x78(%ebx)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
10c099: 8b 45 2c mov 0x2c(%ebp),%eax
10c09c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
the_thread->current_state = STATES_DORMANT;
10c0a2: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10c0a9: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10c0b0: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->real_priority = priority;
10c0b7: 8b 45 1c mov 0x1c(%ebp),%eax
10c0ba: 89 43 18 mov %eax,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10c0bd: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
_Thread_Set_priority( the_thread, priority );
10c0c3: 52 push %edx
10c0c4: 52 push %edx
10c0c5: 50 push %eax
10c0c6: 53 push %ebx
10c0c7: e8 94 05 00 00 call 10c660 <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
10c0cc: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10c0d3: 00 00 00
10c0d6: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10c0dd: 00 00 00
_Thread_Stack_Free( the_thread );
return false;
}
10c0e0: 8b 45 08 mov 0x8(%ebp),%eax
10c0e3: 8b 40 1c mov 0x1c(%eax),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c0e6: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c0ea: 89 1c 90 mov %ebx,(%eax,%edx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c0ed: 8b 45 30 mov 0x30(%ebp),%eax
10c0f0: 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 );
10c0f3: 89 1c 24 mov %ebx,(%esp)
10c0f6: e8 c1 0a 00 00 call 10cbbc <_User_extensions_Thread_create>
10c0fb: 88 c2 mov %al,%dl
if ( extension_status )
10c0fd: 83 c4 10 add $0x10,%esp
return true;
10c100: 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 )
10c102: 84 d2 test %dl,%dl
10c104: 74 04 je 10c10a <_Thread_Initialize+0x1aa>
10c106: eb 72 jmp 10c17a <_Thread_Initialize+0x21a>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
10c108: 31 f6 xor %esi,%esi
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
failed:
if ( the_thread->libc_reent )
10c10a: 8b 83 f0 00 00 00 mov 0xf0(%ebx),%eax
10c110: 85 c0 test %eax,%eax
10c112: 74 0c je 10c120 <_Thread_Initialize+0x1c0>
_Workspace_Free( the_thread->libc_reent );
10c114: 83 ec 0c sub $0xc,%esp
10c117: 50 push %eax
10c118: e8 ce 0d 00 00 call 10ceeb <_Workspace_Free>
10c11d: 83 c4 10 add $0x10,%esp
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
10c120: 8b 83 f4 00 00 00 mov 0xf4(%ebx),%eax
10c126: 85 c0 test %eax,%eax
10c128: 74 0c je 10c136 <_Thread_Initialize+0x1d6>
_Workspace_Free( the_thread->API_Extensions[i] );
10c12a: 83 ec 0c sub $0xc,%esp
10c12d: 50 push %eax
10c12e: e8 b8 0d 00 00 call 10ceeb <_Workspace_Free>
10c133: 83 c4 10 add $0x10,%esp
failed:
if ( the_thread->libc_reent )
_Workspace_Free( the_thread->libc_reent );
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
10c136: 8b 83 f8 00 00 00 mov 0xf8(%ebx),%eax
10c13c: 85 c0 test %eax,%eax
10c13e: 74 0c je 10c14c <_Thread_Initialize+0x1ec>
_Workspace_Free( the_thread->API_Extensions[i] );
10c140: 83 ec 0c sub $0xc,%esp
10c143: 50 push %eax
10c144: e8 a2 0d 00 00 call 10ceeb <_Workspace_Free>
10c149: 83 c4 10 add $0x10,%esp
if ( extensions_area )
10c14c: 85 f6 test %esi,%esi
10c14e: 74 0c je 10c15c <_Thread_Initialize+0x1fc>
(void) _Workspace_Free( extensions_area );
10c150: 83 ec 0c sub $0xc,%esp
10c153: 56 push %esi
10c154: e8 92 0d 00 00 call 10ceeb <_Workspace_Free>
10c159: 83 c4 10 add $0x10,%esp
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
10c15c: 85 ff test %edi,%edi
10c15e: 74 0c je 10c16c <_Thread_Initialize+0x20c>
(void) _Workspace_Free( fp_area );
10c160: 83 ec 0c sub $0xc,%esp
10c163: 57 push %edi
10c164: e8 82 0d 00 00 call 10ceeb <_Workspace_Free>
10c169: 83 c4 10 add $0x10,%esp
#endif
_Thread_Stack_Free( the_thread );
10c16c: 83 ec 0c sub $0xc,%esp
10c16f: 53 push %ebx
10c170: e8 e7 06 00 00 call 10c85c <_Thread_Stack_Free>
return false;
10c175: 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 */
10c178: 31 c0 xor %eax,%eax
_Thread_Stack_Free( the_thread );
return false;
}
10c17a: 8d 65 f4 lea -0xc(%ebp),%esp
10c17d: 5b pop %ebx
10c17e: 5e pop %esi
10c17f: 5f pop %edi
10c180: c9 leave
10c181: c3 ret
0010f400 <_Thread_Resume>:
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
10f400: 55 push %ebp
10f401: 89 e5 mov %esp,%ebp
10f403: 53 push %ebx
10f404: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10f407: 9c pushf
10f408: fa cli
10f409: 59 pop %ecx
current_state = the_thread->current_state;
10f40a: 8b 50 10 mov 0x10(%eax),%edx
if ( current_state & STATES_SUSPENDED ) {
10f40d: f6 c2 02 test $0x2,%dl
10f410: 74 70 je 10f482 <_Thread_Resume+0x82> <== NEVER TAKEN
10f412: 83 e2 fd and $0xfffffffd,%edx
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
10f415: 89 50 10 mov %edx,0x10(%eax)
if ( _States_Is_ready( current_state ) ) {
10f418: 85 d2 test %edx,%edx
10f41a: 75 66 jne 10f482 <_Thread_Resume+0x82>
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10f41c: 8b 90 90 00 00 00 mov 0x90(%eax),%edx
10f422: 66 8b 98 96 00 00 00 mov 0x96(%eax),%bx
10f429: 66 09 1a or %bx,(%edx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10f42c: 66 8b 15 50 74 12 00 mov 0x127450,%dx
10f433: 0b 90 94 00 00 00 or 0x94(%eax),%edx
10f439: 66 89 15 50 74 12 00 mov %dx,0x127450
_Priority_bit_map_Add( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
10f440: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10f446: 8d 5a 04 lea 0x4(%edx),%ebx
10f449: 89 18 mov %ebx,(%eax)
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
10f44b: 8b 5a 08 mov 0x8(%edx),%ebx
the_chain->last = the_node;
10f44e: 89 42 08 mov %eax,0x8(%edx)
old_last_node->next = the_node;
10f451: 89 03 mov %eax,(%ebx)
the_node->previous = old_last_node;
10f453: 89 58 04 mov %ebx,0x4(%eax)
_ISR_Flash( level );
10f456: 51 push %ecx
10f457: 9d popf
10f458: fa cli
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
10f459: 8b 50 14 mov 0x14(%eax),%edx
10f45c: 8b 1d 00 79 12 00 mov 0x127900,%ebx
10f462: 3b 53 14 cmp 0x14(%ebx),%edx
10f465: 73 1b jae 10f482 <_Thread_Resume+0x82>
_Thread_Heir = the_thread;
10f467: a3 00 79 12 00 mov %eax,0x127900
if ( _Thread_Executing->is_preemptible ||
10f46c: a1 fc 78 12 00 mov 0x1278fc,%eax
10f471: 80 78 74 00 cmpb $0x0,0x74(%eax)
10f475: 75 04 jne 10f47b <_Thread_Resume+0x7b>
10f477: 85 d2 test %edx,%edx
10f479: 75 07 jne 10f482 <_Thread_Resume+0x82> <== ALWAYS TAKEN
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
10f47b: c6 05 08 79 12 00 01 movb $0x1,0x127908
}
}
}
_ISR_Enable( level );
10f482: 51 push %ecx
10f483: 9d popf
}
10f484: 5b pop %ebx
10f485: c9 leave
10f486: c3 ret
0010c944 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10c944: 55 push %ebp
10c945: 89 e5 mov %esp,%ebp
10c947: 53 push %ebx
10c948: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10c94b: 8b 1d 34 48 12 00 mov 0x124834,%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10c951: 80 7b 74 00 cmpb $0x0,0x74(%ebx)
10c955: 74 4c je 10c9a3 <_Thread_Tickle_timeslice+0x5f>
return;
if ( !_States_Is_ready( executing->current_state ) )
10c957: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10c95b: 75 46 jne 10c9a3 <_Thread_Tickle_timeslice+0x5f>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10c95d: 8b 43 7c mov 0x7c(%ebx),%eax
10c960: 83 f8 01 cmp $0x1,%eax
10c963: 72 3e jb 10c9a3 <_Thread_Tickle_timeslice+0x5f>
10c965: 83 f8 02 cmp $0x2,%eax
10c968: 76 07 jbe 10c971 <_Thread_Tickle_timeslice+0x2d>
10c96a: 83 f8 03 cmp $0x3,%eax
10c96d: 75 34 jne 10c9a3 <_Thread_Tickle_timeslice+0x5f><== NEVER TAKEN
10c96f: eb 1a jmp 10c98b <_Thread_Tickle_timeslice+0x47>
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 ) {
10c971: 8b 43 78 mov 0x78(%ebx),%eax
10c974: 48 dec %eax
10c975: 89 43 78 mov %eax,0x78(%ebx)
10c978: 85 c0 test %eax,%eax
10c97a: 7f 27 jg 10c9a3 <_Thread_Tickle_timeslice+0x5f>
* at the priority of the currently executing thread, then the
* 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.
*/
_Thread_Yield_processor();
10c97c: e8 27 00 00 00 call 10c9a8 <_Thread_Yield_processor>
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c981: a1 b4 42 12 00 mov 0x1242b4,%eax
10c986: 89 43 78 mov %eax,0x78(%ebx)
10c989: eb 18 jmp 10c9a3 <_Thread_Tickle_timeslice+0x5f>
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
10c98b: 8b 43 78 mov 0x78(%ebx),%eax
10c98e: 48 dec %eax
10c98f: 89 43 78 mov %eax,0x78(%ebx)
10c992: 85 c0 test %eax,%eax
10c994: 75 0d jne 10c9a3 <_Thread_Tickle_timeslice+0x5f>
(*executing->budget_callout)( executing );
10c996: 83 ec 0c sub $0xc,%esp
10c999: 53 push %ebx
10c99a: ff 93 80 00 00 00 call *0x80(%ebx)
10c9a0: 83 c4 10 add $0x10,%esp
break;
#endif
}
}
10c9a3: 8b 5d fc mov -0x4(%ebp),%ebx
10c9a6: c9 leave
10c9a7: c3 ret
0010c3e0 <_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
)
{
10c3e0: 55 push %ebp
10c3e1: 89 e5 mov %esp,%ebp
10c3e3: 57 push %edi
10c3e4: 56 push %esi
10c3e5: 53 push %ebx
10c3e6: 83 ec 14 sub $0x14,%esp
10c3e9: 8b 4d 08 mov 0x8(%ebp),%ecx
10c3ec: 8b 45 0c mov 0xc(%ebp),%eax
10c3ef: 8d 50 3c lea 0x3c(%eax),%edx
10c3f2: 89 50 38 mov %edx,0x38(%eax)
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
10c3f5: c7 40 3c 00 00 00 00 movl $0x0,0x3c(%eax)
Chain_Node *previous_node;
Chain_Node *search_node;
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
10c3fc: 8d 50 38 lea 0x38(%eax),%edx
10c3ff: 89 50 40 mov %edx,0x40(%eax)
priority = the_thread->current_priority;
10c402: 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);
10c405: 89 df mov %ebx,%edi
10c407: c1 ef 06 shr $0x6,%edi
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
10c40a: 6b ff 0c imul $0xc,%edi,%edi
10c40d: 8d 3c 39 lea (%ecx,%edi,1),%edi
10c410: 89 7d ec mov %edi,-0x14(%ebp)
block_state = the_thread_queue->state;
10c413: 8b 51 38 mov 0x38(%ecx),%edx
10c416: 89 55 e4 mov %edx,-0x1c(%ebp)
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
10c419: 89 7d e8 mov %edi,-0x18(%ebp)
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
10c41c: f6 c3 20 test $0x20,%bl
10c41f: 75 73 jne 10c494 <_Thread_queue_Enqueue_priority+0xb4>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10c421: 8d 77 04 lea 0x4(%edi),%esi
10c424: 89 75 e8 mov %esi,-0x18(%ebp)
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
10c427: 9c pushf
10c428: fa cli
10c429: 8f 45 f0 popl -0x10(%ebp)
10c42c: 8b 75 f0 mov -0x10(%ebp),%esi
search_thread = (Thread_Control *) header->first;
10c42f: 8b 17 mov (%edi),%edx
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
10c431: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp)
10c438: 89 75 e0 mov %esi,-0x20(%ebp)
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
10c43b: eb 1f jmp 10c45c <_Thread_queue_Enqueue_priority+0x7c>
search_priority = search_thread->current_priority;
10c43d: 8b 72 14 mov 0x14(%edx),%esi
10c440: 89 75 ec mov %esi,-0x14(%ebp)
if ( priority <= search_priority )
10c443: 39 f3 cmp %esi,%ebx
10c445: 76 1a jbe 10c461 <_Thread_queue_Enqueue_priority+0x81>
break;
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
10c447: ff 75 f0 pushl -0x10(%ebp)
10c44a: 9d popf
10c44b: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10c44c: 8b 75 e4 mov -0x1c(%ebp),%esi
10c44f: 85 72 10 test %esi,0x10(%edx)
10c452: 75 06 jne 10c45a <_Thread_queue_Enqueue_priority+0x7a><== ALWAYS TAKEN
_ISR_Enable( level );
10c454: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED
10c457: 9d popf <== NOT EXECUTED
goto restart_forward_search;
10c458: eb cd jmp 10c427 <_Thread_queue_Enqueue_priority+0x47><== NOT EXECUTED
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
10c45a: 8b 12 mov (%edx),%edx
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
10c45c: 3b 55 e8 cmp -0x18(%ebp),%edx
10c45f: 75 dc jne 10c43d <_Thread_queue_Enqueue_priority+0x5d>
10c461: 8b 75 e0 mov -0x20(%ebp),%esi
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
10c464: 83 79 30 01 cmpl $0x1,0x30(%ecx)
10c468: 0f 85 ae 00 00 00 jne 10c51c <_Thread_queue_Enqueue_priority+0x13c>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10c46e: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx)
if ( priority == search_priority )
10c475: 3b 5d ec cmp -0x14(%ebp),%ebx
10c478: 0f 84 87 00 00 00 je 10c505 <_Thread_queue_Enqueue_priority+0x125>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
10c47e: 8b 5a 04 mov 0x4(%edx),%ebx
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10c481: 89 10 mov %edx,(%eax)
the_node->previous = previous_node;
10c483: 89 58 04 mov %ebx,0x4(%eax)
previous_node->next = the_node;
10c486: 89 03 mov %eax,(%ebx)
search_node->previous = the_node;
10c488: 89 42 04 mov %eax,0x4(%edx)
the_thread->Wait.queue = the_thread_queue;
10c48b: 89 48 44 mov %ecx,0x44(%eax)
_ISR_Enable( level );
10c48e: ff 75 f0 pushl -0x10(%ebp)
10c491: 9d popf
10c492: eb 6a jmp 10c4fe <_Thread_queue_Enqueue_priority+0x11e>
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
10c494: 0f b6 3d f4 01 12 00 movzbl 0x1201f4,%edi
10c49b: 47 inc %edi
10c49c: 89 7d e0 mov %edi,-0x20(%ebp)
_ISR_Disable( level );
10c49f: 9c pushf
10c4a0: fa cli
10c4a1: 8f 45 f0 popl -0x10(%ebp)
10c4a4: 8b 75 f0 mov -0x10(%ebp),%esi
search_thread = (Thread_Control *) header->last;
10c4a7: 8b 7d e8 mov -0x18(%ebp),%edi
10c4aa: 8b 57 08 mov 0x8(%edi),%edx
10c4ad: 8b 7d e0 mov -0x20(%ebp),%edi
10c4b0: 89 75 e0 mov %esi,-0x20(%ebp)
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
10c4b3: eb 1d jmp 10c4d2 <_Thread_queue_Enqueue_priority+0xf2>
search_priority = search_thread->current_priority;
10c4b5: 8b 7a 14 mov 0x14(%edx),%edi
if ( priority >= search_priority )
10c4b8: 39 fb cmp %edi,%ebx
10c4ba: 73 1b jae 10c4d7 <_Thread_queue_Enqueue_priority+0xf7>
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
10c4bc: ff 75 f0 pushl -0x10(%ebp)
10c4bf: 9d popf
10c4c0: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10c4c1: 8b 75 e4 mov -0x1c(%ebp),%esi
10c4c4: 85 72 10 test %esi,0x10(%edx)
10c4c7: 75 06 jne 10c4cf <_Thread_queue_Enqueue_priority+0xef>
_ISR_Enable( level );
10c4c9: ff 75 f0 pushl -0x10(%ebp)
10c4cc: 9d popf
goto restart_reverse_search;
10c4cd: eb c5 jmp 10c494 <_Thread_queue_Enqueue_priority+0xb4>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
10c4cf: 8b 52 04 mov 0x4(%edx),%edx
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
10c4d2: 3b 55 ec cmp -0x14(%ebp),%edx
10c4d5: 75 de jne 10c4b5 <_Thread_queue_Enqueue_priority+0xd5>
10c4d7: 8b 75 e0 mov -0x20(%ebp),%esi
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
10c4da: 83 79 30 01 cmpl $0x1,0x30(%ecx)
10c4de: 75 3c jne 10c51c <_Thread_queue_Enqueue_priority+0x13c>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10c4e0: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx)
if ( priority == search_priority )
10c4e7: 39 fb cmp %edi,%ebx
10c4e9: 74 1a je 10c505 <_Thread_queue_Enqueue_priority+0x125>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
10c4eb: 8b 1a mov (%edx),%ebx
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
10c4ed: 89 18 mov %ebx,(%eax)
the_node->previous = search_node;
10c4ef: 89 50 04 mov %edx,0x4(%eax)
search_node->next = the_node;
10c4f2: 89 02 mov %eax,(%edx)
next_node->previous = the_node;
10c4f4: 89 43 04 mov %eax,0x4(%ebx)
the_thread->Wait.queue = the_thread_queue;
10c4f7: 89 48 44 mov %ecx,0x44(%eax)
_ISR_Enable( level );
10c4fa: ff 75 f0 pushl -0x10(%ebp)
10c4fd: 9d popf
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10c4fe: b8 01 00 00 00 mov $0x1,%eax
10c503: eb 1f jmp 10c524 <_Thread_queue_Enqueue_priority+0x144>
10c505: 83 c2 3c add $0x3c,%edx
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
10c508: 8b 5a 04 mov 0x4(%edx),%ebx
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10c50b: 89 10 mov %edx,(%eax)
the_node->previous = previous_node;
10c50d: 89 58 04 mov %ebx,0x4(%eax)
previous_node->next = the_node;
10c510: 89 03 mov %eax,(%ebx)
search_node->previous = the_node;
10c512: 89 42 04 mov %eax,0x4(%edx)
the_thread->Wait.queue = the_thread_queue;
10c515: 89 48 44 mov %ecx,0x44(%eax)
_ISR_Enable( level );
10c518: 56 push %esi
10c519: 9d popf
10c51a: eb e2 jmp 10c4fe <_Thread_queue_Enqueue_priority+0x11e>
* 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;
10c51c: 8b 45 10 mov 0x10(%ebp),%eax
10c51f: 89 30 mov %esi,(%eax)
return the_thread_queue->sync_state;
10c521: 8b 41 30 mov 0x30(%ecx),%eax
}
10c524: 83 c4 14 add $0x14,%esp
10c527: 5b pop %ebx
10c528: 5e pop %esi
10c529: 5f pop %edi
10c52a: c9 leave
10c52b: c3 ret
0010c5d8 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10c5d8: 55 push %ebp
10c5d9: 89 e5 mov %esp,%ebp
10c5db: 57 push %edi
10c5dc: 56 push %esi
10c5dd: 53 push %ebx
10c5de: 83 ec 1c sub $0x1c,%esp
10c5e1: 8b 75 08 mov 0x8(%ebp),%esi
10c5e4: 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 )
10c5e7: 85 f6 test %esi,%esi
10c5e9: 74 36 je 10c621 <_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 ) {
10c5eb: 83 7e 34 01 cmpl $0x1,0x34(%esi)
10c5ef: 75 30 jne 10c621 <_Thread_queue_Requeue+0x49><== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
10c5f1: 9c pushf
10c5f2: fa cli
10c5f3: 5b pop %ebx
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10c5f4: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi)
10c5fb: 74 22 je 10c61f <_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;
10c5fd: 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 );
10c604: 50 push %eax
10c605: 6a 01 push $0x1
10c607: 57 push %edi
10c608: 56 push %esi
10c609: e8 82 32 00 00 call 10f890 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10c60e: 83 c4 0c add $0xc,%esp
10c611: 8d 45 e4 lea -0x1c(%ebp),%eax
10c614: 50 push %eax
10c615: 57 push %edi
10c616: 56 push %esi
10c617: e8 c4 fd ff ff call 10c3e0 <_Thread_queue_Enqueue_priority>
10c61c: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10c61f: 53 push %ebx
10c620: 9d popf
}
}
10c621: 8d 65 f4 lea -0xc(%ebp),%esp
10c624: 5b pop %ebx
10c625: 5e pop %esi
10c626: 5f pop %edi
10c627: c9 leave
10c628: c3 ret
0010c62c <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10c62c: 55 push %ebp
10c62d: 89 e5 mov %esp,%ebp
10c62f: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10c632: 8d 45 f4 lea -0xc(%ebp),%eax
10c635: 50 push %eax
10c636: ff 75 08 pushl 0x8(%ebp)
10c639: e8 b2 f8 ff ff call 10bef0 <_Thread_Get>
switch ( location ) {
10c63e: 83 c4 10 add $0x10,%esp
10c641: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10c645: 75 17 jne 10c65e <_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 );
10c647: 83 ec 0c sub $0xc,%esp
10c64a: 50 push %eax
10c64b: e8 f4 32 00 00 call 10f944 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10c650: a1 e4 42 12 00 mov 0x1242e4,%eax
10c655: 48 dec %eax
10c656: a3 e4 42 12 00 mov %eax,0x1242e4
10c65b: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10c65e: c9 leave
10c65f: c3 ret
0011696c <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
11696c: 55 push %ebp
11696d: 89 e5 mov %esp,%ebp
11696f: 57 push %edi
116970: 56 push %esi
116971: 53 push %ebx
116972: 83 ec 4c sub $0x4c,%esp
116975: 8b 5d 08 mov 0x8(%ebp),%ebx
116978: 8d 45 dc lea -0x24(%ebp),%eax
11697b: 8d 55 e0 lea -0x20(%ebp),%edx
11697e: 89 55 b4 mov %edx,-0x4c(%ebp)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
116981: 89 55 dc mov %edx,-0x24(%ebp)
the_chain->permanent_null = NULL;
116984: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
Timer_server_Control *ts = (Timer_server_Control *) arg;
Chain_Control insert_chain;
Chain_Control fire_chain;
_Chain_Initialize_empty( &insert_chain );
11698b: 89 45 e4 mov %eax,-0x1c(%ebp)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
11698e: 8d 7d d0 lea -0x30(%ebp),%edi
116991: 8d 55 d4 lea -0x2c(%ebp),%edx
116994: 89 55 b0 mov %edx,-0x50(%ebp)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
116997: 89 55 d0 mov %edx,-0x30(%ebp)
the_chain->permanent_null = NULL;
11699a: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
the_chain->last = _Chain_Head(the_chain);
1169a1: 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 );
1169a4: 8d 43 30 lea 0x30(%ebx),%eax
1169a7: 89 45 c0 mov %eax,-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 );
1169aa: 8d 73 68 lea 0x68(%ebx),%esi
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
1169ad: 8d 53 08 lea 0x8(%ebx),%edx
1169b0: 89 55 bc mov %edx,-0x44(%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;
1169b3: 8d 4d dc lea -0x24(%ebp),%ecx
1169b6: 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;
1169b9: a1 f0 d7 13 00 mov 0x13d7f0,%eax
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
1169be: 8b 53 3c mov 0x3c(%ebx),%edx
watchdogs->last_snapshot = snapshot;
1169c1: 89 43 3c mov %eax,0x3c(%ebx)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169c4: 51 push %ecx
1169c5: 8d 4d d0 lea -0x30(%ebp),%ecx
1169c8: 51 push %ecx
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
1169c9: 29 d0 sub %edx,%eax
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169cb: 50 push %eax
1169cc: ff 75 c0 pushl -0x40(%ebp)
1169cf: e8 a0 39 00 00 call 11a374 <_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();
1169d4: a1 44 d7 13 00 mov 0x13d744,%eax
1169d9: 89 45 c4 mov %eax,-0x3c(%ebp)
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
1169dc: 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 ) {
1169df: 83 c4 10 add $0x10,%esp
1169e2: 39 45 c4 cmp %eax,-0x3c(%ebp)
1169e5: 76 13 jbe 1169fa <_Timer_server_Body+0x8e>
/*
* 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 );
1169e7: 52 push %edx
1169e8: 8d 55 d0 lea -0x30(%ebp),%edx
1169eb: 52 push %edx
if ( snapshot > last_snapshot ) {
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
1169ec: 8b 4d c4 mov -0x3c(%ebp),%ecx
1169ef: 29 c1 sub %eax,%ecx
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169f1: 51 push %ecx
1169f2: 56 push %esi
1169f3: e8 7c 39 00 00 call 11a374 <_Watchdog_Adjust_to_chain>
1169f8: eb 0f jmp 116a09 <_Timer_server_Body+0x9d>
} else if ( snapshot < last_snapshot ) {
1169fa: 73 10 jae 116a0c <_Timer_server_Body+0xa0>
/*
* 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: 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;
1169fd: 2b 45 c4 sub -0x3c(%ebp),%eax
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
116a00: 50 push %eax
116a01: 6a 01 push $0x1
116a03: 56 push %esi
116a04: e8 ff 38 00 00 call 11a308 <_Watchdog_Adjust>
116a09: 83 c4 10 add $0x10,%esp
}
watchdogs->last_snapshot = snapshot;
116a0c: 8b 45 c4 mov -0x3c(%ebp),%eax
116a0f: 89 43 74 mov %eax,0x74(%ebx)
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
116a12: 8b 43 78 mov 0x78(%ebx),%eax
116a15: 83 ec 0c sub $0xc,%esp
116a18: 50 push %eax
116a19: e8 ea 08 00 00 call 117308 <_Chain_Get>
if ( timer == NULL ) {
116a1e: 83 c4 10 add $0x10,%esp
116a21: 85 c0 test %eax,%eax
116a23: 74 29 je 116a4e <_Timer_server_Body+0xe2>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
116a25: 8b 50 38 mov 0x38(%eax),%edx
116a28: 83 fa 01 cmp $0x1,%edx
116a2b: 75 0b jne 116a38 <_Timer_server_Body+0xcc>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116a2d: 52 push %edx
116a2e: 52 push %edx
116a2f: 83 c0 10 add $0x10,%eax
116a32: 50 push %eax
116a33: ff 75 c0 pushl -0x40(%ebp)
116a36: eb 0c jmp 116a44 <_Timer_server_Body+0xd8>
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116a38: 83 fa 03 cmp $0x3,%edx
116a3b: 75 d5 jne 116a12 <_Timer_server_Body+0xa6><== NEVER TAKEN
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116a3d: 51 push %ecx
116a3e: 51 push %ecx
116a3f: 83 c0 10 add $0x10,%eax
116a42: 50 push %eax
116a43: 56 push %esi
116a44: e8 b3 39 00 00 call 11a3fc <_Watchdog_Insert>
116a49: 83 c4 10 add $0x10,%esp
116a4c: eb c4 jmp 116a12 <_Timer_server_Body+0xa6>
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
116a4e: 9c pushf
116a4f: fa cli
116a50: 5a pop %edx
tmp = ts->insert_chain;
116a51: 8b 43 78 mov 0x78(%ebx),%eax
if ( _Chain_Is_empty( insert_chain ) ) {
116a54: b0 01 mov $0x1,%al
116a56: 8b 4d b4 mov -0x4c(%ebp),%ecx
116a59: 39 4d dc cmp %ecx,-0x24(%ebp)
116a5c: 75 09 jne 116a67 <_Timer_server_Body+0xfb>
ts->insert_chain = NULL;
116a5e: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx)
do_loop = false;
116a65: 31 c0 xor %eax,%eax
}
_ISR_Enable( level );
116a67: 52 push %edx
116a68: 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 ) {
116a69: 84 c0 test %al,%al
116a6b: 0f 85 48 ff ff ff jne 1169b9 <_Timer_server_Body+0x4d>
_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 ) ) {
116a71: 8b 45 b0 mov -0x50(%ebp),%eax
116a74: 39 45 d0 cmp %eax,-0x30(%ebp)
116a77: 74 37 je 116ab0 <_Timer_server_Body+0x144>
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
116a79: 9c pushf
116a7a: fa cli
116a7b: 5a pop %edx
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
116a7c: 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))
116a7f: 3b 45 b0 cmp -0x50(%ebp),%eax
116a82: 74 25 je 116aa9 <_Timer_server_Body+0x13d>
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
116a84: 8b 08 mov (%eax),%ecx
the_chain->first = new_first;
116a86: 89 4d d0 mov %ecx,-0x30(%ebp)
new_first->previous = _Chain_Head(the_chain);
116a89: 89 79 04 mov %edi,0x4(%ecx)
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
116a8c: 85 c0 test %eax,%eax
116a8e: 74 19 je 116aa9 <_Timer_server_Body+0x13d><== NEVER TAKEN
watchdog->state = WATCHDOG_INACTIVE;
116a90: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
_ISR_Enable( level );
116a97: 52 push %edx
116a98: 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 );
116a99: 52 push %edx
116a9a: 52 push %edx
116a9b: ff 70 24 pushl 0x24(%eax)
116a9e: ff 70 20 pushl 0x20(%eax)
116aa1: ff 50 1c call *0x1c(%eax)
}
116aa4: 83 c4 10 add $0x10,%esp
116aa7: eb d0 jmp 116a79 <_Timer_server_Body+0x10d>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
116aa9: 52 push %edx
116aaa: 9d popf
116aab: e9 03 ff ff ff jmp 1169b3 <_Timer_server_Body+0x47>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
116ab0: c6 43 7c 00 movb $0x0,0x7c(%ebx)
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
116ab4: e8 17 fe ff ff call 1168d0 <_Thread_Disable_dispatch>
_Thread_Set_state( ts->thread, STATES_DELAYING );
116ab9: 50 push %eax
116aba: 50 push %eax
116abb: 6a 08 push $0x8
116abd: ff 33 pushl (%ebx)
116abf: e8 18 31 00 00 call 119bdc <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
116ac4: 89 d8 mov %ebx,%eax
116ac6: e8 15 fe ff ff call 1168e0 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
116acb: 89 d8 mov %ebx,%eax
116acd: e8 54 fe ff ff call 116926 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
116ad2: e8 ff 27 00 00 call 1192d6 <_Thread_Enable_dispatch>
ts->active = true;
116ad7: 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 );
116adb: 59 pop %ecx
116adc: ff 75 bc pushl -0x44(%ebp)
116adf: e8 30 3a 00 00 call 11a514 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
116ae4: 8d 43 40 lea 0x40(%ebx),%eax
116ae7: 89 04 24 mov %eax,(%esp)
116aea: e8 25 3a 00 00 call 11a514 <_Watchdog_Remove>
116aef: 83 c4 10 add $0x10,%esp
116af2: e9 bc fe ff ff jmp 1169b3 <_Timer_server_Body+0x47>
00116af7 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
116af7: 55 push %ebp
116af8: 89 e5 mov %esp,%ebp
116afa: 57 push %edi
116afb: 56 push %esi
116afc: 53 push %ebx
116afd: 83 ec 2c sub $0x2c,%esp
116b00: 8b 5d 08 mov 0x8(%ebp),%ebx
116b03: 8b 75 0c mov 0xc(%ebp),%esi
if ( ts->insert_chain == NULL ) {
116b06: 8b 43 78 mov 0x78(%ebx),%eax
116b09: 85 c0 test %eax,%eax
116b0b: 0f 85 de 00 00 00 jne 116bef <_Timer_server_Schedule_operation_method+0xf8>
* 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();
116b11: e8 ba fd ff ff call 1168d0 <_Thread_Disable_dispatch>
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
116b16: 8b 46 38 mov 0x38(%esi),%eax
116b19: 83 f8 01 cmp $0x1,%eax
116b1c: 75 5a jne 116b78 <_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 );
116b1e: 9c pushf
116b1f: fa cli
116b20: 8f 45 e0 popl -0x20(%ebp)
snapshot = _Watchdog_Ticks_since_boot;
116b23: 8b 15 f0 d7 13 00 mov 0x13d7f0,%edx
last_snapshot = ts->Interval_watchdogs.last_snapshot;
116b29: 8b 4b 3c mov 0x3c(%ebx),%ecx
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
116b2c: 8b 43 30 mov 0x30(%ebx),%eax
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
116b2f: 8d 7b 34 lea 0x34(%ebx),%edi
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
116b32: 39 f8 cmp %edi,%eax
116b34: 74 19 je 116b4f <_Timer_server_Schedule_operation_method+0x58>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
116b36: 89 d7 mov %edx,%edi
116b38: 29 cf sub %ecx,%edi
116b3a: 89 7d e4 mov %edi,-0x1c(%ebp)
delta_interval = first_watchdog->delta_interval;
116b3d: 8b 78 10 mov 0x10(%eax),%edi
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116b40: 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) {
116b42: 3b 7d e4 cmp -0x1c(%ebp),%edi
116b45: 76 05 jbe 116b4c <_Timer_server_Schedule_operation_method+0x55>
delta_interval -= delta;
116b47: 89 f9 mov %edi,%ecx
116b49: 2b 4d e4 sub -0x1c(%ebp),%ecx
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
116b4c: 89 48 10 mov %ecx,0x10(%eax)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
116b4f: 89 53 3c mov %edx,0x3c(%ebx)
_ISR_Enable( level );
116b52: ff 75 e0 pushl -0x20(%ebp)
116b55: 9d popf
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116b56: 50 push %eax
116b57: 50 push %eax
116b58: 83 c6 10 add $0x10,%esi
116b5b: 56 push %esi
116b5c: 8d 43 30 lea 0x30(%ebx),%eax
116b5f: 50 push %eax
116b60: e8 97 38 00 00 call 11a3fc <_Watchdog_Insert>
if ( !ts->active ) {
116b65: 8a 43 7c mov 0x7c(%ebx),%al
116b68: 83 c4 10 add $0x10,%esp
116b6b: 84 c0 test %al,%al
116b6d: 75 74 jne 116be3 <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_interval_system_watchdog( ts );
116b6f: 89 d8 mov %ebx,%eax
116b71: e8 6a fd ff ff call 1168e0 <_Timer_server_Reset_interval_system_watchdog>
116b76: eb 6b jmp 116be3 <_Timer_server_Schedule_operation_method+0xec>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116b78: 83 f8 03 cmp $0x3,%eax
116b7b: 75 66 jne 116be3 <_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 );
116b7d: 9c pushf
116b7e: fa cli
116b7f: 8f 45 e0 popl -0x20(%ebp)
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
116b82: 8b 15 44 d7 13 00 mov 0x13d744,%edx
last_snapshot = ts->TOD_watchdogs.last_snapshot;
116b88: 8b 43 74 mov 0x74(%ebx),%eax
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
116b8b: 8b 4b 68 mov 0x68(%ebx),%ecx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
116b8e: 8d 7b 6c lea 0x6c(%ebx),%edi
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
116b91: 39 f9 cmp %edi,%ecx
116b93: 74 27 je 116bbc <_Timer_server_Schedule_operation_method+0xc5>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
116b95: 8b 79 10 mov 0x10(%ecx),%edi
116b98: 89 7d d4 mov %edi,-0x2c(%ebp)
if ( snapshot > last_snapshot ) {
116b9b: 39 c2 cmp %eax,%edx
116b9d: 76 15 jbe 116bb4 <_Timer_server_Schedule_operation_method+0xbd>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
116b9f: 89 d7 mov %edx,%edi
116ba1: 29 c7 sub %eax,%edi
116ba3: 89 7d e4 mov %edi,-0x1c(%ebp)
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116ba6: 31 c0 xor %eax,%eax
if ( snapshot > last_snapshot ) {
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
116ba8: 39 7d d4 cmp %edi,-0x2c(%ebp)
116bab: 76 0c jbe 116bb9 <_Timer_server_Schedule_operation_method+0xc2><== NEVER TAKEN
delta_interval -= delta;
116bad: 8b 45 d4 mov -0x2c(%ebp),%eax
116bb0: 29 f8 sub %edi,%eax
116bb2: eb 05 jmp 116bb9 <_Timer_server_Schedule_operation_method+0xc2>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
116bb4: 03 45 d4 add -0x2c(%ebp),%eax
delta_interval += delta;
116bb7: 29 d0 sub %edx,%eax
}
first_watchdog->delta_interval = delta_interval;
116bb9: 89 41 10 mov %eax,0x10(%ecx)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
116bbc: 89 53 74 mov %edx,0x74(%ebx)
_ISR_Enable( level );
116bbf: ff 75 e0 pushl -0x20(%ebp)
116bc2: 9d popf
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116bc3: 57 push %edi
116bc4: 57 push %edi
116bc5: 83 c6 10 add $0x10,%esi
116bc8: 56 push %esi
116bc9: 8d 43 68 lea 0x68(%ebx),%eax
116bcc: 50 push %eax
116bcd: e8 2a 38 00 00 call 11a3fc <_Watchdog_Insert>
if ( !ts->active ) {
116bd2: 8a 43 7c mov 0x7c(%ebx),%al
116bd5: 83 c4 10 add $0x10,%esp
116bd8: 84 c0 test %al,%al
116bda: 75 07 jne 116be3 <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_tod_system_watchdog( ts );
116bdc: 89 d8 mov %ebx,%eax
116bde: e8 43 fd ff ff call 116926 <_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 );
}
}
116be3: 8d 65 f4 lea -0xc(%ebp),%esp
116be6: 5b pop %ebx
116be7: 5e pop %esi
116be8: 5f pop %edi
116be9: c9 leave
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
116bea: e9 e7 26 00 00 jmp 1192d6 <_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 );
116bef: 8b 43 78 mov 0x78(%ebx),%eax
116bf2: 89 75 0c mov %esi,0xc(%ebp)
116bf5: 89 45 08 mov %eax,0x8(%ebp)
}
}
116bf8: 8d 65 f4 lea -0xc(%ebp),%esp
116bfb: 5b pop %ebx
116bfc: 5e pop %esi
116bfd: 5f pop %edi
116bfe: c9 leave
* 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 );
116bff: e9 c8 06 00 00 jmp 1172cc <_Chain_Append>
0010cb7f <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10cb7f: 55 push %ebp
10cb80: 89 e5 mov %esp,%ebp
10cb82: 57 push %edi
10cb83: 56 push %esi
10cb84: 53 push %ebx
10cb85: 83 ec 0c sub $0xc,%esp
10cb88: 8b 7d 10 mov 0x10(%ebp),%edi
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
10cb8b: 8b 1d e0 44 12 00 mov 0x1244e0,%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 );
10cb91: 0f b6 75 0c movzbl 0xc(%ebp),%esi
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
10cb95: eb 15 jmp 10cbac <_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 )
10cb97: 8b 43 30 mov 0x30(%ebx),%eax
10cb9a: 85 c0 test %eax,%eax
10cb9c: 74 0b je 10cba9 <_User_extensions_Fatal+0x2a>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10cb9e: 52 push %edx
10cb9f: 57 push %edi
10cba0: 56 push %esi
10cba1: ff 75 08 pushl 0x8(%ebp)
10cba4: ff d0 call *%eax
10cba6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
10cba9: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
10cbac: 81 fb d8 44 12 00 cmp $0x1244d8,%ebx
10cbb2: 75 e3 jne 10cb97 <_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 );
}
}
10cbb4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10cbb7: 5b pop %ebx <== NOT EXECUTED
10cbb8: 5e pop %esi <== NOT EXECUTED
10cbb9: 5f pop %edi <== NOT EXECUTED
10cbba: c9 leave <== NOT EXECUTED
10cbbb: c3 ret <== NOT EXECUTED
0010ca68 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
10ca68: 55 push %ebp
10ca69: 89 e5 mov %esp,%ebp
10ca6b: 57 push %edi
10ca6c: 56 push %esi
10ca6d: 53 push %ebx
10ca6e: 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;
10ca71: a1 30 02 12 00 mov 0x120230,%eax
10ca76: 89 45 e4 mov %eax,-0x1c(%ebp)
initial_extensions = Configuration.User_extension_table;
10ca79: 8b 35 34 02 12 00 mov 0x120234,%esi
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
10ca7f: c7 05 d8 44 12 00 dc movl $0x1244dc,0x1244d8
10ca86: 44 12 00
the_chain->permanent_null = NULL;
10ca89: c7 05 dc 44 12 00 00 movl $0x0,0x1244dc
10ca90: 00 00 00
the_chain->last = _Chain_Head(the_chain);
10ca93: c7 05 e0 44 12 00 d8 movl $0x1244d8,0x1244e0
10ca9a: 44 12 00
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
10ca9d: c7 05 e8 42 12 00 ec movl $0x1242ec,0x1242e8
10caa4: 42 12 00
the_chain->permanent_null = NULL;
10caa7: c7 05 ec 42 12 00 00 movl $0x0,0x1242ec
10caae: 00 00 00
the_chain->last = _Chain_Head(the_chain);
10cab1: c7 05 f0 42 12 00 e8 movl $0x1242e8,0x1242f0
10cab8: 42 12 00
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10cabb: 85 f6 test %esi,%esi
10cabd: 74 53 je 10cb12 <_User_extensions_Handler_initialization+0xaa><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
10cabf: 6b c8 34 imul $0x34,%eax,%ecx
10cac2: 83 ec 0c sub $0xc,%esp
10cac5: 51 push %ecx
10cac6: 89 4d e0 mov %ecx,-0x20(%ebp)
10cac9: e8 32 04 00 00 call 10cf00 <_Workspace_Allocate_or_fatal_error>
10cace: 89 c3 mov %eax,%ebx
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10cad0: 31 c0 xor %eax,%eax
10cad2: 8b 4d e0 mov -0x20(%ebp),%ecx
10cad5: 89 df mov %ebx,%edi
10cad7: f3 aa rep stos %al,%es:(%edi)
10cad9: 89 f0 mov %esi,%eax
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cadb: 83 c4 10 add $0x10,%esp
10cade: 31 d2 xor %edx,%edx
10cae0: eb 2b jmp 10cb0d <_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;
10cae2: 8d 7b 14 lea 0x14(%ebx),%edi
10cae5: 89 c6 mov %eax,%esi
10cae7: b9 08 00 00 00 mov $0x8,%ecx
10caec: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10caee: 83 ec 0c sub $0xc,%esp
10caf1: 53 push %ebx
10caf2: 89 45 dc mov %eax,-0x24(%ebp)
10caf5: 89 55 e0 mov %edx,-0x20(%ebp)
10caf8: e8 43 30 00 00 call 10fb40 <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
10cafd: 83 c3 34 add $0x34,%ebx
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cb00: 8b 55 e0 mov -0x20(%ebp),%edx
10cb03: 42 inc %edx
10cb04: 8b 45 dc mov -0x24(%ebp),%eax
10cb07: 83 c0 20 add $0x20,%eax
10cb0a: 83 c4 10 add $0x10,%esp
10cb0d: 3b 55 e4 cmp -0x1c(%ebp),%edx
10cb10: 72 d0 jb 10cae2 <_User_extensions_Handler_initialization+0x7a>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
10cb12: 8d 65 f4 lea -0xc(%ebp),%esp
10cb15: 5b pop %ebx
10cb16: 5e pop %esi
10cb17: 5f pop %edi
10cb18: c9 leave
10cb19: c3 ret
0010e4b0 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
10e4b0: 55 push %ebp
10e4b1: 89 e5 mov %esp,%ebp
10e4b3: 57 push %edi
10e4b4: 56 push %esi
10e4b5: 53 push %ebx
10e4b6: 83 ec 1c sub $0x1c,%esp
10e4b9: 8b 75 08 mov 0x8(%ebp),%esi
10e4bc: 8b 7d 0c mov 0xc(%ebp),%edi
10e4bf: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
10e4c2: 9c pushf
10e4c3: fa cli
10e4c4: 58 pop %eax
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
10e4c5: 8b 16 mov (%esi),%edx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10e4c7: 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 ) ) {
10e4ca: 39 ca cmp %ecx,%edx
10e4cc: 74 44 je 10e512 <_Watchdog_Adjust+0x62>
switch ( direction ) {
10e4ce: 85 ff test %edi,%edi
10e4d0: 74 3c je 10e50e <_Watchdog_Adjust+0x5e>
10e4d2: 4f dec %edi
10e4d3: 75 3d jne 10e512 <_Watchdog_Adjust+0x62> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
10e4d5: 01 5a 10 add %ebx,0x10(%edx)
break;
10e4d8: eb 38 jmp 10e512 <_Watchdog_Adjust+0x62>
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) header->first );
10e4da: 8b 16 mov (%esi),%edx
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
10e4dc: 8b 7a 10 mov 0x10(%edx),%edi
10e4df: 39 fb cmp %edi,%ebx
10e4e1: 73 07 jae 10e4ea <_Watchdog_Adjust+0x3a>
_Watchdog_First( header )->delta_interval -= units;
10e4e3: 29 df sub %ebx,%edi
10e4e5: 89 7a 10 mov %edi,0x10(%edx)
break;
10e4e8: eb 28 jmp 10e512 <_Watchdog_Adjust+0x62>
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
10e4ea: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx)
_ISR_Enable( level );
10e4f1: 50 push %eax
10e4f2: 9d popf
_Watchdog_Tickle( header );
10e4f3: 83 ec 0c sub $0xc,%esp
10e4f6: 56 push %esi
10e4f7: 89 4d e4 mov %ecx,-0x1c(%ebp)
10e4fa: e8 9d 01 00 00 call 10e69c <_Watchdog_Tickle>
_ISR_Disable( level );
10e4ff: 9c pushf
10e500: fa cli
10e501: 58 pop %eax
if ( _Chain_Is_empty( header ) )
10e502: 83 c4 10 add $0x10,%esp
10e505: 8b 4d e4 mov -0x1c(%ebp),%ecx
10e508: 39 0e cmp %ecx,(%esi)
10e50a: 74 06 je 10e512 <_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;
10e50c: 29 fb sub %edi,%ebx
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10e50e: 85 db test %ebx,%ebx
10e510: 75 c8 jne 10e4da <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
10e512: 50 push %eax
10e513: 9d popf
}
10e514: 8d 65 f4 lea -0xc(%ebp),%esp
10e517: 5b pop %ebx
10e518: 5e pop %esi
10e519: 5f pop %edi
10e51a: c9 leave
10e51b: c3 ret
0010cdb8 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10cdb8: 55 push %ebp
10cdb9: 89 e5 mov %esp,%ebp
10cdbb: 56 push %esi
10cdbc: 53 push %ebx
10cdbd: 8b 55 08 mov 0x8(%ebp),%edx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10cdc0: 9c pushf
10cdc1: fa cli
10cdc2: 5e pop %esi
previous_state = the_watchdog->state;
10cdc3: 8b 42 08 mov 0x8(%edx),%eax
switch ( previous_state ) {
10cdc6: 83 f8 01 cmp $0x1,%eax
10cdc9: 74 09 je 10cdd4 <_Watchdog_Remove+0x1c>
10cdcb: 72 42 jb 10ce0f <_Watchdog_Remove+0x57>
10cdcd: 83 f8 03 cmp $0x3,%eax
10cdd0: 77 3d ja 10ce0f <_Watchdog_Remove+0x57> <== NEVER TAKEN
10cdd2: eb 09 jmp 10cddd <_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;
10cdd4: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
break;
10cddb: eb 32 jmp 10ce0f <_Watchdog_Remove+0x57>
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10cddd: 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 );
}
10cde4: 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) )
10cde6: 83 39 00 cmpl $0x0,(%ecx)
10cde9: 74 06 je 10cdf1 <_Watchdog_Remove+0x39>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10cdeb: 8b 5a 10 mov 0x10(%edx),%ebx
10cdee: 01 59 10 add %ebx,0x10(%ecx)
if ( _Watchdog_Sync_count )
10cdf1: 8b 1d 18 44 12 00 mov 0x124418,%ebx
10cdf7: 85 db test %ebx,%ebx
10cdf9: 74 0c je 10ce07 <_Watchdog_Remove+0x4f>
_Watchdog_Sync_level = _ISR_Nest_level;
10cdfb: 8b 1d 30 48 12 00 mov 0x124830,%ebx
10ce01: 89 1d 90 43 12 00 mov %ebx,0x124390
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10ce07: 8b 5a 04 mov 0x4(%edx),%ebx
next->previous = previous;
10ce0a: 89 59 04 mov %ebx,0x4(%ecx)
previous->next = next;
10ce0d: 89 0b mov %ecx,(%ebx)
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10ce0f: 8b 0d 1c 44 12 00 mov 0x12441c,%ecx
10ce15: 89 4a 18 mov %ecx,0x18(%edx)
_ISR_Enable( level );
10ce18: 56 push %esi
10ce19: 9d popf
return( previous_state );
}
10ce1a: 5b pop %ebx
10ce1b: 5e pop %esi
10ce1c: c9 leave
10ce1d: c3 ret
0010e040 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
10e040: 55 push %ebp
10e041: 89 e5 mov %esp,%ebp
10e043: 57 push %edi
10e044: 56 push %esi
10e045: 53 push %ebx
10e046: 83 ec 20 sub $0x20,%esp
10e049: 8b 7d 08 mov 0x8(%ebp),%edi
10e04c: 8b 75 0c mov 0xc(%ebp),%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
10e04f: 9c pushf
10e050: fa cli
10e051: 8f 45 e4 popl -0x1c(%ebp)
printk( "Watchdog Chain: %s %p\n", name, header );
10e054: 56 push %esi
10e055: 57 push %edi
10e056: 68 80 0f 12 00 push $0x120f80
10e05b: e8 88 aa ff ff call 108ae8 <printk>
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
10e060: 8b 1e mov (%esi),%ebx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10e062: 83 c6 04 add $0x4,%esi
if ( !_Chain_Is_empty( header ) ) {
10e065: 83 c4 10 add $0x10,%esp
10e068: 39 f3 cmp %esi,%ebx
10e06a: 74 1d je 10e089 <_Watchdog_Report_chain+0x49>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
10e06c: 52 push %edx
10e06d: 52 push %edx
10e06e: 53 push %ebx
10e06f: 6a 00 push $0x0
10e071: e8 32 00 00 00 call 10e0a8 <_Watchdog_Report>
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = header->first ;
node != _Chain_Tail(header) ;
node = node->next )
10e076: 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 = header->first ;
10e078: 83 c4 10 add $0x10,%esp
10e07b: 39 f3 cmp %esi,%ebx
10e07d: 75 ed jne 10e06c <_Watchdog_Report_chain+0x2c><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
10e07f: 50 push %eax
10e080: 50 push %eax
10e081: 57 push %edi
10e082: 68 97 0f 12 00 push $0x120f97
10e087: eb 08 jmp 10e091 <_Watchdog_Report_chain+0x51>
} else {
printk( "Chain is empty\n" );
10e089: 83 ec 0c sub $0xc,%esp
10e08c: 68 a6 0f 12 00 push $0x120fa6
10e091: e8 52 aa ff ff call 108ae8 <printk>
10e096: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10e099: ff 75 e4 pushl -0x1c(%ebp)
10e09c: 9d popf
}
10e09d: 8d 65 f4 lea -0xc(%ebp),%esp
10e0a0: 5b pop %ebx
10e0a1: 5e pop %esi
10e0a2: 5f pop %edi
10e0a3: c9 leave
10e0a4: c3 ret
0010b1d8 <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
10b1d8: 55 push %ebp
10b1d9: 89 e5 mov %esp,%ebp
10b1db: 57 push %edi
10b1dc: 56 push %esi
10b1dd: 53 push %ebx
10b1de: 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 );
10b1e1: ff 75 0c pushl 0xc(%ebp)
10b1e4: e8 5e ed ff ff call 109f47 <rtems_filesystem_dirname>
10b1e9: 89 45 94 mov %eax,-0x6c(%ebp)
if ( old_parent_pathlen == 0 )
10b1ec: 83 c4 10 add $0x10,%esp
10b1ef: 85 c0 test %eax,%eax
10b1f1: 8d 45 b8 lea -0x48(%ebp),%eax
10b1f4: 75 15 jne 10b20b <_rename_r+0x33>
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
10b1f6: 51 push %ecx
10b1f7: 50 push %eax
10b1f8: 8d 45 e4 lea -0x1c(%ebp),%eax
10b1fb: 50 push %eax
10b1fc: ff 75 0c pushl 0xc(%ebp)
10b1ff: e8 48 03 00 00 call 10b54c <rtems_filesystem_get_start_loc>
10b204: 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;
10b207: 31 db xor %ebx,%ebx
10b209: eb 23 jmp 10b22e <_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,
10b20b: 83 ec 0c sub $0xc,%esp
10b20e: 6a 00 push $0x0
10b210: 50 push %eax
10b211: 6a 02 push $0x2
10b213: ff 75 94 pushl -0x6c(%ebp)
10b216: ff 75 0c pushl 0xc(%ebp)
10b219: e8 e8 ec ff ff call 109f06 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
10b21e: 83 c4 20 add $0x20,%esp
return -1;
10b221: 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 )
10b224: 85 c0 test %eax,%eax
10b226: 0f 85 50 01 00 00 jne 10b37c <_rename_r+0x1a4> <== NEVER TAKEN
return -1;
free_old_parentloc = true;
10b22c: b3 01 mov $0x1,%bl
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
10b22e: 8d 7d cc lea -0x34(%ebp),%edi
10b231: 8d 75 b8 lea -0x48(%ebp),%esi
10b234: b9 05 00 00 00 mov $0x5,%ecx
10b239: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = old + old_parent_pathlen;
10b23b: 8b 75 0c mov 0xc(%ebp),%esi
10b23e: 03 75 94 add -0x6c(%ebp),%esi
10b241: 89 75 e0 mov %esi,-0x20(%ebp)
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
10b244: 83 c9 ff or $0xffffffff,%ecx
10b247: 89 f7 mov %esi,%edi
10b249: 31 c0 xor %eax,%eax
10b24b: f2 ae repnz scas %es:(%edi),%al
10b24d: f7 d1 not %ecx
10b24f: 49 dec %ecx
10b250: 52 push %edx
10b251: 52 push %edx
10b252: 51 push %ecx
10b253: 56 push %esi
10b254: e8 2d ed ff ff call 109f86 <rtems_filesystem_prefix_separators>
10b259: 01 c6 add %eax,%esi
10b25b: 89 75 e0 mov %esi,-0x20(%ebp)
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
10b25e: 83 c9 ff or $0xffffffff,%ecx
10b261: 89 f7 mov %esi,%edi
10b263: 31 c0 xor %eax,%eax
10b265: f2 ae repnz scas %es:(%edi),%al
10b267: f7 d1 not %ecx
10b269: 49 dec %ecx
10b26a: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10b271: 8d 7d cc lea -0x34(%ebp),%edi
10b274: 57 push %edi
10b275: 6a 00 push $0x0
10b277: 51 push %ecx
10b278: 56 push %esi
10b279: e8 2a ec ff ff call 109ea8 <rtems_filesystem_evaluate_relative_path>
0, &old_loc, false );
if ( result != 0 ) {
10b27e: 83 c4 20 add $0x20,%esp
10b281: 85 c0 test %eax,%eax
10b283: 74 16 je 10b29b <_rename_r+0xc3>
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
return -1;
10b285: 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 )
10b288: 84 db test %bl,%bl
10b28a: 0f 84 ec 00 00 00 je 10b37c <_rename_r+0x1a4> <== NEVER TAKEN
rtems_filesystem_freenode( &old_parent_loc );
10b290: 83 ec 0c sub $0xc,%esp
10b293: 8d 45 b8 lea -0x48(%ebp),%eax
10b296: e9 d8 00 00 00 jmp 10b373 <_rename_r+0x19b>
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
10b29b: 50 push %eax
10b29c: 8d 75 a4 lea -0x5c(%ebp),%esi
10b29f: 56 push %esi
10b2a0: 8d 45 e4 lea -0x1c(%ebp),%eax
10b2a3: 50 push %eax
10b2a4: ff 75 10 pushl 0x10(%ebp)
10b2a7: e8 a0 02 00 00 call 10b54c <rtems_filesystem_get_start_loc>
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
10b2ac: 83 c4 0c add $0xc,%esp
10b2af: 8d 45 e0 lea -0x20(%ebp),%eax
10b2b2: 50 push %eax
10b2b3: 56 push %esi
10b2b4: 8b 45 10 mov 0x10(%ebp),%eax
10b2b7: 03 45 e4 add -0x1c(%ebp),%eax
10b2ba: 50 push %eax
10b2bb: 8b 45 b0 mov -0x50(%ebp),%eax
10b2be: ff 50 04 call *0x4(%eax)
if ( result != 0 ) {
10b2c1: 83 c4 10 add $0x10,%esp
10b2c4: 85 c0 test %eax,%eax
10b2c6: 74 2d je 10b2f5 <_rename_r+0x11d>
rtems_filesystem_freenode( &new_parent_loc );
10b2c8: 83 ec 0c sub $0xc,%esp
10b2cb: 56 push %esi
10b2cc: e8 43 ee ff ff call 10a114 <rtems_filesystem_freenode>
if ( free_old_parentloc )
10b2d1: 83 c4 10 add $0x10,%esp
10b2d4: 84 db test %bl,%bl
10b2d6: 74 0f je 10b2e7 <_rename_r+0x10f> <== NEVER TAKEN
rtems_filesystem_freenode( &old_parent_loc );
10b2d8: 83 ec 0c sub $0xc,%esp
10b2db: 8d 45 b8 lea -0x48(%ebp),%eax
10b2de: 50 push %eax
10b2df: e8 30 ee ff ff call 10a114 <rtems_filesystem_freenode>
10b2e4: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &old_loc );
10b2e7: 83 ec 0c sub $0xc,%esp
10b2ea: 8d 45 cc lea -0x34(%ebp),%eax
10b2ed: 50 push %eax
10b2ee: e8 21 ee ff ff call 10a114 <rtems_filesystem_freenode>
10b2f3: eb 3e jmp 10b333 <_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 ) {
10b2f5: 8b 45 b4 mov -0x4c(%ebp),%eax
10b2f8: 39 45 c8 cmp %eax,-0x38(%ebp)
10b2fb: 74 3e je 10b33b <_rename_r+0x163>
rtems_filesystem_freenode( &new_parent_loc );
10b2fd: 83 ec 0c sub $0xc,%esp
10b300: 56 push %esi
10b301: e8 0e ee ff ff call 10a114 <rtems_filesystem_freenode>
if ( free_old_parentloc )
10b306: 83 c4 10 add $0x10,%esp
10b309: 84 db test %bl,%bl
10b30b: 74 0f je 10b31c <_rename_r+0x144>
rtems_filesystem_freenode( &old_parent_loc );
10b30d: 83 ec 0c sub $0xc,%esp
10b310: 8d 45 b8 lea -0x48(%ebp),%eax
10b313: 50 push %eax
10b314: e8 fb ed ff ff call 10a114 <rtems_filesystem_freenode>
10b319: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &old_loc );
10b31c: 83 ec 0c sub $0xc,%esp
10b31f: 8d 45 cc lea -0x34(%ebp),%eax
10b322: 50 push %eax
10b323: e8 ec ed ff ff call 10a114 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
10b328: e8 27 95 00 00 call 114854 <__errno>
10b32d: c7 00 12 00 00 00 movl $0x12,(%eax)
10b333: 83 c4 10 add $0x10,%esp
10b336: 83 cf ff or $0xffffffff,%edi
10b339: eb 41 jmp 10b37c <_rename_r+0x1a4>
}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
10b33b: ff 75 e0 pushl -0x20(%ebp)
10b33e: 56 push %esi
10b33f: 57 push %edi
10b340: 8d 55 b8 lea -0x48(%ebp),%edx
10b343: 52 push %edx
10b344: 8b 45 b0 mov -0x50(%ebp),%eax
10b347: 89 55 90 mov %edx,-0x70(%ebp)
10b34a: ff 50 40 call *0x40(%eax)
10b34d: 89 c7 mov %eax,%edi
rtems_filesystem_freenode( &new_parent_loc );
10b34f: 89 34 24 mov %esi,(%esp)
10b352: e8 bd ed ff ff call 10a114 <rtems_filesystem_freenode>
if ( free_old_parentloc )
10b357: 83 c4 10 add $0x10,%esp
10b35a: 84 db test %bl,%bl
10b35c: 8b 55 90 mov -0x70(%ebp),%edx
10b35f: 74 0c je 10b36d <_rename_r+0x195>
rtems_filesystem_freenode( &old_parent_loc );
10b361: 83 ec 0c sub $0xc,%esp
10b364: 52 push %edx
10b365: e8 aa ed ff ff call 10a114 <rtems_filesystem_freenode>
10b36a: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &old_loc );
10b36d: 83 ec 0c sub $0xc,%esp
10b370: 8d 45 cc lea -0x34(%ebp),%eax
10b373: 50 push %eax
10b374: e8 9b ed ff ff call 10a114 <rtems_filesystem_freenode>
return result;
10b379: 83 c4 10 add $0x10,%esp
}
10b37c: 89 f8 mov %edi,%eax
10b37e: 8d 65 f4 lea -0xc(%ebp),%esp
10b381: 5b pop %ebx
10b382: 5e pop %esi
10b383: 5f pop %edi
10b384: c9 leave
10b385: c3 ret
0010a7c0 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
10a7c0: 55 push %ebp
10a7c1: 89 e5 mov %esp,%ebp
10a7c3: 57 push %edi
10a7c4: 56 push %esi
10a7c5: 53 push %ebx
10a7c6: 83 ec 18 sub $0x18,%esp
10a7c9: 8b 75 08 mov 0x8(%ebp),%esi
10a7cc: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
10a7cf: 68 78 72 12 00 push $0x127278
10a7d4: e8 0b 10 00 00 call 10b7e4 <pthread_mutex_lock>
if (aiocbp == NULL)
10a7d9: 83 c4 10 add $0x10,%esp
10a7dc: 85 db test %ebx,%ebx
10a7de: 0f 85 05 01 00 00 jne 10a8e9 <aio_cancel+0x129>
{
if (fcntl (fildes, F_GETFL) < 0) {
10a7e4: 53 push %ebx
10a7e5: 53 push %ebx
10a7e6: 6a 03 push $0x3
10a7e8: 56 push %esi
10a7e9: e8 9e 5f 00 00 call 11078c <fcntl>
10a7ee: 83 c4 10 add $0x10,%esp
10a7f1: 85 c0 test %eax,%eax
10a7f3: 79 1d jns 10a812 <aio_cancel+0x52> <== NEVER TAKEN
pthread_mutex_unlock(&aio_request_queue.mutex);
10a7f5: 83 ec 0c sub $0xc,%esp
10a7f8: 68 78 72 12 00 push $0x127278
10a7fd: e8 62 10 00 00 call 10b864 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
10a802: e8 35 8e 00 00 call 11363c <__errno>
10a807: c7 00 09 00 00 00 movl $0x9,(%eax)
10a80d: e9 f5 00 00 00 jmp 10a907 <aio_cancel+0x147>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
10a812: 51 push %ecx <== NOT EXECUTED
10a813: 6a 00 push $0x0 <== NOT EXECUTED
10a815: 56 push %esi <== NOT EXECUTED
10a816: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED
10a81b: e8 20 03 00 00 call 10ab40 <rtems_aio_search_fd> <== NOT EXECUTED
10a820: 89 c3 mov %eax,%ebx <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
10a822: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a825: 85 c0 test %eax,%eax <== NOT EXECUTED
10a827: 0f 85 82 00 00 00 jne 10a8af <aio_cancel+0xef> <== NOT EXECUTED
{
if (!rtems_chain_is_empty (&aio_request_queue.idle_req))
10a82d: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED
10a834: 72 12 00
10a837: 74 5c je 10a895 <aio_cancel+0xd5> <== NOT EXECUTED
{
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
10a839: 52 push %edx <== NOT EXECUTED
10a83a: 6a 00 push $0x0 <== NOT EXECUTED
10a83c: 56 push %esi <== NOT EXECUTED
10a83d: 68 cc 72 12 00 push $0x1272cc <== NOT EXECUTED
10a842: e8 f9 02 00 00 call 10ab40 <rtems_aio_search_fd> <== NOT EXECUTED
10a847: 89 c3 mov %eax,%ebx <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL) {
10a849: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a84c: 85 c0 test %eax,%eax <== NOT EXECUTED
10a84e: 75 17 jne 10a867 <aio_cancel+0xa7> <== NOT EXECUTED
pthread_mutex_unlock(&aio_request_queue.mutex);
10a850: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a853: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10a858: e8 07 10 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
10a85d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a860: b3 02 mov $0x2,%bl <== NOT EXECUTED
10a862: e9 1b 01 00 00 jmp 10a982 <aio_cancel+0x1c2> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10a867: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a86a: 50 push %eax <== NOT EXECUTED
10a86b: e8 d0 26 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED
}
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10a870: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10a873: e8 07 06 00 00 call 10ae7f <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_destroy (&r_chain->mutex);
10a878: 8d 73 1c lea 0x1c(%ebx),%esi <== NOT EXECUTED
10a87b: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10a87e: e8 41 0d 00 00 call 10b5c4 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->mutex);
10a883: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10a886: e8 45 0a 00 00 call 10b2d0 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
10a88b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10a88e: e8 ad d4 ff ff call 107d40 <free> <== NOT EXECUTED
10a893: eb 3e jmp 10a8d3 <aio_cancel+0x113> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
}
pthread_mutex_unlock (&aio_request_queue.mutex);
10a895: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a898: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10a89d: e8 c2 0f 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
10a8a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a8a5: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED
10a8aa: e9 d3 00 00 00 jmp 10a982 <aio_cancel+0x1c2> <== NOT EXECUTED
}
pthread_mutex_lock (&r_chain->mutex);
10a8af: 8d 70 1c lea 0x1c(%eax),%esi <== NOT EXECUTED
10a8b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a8b5: 56 push %esi <== NOT EXECUTED
10a8b6: e8 29 0f 00 00 call 10b7e4 <pthread_mutex_lock> <== NOT EXECUTED
10a8bb: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10a8be: e8 7d 26 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10a8c3: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10a8c6: e8 b4 05 00 00 call 10ae7f <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
10a8cb: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10a8ce: e8 91 0f 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
10a8d3: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED
10a8da: e8 85 0f 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
10a8df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a8e2: 31 db xor %ebx,%ebx <== NOT EXECUTED
10a8e4: e9 99 00 00 00 jmp 10a982 <aio_cancel+0x1c2> <== NOT EXECUTED
}
else
{
if (aiocbp->aio_fildes != fildes) {
10a8e9: 8b 3b mov (%ebx),%edi
10a8eb: 39 f7 cmp %esi,%edi
10a8ed: 74 20 je 10a90f <aio_cancel+0x14f> <== NEVER TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
10a8ef: 83 ec 0c sub $0xc,%esp
10a8f2: 68 78 72 12 00 push $0x127278
10a8f7: e8 68 0f 00 00 call 10b864 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
10a8fc: e8 3b 8d 00 00 call 11363c <__errno>
10a901: c7 00 16 00 00 00 movl $0x16,(%eax)
10a907: 83 c4 10 add $0x10,%esp
10a90a: 83 cb ff or $0xffffffff,%ebx
10a90d: eb 73 jmp 10a982 <aio_cancel+0x1c2>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
10a90f: 50 push %eax
10a910: 6a 00 push $0x0
10a912: 57 push %edi <== NOT EXECUTED
10a913: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED
10a918: e8 23 02 00 00 call 10ab40 <rtems_aio_search_fd> <== NOT EXECUTED
10a91d: 89 c6 mov %eax,%esi <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
10a91f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a922: 85 c0 test %eax,%eax <== NOT EXECUTED
10a924: 75 2e jne 10a954 <aio_cancel+0x194> <== NOT EXECUTED
if (!rtems_chain_is_empty (&aio_request_queue.idle_req))
10a926: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED
10a92d: 72 12 00
10a930: 74 22 je 10a954 <aio_cancel+0x194> <== NOT EXECUTED
{
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
10a932: 56 push %esi <== NOT EXECUTED
10a933: 6a 00 push $0x0 <== NOT EXECUTED
10a935: 57 push %edi <== NOT EXECUTED
10a936: 68 cc 72 12 00 push $0x1272cc <== NOT EXECUTED
10a93b: e8 00 02 00 00 call 10ab40 <rtems_aio_search_fd> <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
10a940: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a943: 85 c0 test %eax,%eax <== NOT EXECUTED
10a945: 74 a8 je 10a8ef <aio_cancel+0x12f> <== NOT EXECUTED
{
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp);
10a947: 51 push %ecx <== NOT EXECUTED
10a948: 51 push %ecx <== NOT EXECUTED
10a949: 53 push %ebx <== NOT EXECUTED
10a94a: 50 push %eax <== NOT EXECUTED
10a94b: e8 6f 05 00 00 call 10aebf <rtems_aio_remove_req> <== NOT EXECUTED
10a950: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10a952: eb 1f jmp 10a973 <aio_cancel+0x1b3> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
pthread_mutex_lock (&r_chain->mutex);
10a954: 8d 7e 1c lea 0x1c(%esi),%edi <== NOT EXECUTED
10a957: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a95a: 57 push %edi <== NOT EXECUTED
10a95b: e8 84 0e 00 00 call 10b7e4 <pthread_mutex_lock> <== NOT EXECUTED
result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp);
10a960: 58 pop %eax <== NOT EXECUTED
10a961: 5a pop %edx <== NOT EXECUTED
10a962: 53 push %ebx <== NOT EXECUTED
10a963: 56 push %esi <== NOT EXECUTED
10a964: e8 56 05 00 00 call 10aebf <rtems_aio_remove_req> <== NOT EXECUTED
10a969: 89 c3 mov %eax,%ebx <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
10a96b: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10a96e: e8 f1 0e 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
10a973: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED
10a97a: e8 e5 0e 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10a97f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return AIO_ALLDONE;
}
10a982: 89 d8 mov %ebx,%eax
10a984: 8d 65 f4 lea -0xc(%ebp),%esp
10a987: 5b pop %ebx
10a988: 5e pop %esi
10a989: 5f pop %edi
10a98a: c9 leave
10a98b: c3 ret
0010a998 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
10a998: 55 push %ebp
10a999: 89 e5 mov %esp,%ebp
10a99b: 53 push %ebx
10a99c: 83 ec 04 sub $0x4,%esp
10a99f: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
10a9a2: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp)
10a9a9: 74 1b je 10a9c6 <aio_fsync+0x2e>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10a9ab: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10a9b2: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10a9b9: e8 7e 8c 00 00 call 11363c <__errno>
10a9be: c7 00 16 00 00 00 movl $0x16,(%eax)
10a9c4: eb 74 jmp 10aa3a <aio_fsync+0xa2>
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10a9c6: 50 push %eax
10a9c7: 50 push %eax
10a9c8: 6a 03 push $0x3
10a9ca: ff 33 pushl (%ebx)
10a9cc: e8 bb 5d 00 00 call 11078c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10a9d1: 83 e0 03 and $0x3,%eax
10a9d4: 48 dec %eax
10a9d5: 83 c4 10 add $0x10,%esp
10a9d8: 83 f8 01 cmp $0x1,%eax
10a9db: 76 1b jbe 10a9f8 <aio_fsync+0x60> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10a9dd: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10a9e4: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10a9eb: e8 4c 8c 00 00 call 11363c <__errno>
10a9f0: c7 00 09 00 00 00 movl $0x9,(%eax)
10a9f6: eb 42 jmp 10aa3a <aio_fsync+0xa2>
req = malloc (sizeof (rtems_aio_request));
10a9f8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a9fb: 6a 18 push $0x18 <== NOT EXECUTED
10a9fd: e8 c2 d7 ff ff call 1081c4 <malloc> <== NOT EXECUTED
if (req == NULL)
10aa02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10aa05: 85 c0 test %eax,%eax <== NOT EXECUTED
10aa07: 75 1b jne 10aa24 <aio_fsync+0x8c> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10aa09: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10aa10: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10aa17: e8 20 8c 00 00 call 11363c <__errno> <== NOT EXECUTED
10aa1c: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10aa22: eb 16 jmp 10aa3a <aio_fsync+0xa2> <== NOT EXECUTED
req->aiocbp = aiocbp;
10aa24: 89 58 14 mov %ebx,0x14(%eax) <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_SYNC;
10aa27: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx) <== NOT EXECUTED
return rtems_aio_enqueue (req);
10aa2e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
10aa31: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10aa34: c9 leave <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
10aa35: e9 d7 04 00 00 jmp 10af11 <rtems_aio_enqueue> <== NOT EXECUTED
}
10aa3a: 83 c8 ff or $0xffffffff,%eax
10aa3d: 8b 5d fc mov -0x4(%ebp),%ebx
10aa40: c9 leave
10aa41: c3 ret
0010b10c <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
10b10c: 55 push %ebp
10b10d: 89 e5 mov %esp,%ebp
10b10f: 53 push %ebx
10b110: 83 ec 0c sub $0xc,%esp
10b113: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10b116: 6a 03 push $0x3
10b118: ff 33 pushl (%ebx)
10b11a: e8 6d 56 00 00 call 11078c <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10b11f: 83 e0 03 and $0x3,%eax
10b122: 83 c4 10 add $0x10,%esp
10b125: 83 f8 02 cmp $0x2,%eax
10b128: 74 1f je 10b149 <aio_read+0x3d>
10b12a: 85 c0 test %eax,%eax
10b12c: 74 1b je 10b149 <aio_read+0x3d> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10b12e: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10b135: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b13c: e8 fb 84 00 00 call 11363c <__errno>
10b141: c7 00 09 00 00 00 movl $0x9,(%eax)
10b147: eb 69 jmp 10b1b2 <aio_read+0xa6>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10b149: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10b14d: 75 06 jne 10b155 <aio_read+0x49>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10b14f: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10b153: 79 1b jns 10b170 <aio_read+0x64>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10b155: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10b15c: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b163: e8 d4 84 00 00 call 11363c <__errno>
10b168: c7 00 16 00 00 00 movl $0x16,(%eax)
10b16e: eb 42 jmp 10b1b2 <aio_read+0xa6>
req = malloc (sizeof (rtems_aio_request));
10b170: 83 ec 0c sub $0xc,%esp
10b173: 6a 18 push $0x18
10b175: e8 4a d0 ff ff call 1081c4 <malloc>
if (req == NULL)
10b17a: 83 c4 10 add $0x10,%esp
10b17d: 85 c0 test %eax,%eax
10b17f: 75 1b jne 10b19c <aio_read+0x90> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10b181: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10b188: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10b18f: e8 a8 84 00 00 call 11363c <__errno> <== NOT EXECUTED
10b194: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10b19a: eb 16 jmp 10b1b2 <aio_read+0xa6> <== NOT EXECUTED
req->aiocbp = aiocbp;
10b19c: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_READ;
10b19f: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx)
return rtems_aio_enqueue (req);
10b1a6: 89 45 08 mov %eax,0x8(%ebp)
}
10b1a9: 8b 5d fc mov -0x4(%ebp),%ebx
10b1ac: 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);
10b1ad: e9 5f fd ff ff jmp 10af11 <rtems_aio_enqueue>
}
10b1b2: 83 c8 ff or $0xffffffff,%eax
10b1b5: 8b 5d fc mov -0x4(%ebp),%ebx
10b1b8: c9 leave
10b1b9: c3 ret
0010b1c8 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
10b1c8: 55 push %ebp
10b1c9: 89 e5 mov %esp,%ebp
10b1cb: 53 push %ebx
10b1cc: 83 ec 0c sub $0xc,%esp
10b1cf: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10b1d2: 6a 03 push $0x3
10b1d4: ff 33 pushl (%ebx)
10b1d6: e8 b1 55 00 00 call 11078c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10b1db: 83 e0 03 and $0x3,%eax
10b1de: 48 dec %eax
10b1df: 83 c4 10 add $0x10,%esp
10b1e2: 83 f8 01 cmp $0x1,%eax
10b1e5: 76 1b jbe 10b202 <aio_write+0x3a>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10b1e7: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10b1ee: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b1f5: e8 42 84 00 00 call 11363c <__errno>
10b1fa: c7 00 09 00 00 00 movl $0x9,(%eax)
10b200: eb 69 jmp 10b26b <aio_write+0xa3>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10b202: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10b206: 75 06 jne 10b20e <aio_write+0x46>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10b208: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10b20c: 79 1b jns 10b229 <aio_write+0x61>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10b20e: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10b215: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b21c: e8 1b 84 00 00 call 11363c <__errno>
10b221: c7 00 16 00 00 00 movl $0x16,(%eax)
10b227: eb 42 jmp 10b26b <aio_write+0xa3>
req = malloc (sizeof (rtems_aio_request));
10b229: 83 ec 0c sub $0xc,%esp
10b22c: 6a 18 push $0x18
10b22e: e8 91 cf ff ff call 1081c4 <malloc>
if (req == NULL)
10b233: 83 c4 10 add $0x10,%esp
10b236: 85 c0 test %eax,%eax
10b238: 75 1b jne 10b255 <aio_write+0x8d> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10b23a: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10b241: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10b248: e8 ef 83 00 00 call 11363c <__errno> <== NOT EXECUTED
10b24d: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10b253: eb 16 jmp 10b26b <aio_write+0xa3> <== NOT EXECUTED
req->aiocbp = aiocbp;
10b255: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
10b258: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx)
return rtems_aio_enqueue (req);
10b25f: 89 45 08 mov %eax,0x8(%ebp)
}
10b262: 8b 5d fc mov -0x4(%ebp),%ebx
10b265: 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);
10b266: e9 a6 fc ff ff jmp 10af11 <rtems_aio_enqueue>
}
10b26b: 83 c8 ff or $0xffffffff,%eax
10b26e: 8b 5d fc mov -0x4(%ebp),%ebx
10b271: c9 leave
10b272: c3 ret
00107528 <chroot>:
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
107528: 55 push %ebp
107529: 89 e5 mov %esp,%ebp
10752b: 57 push %edi
10752c: 56 push %esi
10752d: 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) {
107530: 81 3d 3c 30 12 00 c8 cmpl $0x1251c8,0x12303c
107537: 51 12 00
10753a: 75 1e jne 10755a <chroot+0x32>
rtems_libio_set_private_env(); /* try to set a new private env*/
10753c: e8 cc 10 00 00 call 10860d <rtems_libio_set_private_env>
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
107541: 81 3d 3c 30 12 00 c8 cmpl $0x1251c8,0x12303c
107548: 51 12 00
10754b: 75 0d jne 10755a <chroot+0x32>
rtems_set_errno_and_return_minus_one( ENOTSUP );
10754d: e8 32 a3 00 00 call 111884 <__errno>
107552: c7 00 86 00 00 00 movl $0x86,(%eax)
107558: eb 22 jmp 10757c <chroot+0x54>
}
result = chdir(pathname);
10755a: 83 ec 0c sub $0xc,%esp
10755d: ff 75 08 pushl 0x8(%ebp)
107560: e8 67 73 00 00 call 10e8cc <chdir>
if (result) {
107565: 83 c4 10 add $0x10,%esp
107568: 85 c0 test %eax,%eax
10756a: 74 15 je 107581 <chroot+0x59>
rtems_set_errno_and_return_minus_one( errno );
10756c: e8 13 a3 00 00 call 111884 <__errno>
107571: 89 c6 mov %eax,%esi
107573: e8 0c a3 00 00 call 111884 <__errno>
107578: 8b 00 mov (%eax),%eax
10757a: 89 06 mov %eax,(%esi)
10757c: 83 c8 ff or $0xffffffff,%eax
10757f: eb 44 jmp 1075c5 <chroot+0x9d>
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
107581: 83 ec 0c sub $0xc,%esp
107584: 6a 00 push $0x0
107586: 8d 75 e4 lea -0x1c(%ebp),%esi
107589: 56 push %esi
10758a: 6a 00 push $0x0
10758c: 6a 01 push $0x1
10758e: 68 6e f3 11 00 push $0x11f36e
107593: e8 02 01 00 00 call 10769a <rtems_filesystem_evaluate_path>
107598: 83 c4 20 add $0x20,%esp
10759b: 85 c0 test %eax,%eax
10759d: 75 cd jne 10756c <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);
10759f: 83 ec 0c sub $0xc,%esp
1075a2: a1 3c 30 12 00 mov 0x12303c,%eax
1075a7: 83 c0 18 add $0x18,%eax
1075aa: 50 push %eax
1075ab: e8 a8 01 00 00 call 107758 <rtems_filesystem_freenode>
rtems_filesystem_root = loc;
1075b0: 8b 3d 3c 30 12 00 mov 0x12303c,%edi
1075b6: 83 c7 18 add $0x18,%edi
1075b9: b9 05 00 00 00 mov $0x5,%ecx
1075be: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
1075c0: 83 c4 10 add $0x10,%esp
1075c3: 31 c0 xor %eax,%eax
}
1075c5: 8d 65 f8 lea -0x8(%ebp),%esp
1075c8: 5e pop %esi
1075c9: 5f pop %edi
1075ca: c9 leave
1075cb: c3 ret
00109f94 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
109f94: 55 push %ebp
109f95: 89 e5 mov %esp,%ebp
109f97: 83 ec 08 sub $0x8,%esp
109f9a: 8b 45 08 mov 0x8(%ebp),%eax
109f9d: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
109fa0: 85 d2 test %edx,%edx
109fa2: 74 3c je 109fe0 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
109fa4: 83 f8 01 cmp $0x1,%eax
109fa7: 75 0b jne 109fb4 <clock_gettime+0x20>
_TOD_Get(tp);
109fa9: 83 ec 0c sub $0xc,%esp
109fac: 52 push %edx
109fad: e8 9e 1b 00 00 call 10bb50 <_TOD_Get>
109fb2: eb 13 jmp 109fc7 <clock_gettime+0x33>
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
109fb4: 83 f8 04 cmp $0x4,%eax
109fb7: 74 05 je 109fbe <clock_gettime+0x2a> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
109fb9: 83 f8 02 cmp $0x2,%eax
109fbc: 75 10 jne 109fce <clock_gettime+0x3a>
_TOD_Get_uptime_as_timespec( tp );
109fbe: 83 ec 0c sub $0xc,%esp
109fc1: 52 push %edx
109fc2: e8 e5 1b 00 00 call 10bbac <_TOD_Get_uptime_as_timespec>
return 0;
109fc7: 83 c4 10 add $0x10,%esp
109fca: 31 c0 xor %eax,%eax
109fcc: eb 20 jmp 109fee <clock_gettime+0x5a>
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
109fce: 83 f8 03 cmp $0x3,%eax
109fd1: 75 0d jne 109fe0 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( ENOSYS );
109fd3: e8 68 7f 00 00 call 111f40 <__errno>
109fd8: c7 00 58 00 00 00 movl $0x58,(%eax)
109fde: eb 0b jmp 109feb <clock_gettime+0x57>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
109fe0: e8 5b 7f 00 00 call 111f40 <__errno>
109fe5: c7 00 16 00 00 00 movl $0x16,(%eax)
109feb: 83 c8 ff or $0xffffffff,%eax
return 0;
}
109fee: c9 leave
109fef: c3 ret
00109ff0 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
109ff0: 55 push %ebp
109ff1: 89 e5 mov %esp,%ebp
109ff3: 83 ec 08 sub $0x8,%esp
109ff6: 8b 45 08 mov 0x8(%ebp),%eax
109ff9: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
109ffc: 85 d2 test %edx,%edx
109ffe: 74 44 je 10a044 <clock_settime+0x54> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10a000: 83 f8 01 cmp $0x1,%eax
10a003: 75 28 jne 10a02d <clock_settime+0x3d>
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
10a005: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx)
10a00b: 76 37 jbe 10a044 <clock_settime+0x54>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a00d: a1 24 63 12 00 mov 0x126324,%eax
10a012: 40 inc %eax
10a013: a3 24 63 12 00 mov %eax,0x126324
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
10a018: 83 ec 0c sub $0xc,%esp
10a01b: 52 push %edx
10a01c: e8 e3 1b 00 00 call 10bc04 <_TOD_Set>
_Thread_Enable_dispatch();
10a021: e8 68 2c 00 00 call 10cc8e <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
10a026: 83 c4 10 add $0x10,%esp
10a029: 31 c0 xor %eax,%eax
10a02b: eb 25 jmp 10a052 <clock_settime+0x62>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
10a02d: 83 f8 02 cmp $0x2,%eax
10a030: 74 05 je 10a037 <clock_settime+0x47>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
10a032: 83 f8 03 cmp $0x3,%eax
10a035: 75 0d jne 10a044 <clock_settime+0x54>
rtems_set_errno_and_return_minus_one( ENOSYS );
10a037: e8 04 7f 00 00 call 111f40 <__errno>
10a03c: c7 00 58 00 00 00 movl $0x58,(%eax)
10a042: eb 0b jmp 10a04f <clock_settime+0x5f>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
10a044: e8 f7 7e 00 00 call 111f40 <__errno>
10a049: c7 00 16 00 00 00 movl $0x16,(%eax)
10a04f: 83 c8 ff or $0xffffffff,%eax
return 0;
}
10a052: c9 leave
10a053: c3 ret
0010d340 <devFS_evaluate_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
10d340: 55 push %ebp
10d341: 89 e5 mov %esp,%ebp
10d343: 57 push %edi
10d344: 56 push %esi
10d345: 53 push %ebx
10d346: 83 ec 1c sub $0x1c,%esp
10d349: 8b 4d 0c mov 0xc(%ebp),%ecx
10d34c: 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 ) )
10d34f: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp)
10d356: 74 0d je 10d365 <devFS_evaluate_path+0x25><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
10d358: e8 5b 23 00 00 call 10f6b8 <__errno> <== NOT EXECUTED
10d35d: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10d363: eb 77 jmp 10d3dc <devFS_evaluate_path+0x9c><== NOT EXECUTED
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
10d365: 8b 33 mov (%ebx),%esi
if (!device_name_table)
10d367: 85 f6 test %esi,%esi
10d369: 74 04 je 10d36f <devFS_evaluate_path+0x2f>
10d36b: 31 ff xor %edi,%edi
10d36d: eb 5a jmp 10d3c9 <devFS_evaluate_path+0x89>
rtems_set_errno_and_return_minus_one( EFAULT );
10d36f: e8 44 23 00 00 call 10f6b8 <__errno>
10d374: c7 00 0e 00 00 00 movl $0xe,(%eax)
10d37a: eb 60 jmp 10d3dc <devFS_evaluate_path+0x9c>
for (i = 0; i < rtems_device_table_size; i++) {
if (!device_name_table[i].device_name)
10d37c: 8b 16 mov (%esi),%edx
10d37e: 85 d2 test %edx,%edx
10d380: 74 43 je 10d3c5 <devFS_evaluate_path+0x85>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
10d382: 50 push %eax
10d383: 51 push %ecx
10d384: 52 push %edx
10d385: ff 75 08 pushl 0x8(%ebp)
10d388: 89 55 e4 mov %edx,-0x1c(%ebp)
10d38b: 89 4d e0 mov %ecx,-0x20(%ebp)
10d38e: e8 01 30 00 00 call 110394 <strncmp>
10d393: 83 c4 10 add $0x10,%esp
10d396: 85 c0 test %eax,%eax
10d398: 8b 55 e4 mov -0x1c(%ebp),%edx
10d39b: 8b 4d e0 mov -0x20(%ebp),%ecx
10d39e: 75 25 jne 10d3c5 <devFS_evaluate_path+0x85>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
10d3a0: 80 3c 0a 00 cmpb $0x0,(%edx,%ecx,1)
10d3a4: 75 1f jne 10d3c5 <devFS_evaluate_path+0x85><== NEVER TAKEN
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
10d3a6: 89 33 mov %esi,(%ebx)
pathloc->handlers = &devFS_file_handlers;
10d3a8: c7 43 08 7c ff 11 00 movl $0x11ff7c,0x8(%ebx)
pathloc->ops = &devFS_ops;
10d3af: c7 43 0c 34 ff 11 00 movl $0x11ff34,0xc(%ebx)
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
10d3b6: a1 d0 00 12 00 mov 0x1200d0,%eax
10d3bb: 8b 40 28 mov 0x28(%eax),%eax
10d3be: 89 43 10 mov %eax,0x10(%ebx)
return 0;
10d3c1: 31 c0 xor %eax,%eax
10d3c3: eb 1a jmp 10d3df <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++) {
10d3c5: 47 inc %edi
10d3c6: 83 c6 14 add $0x14,%esi
10d3c9: 3b 3d 48 e1 11 00 cmp 0x11e148,%edi
10d3cf: 72 ab jb 10d37c <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 );
10d3d1: e8 e2 22 00 00 call 10f6b8 <__errno>
10d3d6: c7 00 02 00 00 00 movl $0x2,(%eax)
10d3dc: 83 c8 ff or $0xffffffff,%eax
}
10d3df: 8d 65 f4 lea -0xc(%ebp),%esp
10d3e2: 5b pop %ebx
10d3e3: 5e pop %esi
10d3e4: 5f pop %edi
10d3e5: c9 leave
10d3e6: c3 ret
00106c40 <devFS_mknod>:
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
106c40: 55 push %ebp
106c41: 89 e5 mov %esp,%ebp
106c43: 57 push %edi
106c44: 56 push %esi
106c45: 53 push %ebx
106c46: 83 ec 1c sub $0x1c,%esp
106c49: 8b 7d 08 mov 0x8(%ebp),%edi
106c4c: 8b 4d 10 mov 0x10(%ebp),%ecx
106c4f: 8b 55 14 mov 0x14(%ebp),%edx
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
106c52: 80 3f 64 cmpb $0x64,(%edi)
106c55: 75 18 jne 106c6f <devFS_mknod+0x2f>
106c57: 80 7f 01 65 cmpb $0x65,0x1(%edi)
106c5b: 75 12 jne 106c6f <devFS_mknod+0x2f> <== NEVER TAKEN
106c5d: 80 7f 02 76 cmpb $0x76,0x2(%edi)
106c61: 75 0c jne 106c6f <devFS_mknod+0x2f> <== NEVER TAKEN
(path[2] == 'v') && (path[3] == '\0'))
return 0;
106c63: 31 c0 xor %eax,%eax
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
(path[2] == 'v') && (path[3] == '\0'))
106c65: 80 7f 03 00 cmpb $0x0,0x3(%edi)
106c69: 0f 84 c9 00 00 00 je 106d38 <devFS_mknod+0xf8>
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
106c6f: 8b 45 0c mov 0xc(%ebp),%eax
106c72: 25 00 f0 00 00 and $0xf000,%eax
106c77: 3d 00 20 00 00 cmp $0x2000,%eax
106c7c: 74 14 je 106c92 <devFS_mknod+0x52>
106c7e: 3d 00 60 00 00 cmp $0x6000,%eax
106c83: 74 0d je 106c92 <devFS_mknod+0x52>
rtems_set_errno_and_return_minus_one( EINVAL );
106c85: e8 2e 8a 00 00 call 10f6b8 <__errno>
106c8a: c7 00 16 00 00 00 movl $0x16,(%eax)
106c90: eb 23 jmp 106cb5 <devFS_mknod+0x75>
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.major;
106c92: 89 4d e4 mov %ecx,-0x1c(%ebp)
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
106c95: 89 55 e0 mov %edx,-0x20(%ebp)
else
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
106c98: 8b 45 18 mov 0x18(%ebp),%eax
106c9b: 8b 08 mov (%eax),%ecx
if (!device_name_table)
106c9d: 85 c9 test %ecx,%ecx
106c9f: 74 09 je 106caa <devFS_mknod+0x6a>
106ca1: 89 ca mov %ecx,%edx
106ca3: 83 ce ff or $0xffffffff,%esi
106ca6: 31 db xor %ebx,%ebx
106ca8: eb 46 jmp 106cf0 <devFS_mknod+0xb0>
rtems_set_errno_and_return_minus_one( EFAULT );
106caa: e8 09 8a 00 00 call 10f6b8 <__errno>
106caf: c7 00 0e 00 00 00 movl $0xe,(%eax)
106cb5: 83 c8 ff or $0xffffffff,%eax
106cb8: eb 7e jmp 106d38 <devFS_mknod+0xf8>
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
106cba: 8b 02 mov (%edx),%eax
106cbc: 85 c0 test %eax,%eax
106cbe: 74 2a je 106cea <devFS_mknod+0xaa>
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
106cc0: 83 ec 08 sub $0x8,%esp
106cc3: 50 push %eax
106cc4: 57 push %edi
106cc5: 89 55 d8 mov %edx,-0x28(%ebp)
106cc8: 89 4d dc mov %ecx,-0x24(%ebp)
106ccb: e8 1c 96 00 00 call 1102ec <strcmp>
106cd0: 83 c4 10 add $0x10,%esp
106cd3: 85 c0 test %eax,%eax
106cd5: 8b 55 d8 mov -0x28(%ebp),%edx
106cd8: 8b 4d dc mov -0x24(%ebp),%ecx
106cdb: 75 0f jne 106cec <devFS_mknod+0xac>
rtems_set_errno_and_return_minus_one( EEXIST );
106cdd: e8 d6 89 00 00 call 10f6b8 <__errno>
106ce2: c7 00 11 00 00 00 movl $0x11,(%eax)
106ce8: eb cb jmp 106cb5 <devFS_mknod+0x75>
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
slot = i;
106cea: 89 de mov %ebx,%esi
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
106cec: 43 inc %ebx
106ced: 83 c2 14 add $0x14,%edx
106cf0: 3b 1d 48 e1 11 00 cmp 0x11e148,%ebx
106cf6: 72 c2 jb 106cba <devFS_mknod+0x7a>
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
106cf8: 83 fe ff cmp $0xffffffff,%esi
106cfb: 75 0d jne 106d0a <devFS_mknod+0xca>
rtems_set_errno_and_return_minus_one( ENOMEM );
106cfd: e8 b6 89 00 00 call 10f6b8 <__errno>
106d02: c7 00 0c 00 00 00 movl $0xc,(%eax)
106d08: eb ab jmp 106cb5 <devFS_mknod+0x75>
_ISR_Disable(level);
106d0a: 9c pushf
106d0b: fa cli
106d0c: 5b pop %ebx
device_name_table[slot].device_name = (char *)path;
106d0d: 6b d6 14 imul $0x14,%esi,%edx
106d10: 8d 14 11 lea (%ecx,%edx,1),%edx
106d13: 89 3a mov %edi,(%edx)
device_name_table[slot].device_name_length = strlen(path);
106d15: 31 c0 xor %eax,%eax
106d17: 83 c9 ff or $0xffffffff,%ecx
106d1a: f2 ae repnz scas %es:(%edi),%al
106d1c: f7 d1 not %ecx
106d1e: 49 dec %ecx
106d1f: 89 4a 04 mov %ecx,0x4(%edx)
device_name_table[slot].major = major;
106d22: 8b 45 e4 mov -0x1c(%ebp),%eax
106d25: 89 42 08 mov %eax,0x8(%edx)
device_name_table[slot].minor = minor;
106d28: 8b 45 e0 mov -0x20(%ebp),%eax
106d2b: 89 42 0c mov %eax,0xc(%edx)
device_name_table[slot].mode = mode;
106d2e: 8b 45 0c mov 0xc(%ebp),%eax
106d31: 89 42 10 mov %eax,0x10(%edx)
_ISR_Enable(level);
106d34: 53 push %ebx
106d35: 9d popf
return 0;
106d36: 31 c0 xor %eax,%eax
}
106d38: 8d 65 f4 lea -0xc(%ebp),%esp
106d3b: 5b pop %ebx
106d3c: 5e pop %esi
106d3d: 5f pop %edi
106d3e: c9 leave
106d3f: c3 ret
00108084 <drainOutput>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
108084: 55 push %ebp
108085: 89 e5 mov %esp,%ebp
108087: 53 push %ebx
108088: 83 ec 04 sub $0x4,%esp
10808b: 89 c3 mov %eax,%ebx
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
10808d: 83 b8 b4 00 00 00 00 cmpl $0x0,0xb4(%eax)
108094: 74 46 je 1080dc <drainOutput+0x58>
rtems_interrupt_disable (level);
108096: 9c pushf
108097: fa cli
108098: 58 pop %eax
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
108099: eb 2f jmp 1080ca <drainOutput+0x46>
tty->rawOutBufState = rob_wait;
10809b: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
1080a2: 00 00 00
rtems_interrupt_enable (level);
1080a5: 50 push %eax
1080a6: 9d popf
sc = rtems_semaphore_obtain(
1080a7: 50 push %eax
1080a8: 6a 00 push $0x0
1080aa: 6a 00 push $0x0
1080ac: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
1080b2: e8 ad 20 00 00 call 10a164 <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
1080b7: 83 c4 10 add $0x10,%esp
1080ba: 85 c0 test %eax,%eax
1080bc: 74 09 je 1080c7 <drainOutput+0x43> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
1080be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1080c1: 50 push %eax <== NOT EXECUTED
1080c2: e8 65 26 00 00 call 10a72c <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_interrupt_disable (level);
1080c7: 9c pushf
1080c8: fa cli
1080c9: 58 pop %eax
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
1080ca: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx
1080d0: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
1080d6: 39 d1 cmp %edx,%ecx
1080d8: 75 c1 jne 10809b <drainOutput+0x17>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
1080da: 50 push %eax
1080db: 9d popf
}
}
1080dc: 8b 5d fc mov -0x4(%ebp),%ebx
1080df: c9 leave
1080e0: c3 ret
00108c3b <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
108c3b: 55 push %ebp
108c3c: 89 e5 mov %esp,%ebp
108c3e: 53 push %ebx
108c3f: 83 ec 24 sub $0x24,%esp
if ((tty->termios.c_lflag & ECHOCTL) &&
108c42: f6 42 3d 02 testb $0x2,0x3d(%edx)
108c46: 74 3e je 108c86 <echo+0x4b> <== NEVER TAKEN
iscntrl(c) && (c != '\t') && (c != '\n')) {
108c48: 0f b6 c8 movzbl %al,%ecx
108c4b: 8b 1d 08 21 12 00 mov 0x122108,%ebx
108c51: f6 44 0b 01 20 testb $0x20,0x1(%ebx,%ecx,1)
108c56: 74 2e je 108c86 <echo+0x4b>
108c58: 3c 09 cmp $0x9,%al
108c5a: 74 2a je 108c86 <echo+0x4b>
108c5c: 3c 0a cmp $0xa,%al
108c5e: 74 26 je 108c86 <echo+0x4b>
char echobuf[2];
echobuf[0] = '^';
108c60: c6 45 f6 5e movb $0x5e,-0xa(%ebp)
echobuf[1] = c ^ 0x40;
108c64: 83 f0 40 xor $0x40,%eax
108c67: 88 45 f7 mov %al,-0x9(%ebp)
rtems_termios_puts (echobuf, 2, tty);
108c6a: 50 push %eax
108c6b: 52 push %edx
108c6c: 6a 02 push $0x2
108c6e: 8d 45 f6 lea -0xa(%ebp),%eax
108c71: 50 push %eax
108c72: 89 55 e4 mov %edx,-0x1c(%ebp)
108c75: e8 84 fd ff ff call 1089fe <rtems_termios_puts>
tty->column += 2;
108c7a: 8b 55 e4 mov -0x1c(%ebp),%edx
108c7d: 83 42 28 02 addl $0x2,0x28(%edx)
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
108c81: 83 c4 10 add $0x10,%esp
108c84: eb 08 jmp 108c8e <echo+0x53>
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
108c86: 0f b6 c0 movzbl %al,%eax
108c89: e8 90 fe ff ff call 108b1e <oproc>
}
}
108c8e: 8b 5d fc mov -0x4(%ebp),%ebx
108c91: c9 leave
108c92: c3 ret
0010811e <endgrent>:
void endgrent(void)
{
10811e: 55 push %ebp
10811f: 89 e5 mov %esp,%ebp
108121: 83 ec 08 sub $0x8,%esp
if (group_fp != NULL)
108124: a1 98 5e 12 00 mov 0x125e98,%eax
108129: 85 c0 test %eax,%eax
10812b: 74 0c je 108139 <endgrent+0x1b> <== NEVER TAKEN
fclose(group_fp);
10812d: 83 ec 0c sub $0xc,%esp
108130: 50 push %eax
108131: e8 5e 9e 00 00 call 111f94 <fclose>
108136: 83 c4 10 add $0x10,%esp
}
108139: c9 leave
10813a: c3 ret
00107fd1 <endpwent>:
void endpwent(void)
{
107fd1: 55 push %ebp
107fd2: 89 e5 mov %esp,%ebp
107fd4: 83 ec 08 sub $0x8,%esp
if (passwd_fp != NULL)
107fd7: a1 74 5f 12 00 mov 0x125f74,%eax
107fdc: 85 c0 test %eax,%eax
107fde: 74 0c je 107fec <endpwent+0x1b> <== NEVER TAKEN
fclose(passwd_fp);
107fe0: 83 ec 0c sub $0xc,%esp
107fe3: 50 push %eax
107fe4: e8 ab 9f 00 00 call 111f94 <fclose>
107fe9: 83 c4 10 add $0x10,%esp
}
107fec: c9 leave
107fed: c3 ret
00108c93 <erase>:
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
108c93: 55 push %ebp
108c94: 89 e5 mov %esp,%ebp
108c96: 57 push %edi
108c97: 56 push %esi
108c98: 53 push %ebx
108c99: 83 ec 2c sub $0x2c,%esp
108c9c: 89 c3 mov %eax,%ebx
108c9e: 89 55 e4 mov %edx,-0x1c(%ebp)
if (tty->ccount == 0)
108ca1: 83 78 20 00 cmpl $0x0,0x20(%eax)
108ca5: 0f 84 59 01 00 00 je 108e04 <erase+0x171>
return;
if (lineFlag) {
108cab: 85 d2 test %edx,%edx
108cad: 0f 84 46 01 00 00 je 108df9 <erase+0x166>
if (!(tty->termios.c_lflag & ECHO)) {
108cb3: 8b 40 3c mov 0x3c(%eax),%eax
108cb6: a8 08 test $0x8,%al
108cb8: 75 0c jne 108cc6 <erase+0x33> <== ALWAYS TAKEN
tty->ccount = 0;
108cba: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
return;
108cc1: e9 3e 01 00 00 jmp 108e04 <erase+0x171> <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
108cc6: a8 10 test $0x10,%al
108cc8: 0f 85 2b 01 00 00 jne 108df9 <erase+0x166> <== ALWAYS TAKEN
tty->ccount = 0;
108cce: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
108cd5: 0f b6 43 44 movzbl 0x44(%ebx),%eax <== NOT EXECUTED
108cd9: 89 da mov %ebx,%edx <== NOT EXECUTED
108cdb: e8 5b ff ff ff call 108c3b <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
108ce0: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED
108ce4: 0f 84 1a 01 00 00 je 108e04 <erase+0x171> <== NOT EXECUTED
echo ('\n', tty);
108cea: 89 da mov %ebx,%edx <== NOT EXECUTED
108cec: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
108cf1: eb 2a jmp 108d1d <erase+0x8a> <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
108cf3: 8b 7b 1c mov 0x1c(%ebx),%edi
108cf6: 8d 50 ff lea -0x1(%eax),%edx
108cf9: 89 53 20 mov %edx,0x20(%ebx)
108cfc: 8a 4c 07 ff mov -0x1(%edi,%eax,1),%cl
if (tty->termios.c_lflag & ECHO) {
108d00: 8b 53 3c mov 0x3c(%ebx),%edx
108d03: f6 c2 08 test $0x8,%dl
108d06: 0f 84 e7 00 00 00 je 108df3 <erase+0x160> <== NEVER TAKEN
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
108d0c: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
108d10: 75 17 jne 108d29 <erase+0x96>
108d12: f6 c2 10 test $0x10,%dl
108d15: 75 12 jne 108d29 <erase+0x96> <== ALWAYS TAKEN
echo (tty->termios.c_cc[VERASE], tty);
108d17: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED
108d1b: 89 da mov %ebx,%edx <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
108d1d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108d20: 5b pop %ebx <== NOT EXECUTED
108d21: 5e pop %esi <== NOT EXECUTED
108d22: 5f pop %edi <== NOT EXECUTED
108d23: c9 leave <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
108d24: e9 12 ff ff ff jmp 108c3b <echo> <== NOT EXECUTED
} else if (c == '\t') {
108d29: 80 f9 09 cmp $0x9,%cl
108d2c: 8b 35 08 21 12 00 mov 0x122108,%esi
108d32: 89 75 e0 mov %esi,-0x20(%ebp)
108d35: 75 60 jne 108d97 <erase+0x104>
int col = tty->read_start_column;
108d37: 8b 73 2c mov 0x2c(%ebx),%esi
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
108d3a: b9 01 00 00 00 mov $0x1,%ecx
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
108d3f: 81 e2 00 02 00 00 and $0x200,%edx
108d45: 89 55 dc mov %edx,-0x24(%ebp)
108d48: 89 45 d4 mov %eax,-0x2c(%ebp)
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
108d4b: eb 28 jmp 108d75 <erase+0xe2>
c = tty->cbuf[i++];
108d4d: 8a 54 0f ff mov -0x1(%edi,%ecx,1),%dl
if (c == '\t') {
108d51: 80 fa 09 cmp $0x9,%dl
108d54: 75 05 jne 108d5b <erase+0xc8>
col = (col | 7) + 1;
108d56: 83 ce 07 or $0x7,%esi
108d59: eb 18 jmp 108d73 <erase+0xe0>
} else if (iscntrl (c)) {
108d5b: 0f b6 d2 movzbl %dl,%edx
108d5e: 8b 45 e0 mov -0x20(%ebp),%eax
108d61: f6 44 10 01 20 testb $0x20,0x1(%eax,%edx,1)
108d66: 74 0b je 108d73 <erase+0xe0> <== ALWAYS TAKEN
if (tty->termios.c_lflag & ECHOCTL)
108d68: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) <== NOT EXECUTED
108d6c: 74 06 je 108d74 <erase+0xe1> <== NOT EXECUTED
col += 2;
108d6e: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
108d71: eb 01 jmp 108d74 <erase+0xe1> <== NOT EXECUTED
} else {
col++;
108d73: 46 inc %esi
108d74: 41 inc %ecx
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
108d75: 3b 4d d4 cmp -0x2c(%ebp),%ecx
108d78: 75 d3 jne 108d4d <erase+0xba>
108d7a: eb 14 jmp 108d90 <erase+0xfd>
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
108d7c: 57 push %edi
108d7d: 53 push %ebx
108d7e: 6a 01 push $0x1
108d80: 68 bc e6 11 00 push $0x11e6bc
108d85: e8 74 fc ff ff call 1089fe <rtems_termios_puts>
tty->column--;
108d8a: ff 4b 28 decl 0x28(%ebx)
108d8d: 83 c4 10 add $0x10,%esp
}
/*
* Back up over the tab
*/
while (tty->column > col) {
108d90: 39 73 28 cmp %esi,0x28(%ebx)
108d93: 7f e7 jg 108d7c <erase+0xe9>
108d95: eb 5c jmp 108df3 <erase+0x160>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
108d97: 0f b6 f1 movzbl %cl,%esi
108d9a: 8b 45 e0 mov -0x20(%ebp),%eax
108d9d: f6 44 30 01 20 testb $0x20,0x1(%eax,%esi,1)
108da2: 74 21 je 108dc5 <erase+0x132> <== ALWAYS TAKEN
108da4: 80 e6 02 and $0x2,%dh <== NOT EXECUTED
108da7: 74 1c je 108dc5 <erase+0x132> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
108da9: 51 push %ecx <== NOT EXECUTED
108daa: 53 push %ebx <== NOT EXECUTED
108dab: 6a 03 push $0x3 <== NOT EXECUTED
108dad: 68 ba e6 11 00 push $0x11e6ba <== NOT EXECUTED
108db2: e8 47 fc ff ff call 1089fe <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
108db7: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
108dba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108dbd: 85 c0 test %eax,%eax <== NOT EXECUTED
108dbf: 74 04 je 108dc5 <erase+0x132> <== NOT EXECUTED
tty->column--;
108dc1: 48 dec %eax <== NOT EXECUTED
108dc2: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
108dc5: a1 08 21 12 00 mov 0x122108,%eax
108dca: f6 44 30 01 20 testb $0x20,0x1(%eax,%esi,1)
108dcf: 74 06 je 108dd7 <erase+0x144> <== ALWAYS TAKEN
108dd1: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED
108dd5: 74 1c je 108df3 <erase+0x160> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
108dd7: 52 push %edx
108dd8: 53 push %ebx
108dd9: 6a 03 push $0x3
108ddb: 68 ba e6 11 00 push $0x11e6ba
108de0: e8 19 fc ff ff call 1089fe <rtems_termios_puts>
if (tty->column)
108de5: 8b 43 28 mov 0x28(%ebx),%eax
108de8: 83 c4 10 add $0x10,%esp
108deb: 85 c0 test %eax,%eax
108ded: 74 04 je 108df3 <erase+0x160> <== NEVER TAKEN
tty->column--;
108def: 48 dec %eax
108df0: 89 43 28 mov %eax,0x28(%ebx)
}
}
}
if (!lineFlag)
108df3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
108df7: 74 0b je 108e04 <erase+0x171>
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
108df9: 8b 43 20 mov 0x20(%ebx),%eax
108dfc: 85 c0 test %eax,%eax
108dfe: 0f 85 ef fe ff ff jne 108cf3 <erase+0x60>
}
}
if (!lineFlag)
break;
}
}
108e04: 8d 65 f4 lea -0xc(%ebp),%esp
108e07: 5b pop %ebx
108e08: 5e pop %esi
108e09: 5f pop %edi
108e0a: c9 leave
108e0b: c3 ret
00107be8 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
107be8: 55 push %ebp
107be9: 89 e5 mov %esp,%ebp
107beb: 57 push %edi
107bec: 56 push %esi
107bed: 53 push %ebx
107bee: 83 ec 0c sub $0xc,%esp
107bf1: 8b 5d 08 mov 0x8(%ebp),%ebx
int ret;
va_list ap;
va_start( ap, cmd );
107bf4: 8d 75 10 lea 0x10(%ebp),%esi
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
107bf7: 8b 0d 44 21 12 00 mov 0x122144,%ecx
107bfd: 39 cb cmp %ecx,%ebx
107bff: 73 14 jae 107c15 <fcntl+0x2d>
iop = rtems_libio_iop( fd );
107c01: 8b 15 98 61 12 00 mov 0x126198,%edx
107c07: 6b db 38 imul $0x38,%ebx,%ebx
107c0a: 8d 1c 1a lea (%edx,%ebx,1),%ebx
rtems_libio_check_is_open(iop);
107c0d: 8b 43 14 mov 0x14(%ebx),%eax
107c10: f6 c4 01 test $0x1,%ah
107c13: 75 10 jne 107c25 <fcntl+0x3d>
107c15: e8 fa a2 00 00 call 111f14 <__errno>
107c1a: c7 00 09 00 00 00 movl $0x9,(%eax)
107c20: e9 e6 00 00 00 jmp 107d0b <fcntl+0x123>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
107c25: 83 7d 0c 09 cmpl $0x9,0xc(%ebp)
107c29: 0f 87 af 00 00 00 ja 107cde <fcntl+0xf6>
107c2f: 8b 7d 0c mov 0xc(%ebp),%edi
107c32: ff 24 bd 28 ff 11 00 jmp *0x11ff28(,%edi,4)
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
107c39: 8b 36 mov (%esi),%esi
if ( fd2 )
107c3b: 85 f6 test %esi,%esi
107c3d: 74 0e je 107c4d <fcntl+0x65>
diop = rtems_libio_iop( fd2 );
107c3f: 31 c0 xor %eax,%eax
107c41: 39 ce cmp %ecx,%esi
107c43: 73 15 jae 107c5a <fcntl+0x72> <== NEVER TAKEN
107c45: 6b c6 38 imul $0x38,%esi,%eax
107c48: 8d 04 02 lea (%edx,%eax,1),%eax
107c4b: eb 0d jmp 107c5a <fcntl+0x72>
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
107c4d: e8 d1 04 00 00 call 108123 <rtems_libio_allocate>
if ( diop == 0 ) {
107c52: 85 c0 test %eax,%eax
107c54: 0f 84 b1 00 00 00 je 107d0b <fcntl+0x123> <== NEVER TAKEN
ret = -1;
break;
}
}
diop->flags = iop->flags;
107c5a: 8b 53 14 mov 0x14(%ebx),%edx
107c5d: 89 50 14 mov %edx,0x14(%eax)
diop->pathinfo = iop->pathinfo;
107c60: 8d 78 18 lea 0x18(%eax),%edi
107c63: 8d 73 18 lea 0x18(%ebx),%esi
107c66: b9 05 00 00 00 mov $0x5,%ecx
107c6b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ret = (int) (diop - rtems_libio_iops);
107c6d: 2b 05 98 61 12 00 sub 0x126198,%eax
107c73: c1 f8 03 sar $0x3,%eax
107c76: 69 f0 b7 6d db b6 imul $0xb6db6db7,%eax,%esi
107c7c: eb 6d jmp 107ceb <fcntl+0x103>
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
107c7e: f6 c4 08 test $0x8,%ah
107c81: 0f 95 c0 setne %al
107c84: 0f b6 c0 movzbl %al,%eax
107c87: 89 c6 mov %eax,%esi
107c89: eb 64 jmp 107cef <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 ) )
107c8b: 83 3e 00 cmpl $0x0,(%esi)
107c8e: 74 05 je 107c95 <fcntl+0xad>
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
107c90: 80 cc 08 or $0x8,%ah
107c93: eb 03 jmp 107c98 <fcntl+0xb0>
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
107c95: 80 e4 f7 and $0xf7,%ah
107c98: 89 43 14 mov %eax,0x14(%ebx)
107c9b: eb 30 jmp 107ccd <fcntl+0xe5>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
107c9d: 83 ec 0c sub $0xc,%esp
107ca0: 50 push %eax
107ca1: e8 3f 04 00 00 call 1080e5 <rtems_libio_to_fcntl_flags>
107ca6: 89 c6 mov %eax,%esi
107ca8: 83 c4 10 add $0x10,%esp
107cab: eb 3e jmp 107ceb <fcntl+0x103>
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
107cad: 83 ec 0c sub $0xc,%esp
107cb0: ff 36 pushl (%esi)
107cb2: e8 f9 03 00 00 call 1080b0 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
107cb7: 25 01 02 00 00 and $0x201,%eax
107cbc: 8b 53 14 mov 0x14(%ebx),%edx
107cbf: 81 e2 fe fd ff ff and $0xfffffdfe,%edx
107cc5: 09 d0 or %edx,%eax
107cc7: 89 43 14 mov %eax,0x14(%ebx)
107cca: 83 c4 10 add $0x10,%esp
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
107ccd: 31 f6 xor %esi,%esi
107ccf: eb 1e jmp 107cef <fcntl+0x107>
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
107cd1: e8 3e a2 00 00 call 111f14 <__errno>
107cd6: c7 00 86 00 00 00 movl $0x86,(%eax)
107cdc: eb 2d jmp 107d0b <fcntl+0x123>
ret = -1;
break;
default:
errno = EINVAL;
107cde: e8 31 a2 00 00 call 111f14 <__errno>
107ce3: c7 00 16 00 00 00 movl $0x16,(%eax)
107ce9: eb 20 jmp 107d0b <fcntl+0x123>
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
107ceb: 85 f6 test %esi,%esi
107ced: 78 1f js 107d0e <fcntl+0x126> <== NEVER TAKEN
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
107cef: 50 push %eax
107cf0: 50 push %eax
107cf1: 8b 43 20 mov 0x20(%ebx),%eax
107cf4: 53 push %ebx
107cf5: ff 75 0c pushl 0xc(%ebp)
107cf8: ff 50 30 call *0x30(%eax)
107cfb: 89 c3 mov %eax,%ebx
if (err) {
107cfd: 83 c4 10 add $0x10,%esp
107d00: 85 c0 test %eax,%eax
107d02: 74 0a je 107d0e <fcntl+0x126> <== ALWAYS TAKEN
errno = err;
107d04: e8 0b a2 00 00 call 111f14 <__errno> <== NOT EXECUTED
107d09: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
ret = -1;
107d0b: 83 ce ff or $0xffffffff,%esi
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
107d0e: 89 f0 mov %esi,%eax
107d10: 8d 65 f4 lea -0xc(%ebp),%esp
107d13: 5b pop %ebx
107d14: 5e pop %esi
107d15: 5f pop %edi
107d16: c9 leave
107d17: c3 ret
0010fa07 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
10fa07: 55 push %ebp
10fa08: 89 e5 mov %esp,%ebp
10fa0a: 57 push %edi
10fa0b: 56 push %esi
10fa0c: 53 push %ebx
10fa0d: 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) {
10fa10: 83 3d a0 6f 12 00 00 cmpl $0x0,0x126fa0
10fa17: 75 50 jne 10fa69 <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 );
10fa19: 53 push %ebx
10fa1a: 6a 00 push $0x0
10fa1c: 6a 00 push $0x0
10fa1e: ff 35 a0 71 12 00 pushl 0x1271a0
10fa24: e8 e7 c1 ff ff call 10bc10 <rtems_semaphore_obtain>
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
10fa29: 83 c4 10 add $0x10,%esp
free(pipe);
}
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
10fa2c: 31 db xor %ebx,%ebx
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
10fa2e: 83 3d a0 6f 12 00 00 cmpl $0x0,0x126fa0
10fa35: 75 1d jne 10fa54 <fifo_open+0x4d> <== NEVER TAKEN
sc = rtems_semaphore_create(
10fa37: 83 ec 0c sub $0xc,%esp
10fa3a: 68 a0 6f 12 00 push $0x126fa0
10fa3f: 6a 00 push $0x0
10fa41: 6a 54 push $0x54
10fa43: 6a 01 push $0x1
10fa45: 68 45 50 49 50 push $0x50495045
10fa4a: e8 99 bf ff ff call 10b9e8 <rtems_semaphore_create>
10fa4f: 89 c3 mov %eax,%ebx
10fa51: 83 c4 20 add $0x20,%esp
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10fa54: 83 ec 0c sub $0xc,%esp
10fa57: ff 35 a0 71 12 00 pushl 0x1271a0
10fa5d: e8 9a c2 ff ff call 10bcfc <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
10fa62: 83 c4 10 add $0x10,%esp
10fa65: 85 db test %ebx,%ebx
10fa67: 75 19 jne 10fa82 <fifo_open+0x7b>
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
10fa69: 51 push %ecx
10fa6a: 6a 00 push $0x0
10fa6c: 6a 00 push $0x0
10fa6e: ff 35 a0 6f 12 00 pushl 0x126fa0
10fa74: e8 97 c1 ff ff call 10bc10 <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
10fa79: 83 c4 10 add $0x10,%esp
return 0;
10fa7c: 31 f6 xor %esi,%esi
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
}
if (sc == RTEMS_SUCCESSFUL) {
10fa7e: 85 c0 test %eax,%eax
10fa80: 74 05 je 10fa87 <fifo_open+0x80> <== ALWAYS TAKEN
return 0;
} else {
return -ENOMEM;
10fa82: be f4 ff ff ff mov $0xfffffff4,%esi
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
if (err)
10fa87: 85 f6 test %esi,%esi
10fa89: 0f 85 37 03 00 00 jne 10fdc6 <fifo_open+0x3bf>
return err;
pipe = *pipep;
10fa8f: 8b 45 08 mov 0x8(%ebp),%eax
10fa92: 8b 18 mov (%eax),%ebx
if (pipe == NULL) {
10fa94: 85 db test %ebx,%ebx
10fa96: 0f 85 56 01 00 00 jne 10fbf2 <fifo_open+0x1eb>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
10fa9c: 83 ec 0c sub $0xc,%esp
10fa9f: 6a 34 push $0x34
10faa1: e8 12 95 ff ff call 108fb8 <malloc>
10faa6: 89 c3 mov %eax,%ebx
10faa8: 89 45 d4 mov %eax,-0x2c(%ebp)
if (pipe == NULL)
10faab: 83 c4 10 add $0x10,%esp
10faae: 85 c0 test %eax,%eax
10fab0: 0f 84 35 01 00 00 je 10fbeb <fifo_open+0x1e4>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
10fab6: b9 0d 00 00 00 mov $0xd,%ecx
10fabb: 89 c7 mov %eax,%edi
10fabd: 89 f0 mov %esi,%eax
10fabf: f3 ab rep stos %eax,%es:(%edi)
pipe->Size = PIPE_BUF;
10fac1: c7 43 04 00 02 00 00 movl $0x200,0x4(%ebx)
pipe->Buffer = malloc(pipe->Size);
10fac8: 83 ec 0c sub $0xc,%esp
10facb: 68 00 02 00 00 push $0x200
10fad0: e8 e3 94 ff ff call 108fb8 <malloc>
10fad5: 89 03 mov %eax,(%ebx)
if (! pipe->Buffer)
10fad7: 83 c4 10 add $0x10,%esp
10fada: 85 c0 test %eax,%eax
10fadc: 0f 84 fb 00 00 00 je 10fbdd <fifo_open+0x1d6> <== NEVER TAKEN
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
10fae2: 8d 43 2c lea 0x2c(%ebx),%eax
10fae5: 50 push %eax
10fae6: 6a 00 push $0x0
10fae8: 6a 00 push $0x0
rtems_build_name ('P', 'I', 'r', c),
10faea: 0f be 05 74 50 12 00 movsbl 0x125074,%eax
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
10faf1: 0d 00 72 49 50 or $0x50497200,%eax
10faf6: 50 push %eax
10faf7: e8 44 18 00 00 call 111340 <rtems_barrier_create>
10fafc: 83 c4 10 add $0x10,%esp
10faff: 85 c0 test %eax,%eax
10fb01: 0f 85 c6 00 00 00 jne 10fbcd <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(
10fb07: 8d 43 30 lea 0x30(%ebx),%eax
10fb0a: 50 push %eax
10fb0b: 6a 00 push $0x0
10fb0d: 6a 00 push $0x0
rtems_build_name ('P', 'I', 'w', c),
10fb0f: 0f be 05 74 50 12 00 movsbl 0x125074,%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(
10fb16: 0d 00 77 49 50 or $0x50497700,%eax
10fb1b: 50 push %eax
10fb1c: e8 1f 18 00 00 call 111340 <rtems_barrier_create>
10fb21: 83 c4 10 add $0x10,%esp
10fb24: 85 c0 test %eax,%eax
10fb26: 0f 85 90 00 00 00 jne 10fbbc <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(
10fb2c: 83 ec 0c sub $0xc,%esp
10fb2f: 8d 43 28 lea 0x28(%ebx),%eax
10fb32: 50 push %eax
10fb33: 6a 00 push $0x0
10fb35: 6a 10 push $0x10
10fb37: 6a 01 push $0x1
rtems_build_name ('P', 'I', 's', c), 1,
10fb39: 0f be 05 74 50 12 00 movsbl 0x125074,%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(
10fb40: 0d 00 73 49 50 or $0x50497300,%eax
10fb45: 50 push %eax
10fb46: e8 9d be ff ff call 10b9e8 <rtems_semaphore_create>
10fb4b: 83 c4 20 add $0x20,%esp
10fb4e: 85 c0 test %eax,%eax
10fb50: 75 59 jne 10fbab <fifo_open+0x1a4>
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
10fb52: 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
10fb53: 8d 7d e0 lea -0x20(%ebp),%edi
10fb56: 57 push %edi
10fb57: ff 73 2c pushl 0x2c(%ebx)
10fb5a: 68 e4 7b 12 00 push $0x127be4
10fb5f: e8 f4 d5 ff ff call 10d158 <_Objects_Get>
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
10fb64: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax)
_Thread_Enable_dispatch();
10fb6b: e8 f6 dd ff ff call 10d966 <_Thread_Enable_dispatch>
10fb70: 83 c4 0c add $0xc,%esp
10fb73: 57 push %edi
10fb74: ff 73 30 pushl 0x30(%ebx)
10fb77: 68 e4 7b 12 00 push $0x127be4
10fb7c: e8 d7 d5 ff ff call 10d158 <_Objects_Get>
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
10fb81: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax)
_Thread_Enable_dispatch();
10fb88: e8 d9 dd ff ff call 10d966 <_Thread_Enable_dispatch>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
10fb8d: a0 74 50 12 00 mov 0x125074,%al
10fb92: 8d 50 01 lea 0x1(%eax),%edx
10fb95: 88 15 74 50 12 00 mov %dl,0x125074
10fb9b: 83 c4 10 add $0x10,%esp
10fb9e: 3c 7a cmp $0x7a,%al
10fba0: 75 50 jne 10fbf2 <fifo_open+0x1eb>
c = 'a';
10fba2: c6 05 74 50 12 00 61 movb $0x61,0x125074
10fba9: eb 47 jmp 10fbf2 <fifo_open+0x1eb>
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
10fbab: 83 ec 0c sub $0xc,%esp
10fbae: 8b 55 d4 mov -0x2c(%ebp),%edx
10fbb1: ff 72 30 pushl 0x30(%edx)
10fbb4: e8 3f 18 00 00 call 1113f8 <rtems_barrier_delete>
10fbb9: 83 c4 10 add $0x10,%esp
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
10fbbc: 83 ec 0c sub $0xc,%esp
10fbbf: 8b 45 d4 mov -0x2c(%ebp),%eax
10fbc2: ff 70 2c pushl 0x2c(%eax)
10fbc5: e8 2e 18 00 00 call 1113f8 <rtems_barrier_delete>
10fbca: 83 c4 10 add $0x10,%esp
err_rbar:
free(pipe->Buffer);
10fbcd: 83 ec 0c sub $0xc,%esp
10fbd0: 8b 55 d4 mov -0x2c(%ebp),%edx
10fbd3: ff 32 pushl (%edx)
10fbd5: e8 ba 8d ff ff call 108994 <free>
10fbda: 83 c4 10 add $0x10,%esp
err_buf:
free(pipe);
10fbdd: 83 ec 0c sub $0xc,%esp
10fbe0: ff 75 d4 pushl -0x2c(%ebp)
10fbe3: e8 ac 8d ff ff call 108994 <free>
10fbe8: 83 c4 10 add $0x10,%esp
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
10fbeb: be f4 ff ff ff mov $0xfffffff4,%esi
10fbf0: eb 33 jmp 10fc25 <fifo_open+0x21e>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
10fbf2: 50 push %eax
10fbf3: 6a 00 push $0x0
10fbf5: 6a 00 push $0x0
10fbf7: ff 73 28 pushl 0x28(%ebx)
10fbfa: e8 11 c0 ff ff call 10bc10 <rtems_semaphore_obtain>
10fbff: 83 c4 10 add $0x10,%esp
10fc02: 85 c0 test %eax,%eax
10fc04: 74 05 je 10fc0b <fifo_open+0x204> <== ALWAYS TAKEN
err = -EINTR;
10fc06: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
if (*pipep == NULL) {
10fc0b: 8b 45 08 mov 0x8(%ebp),%eax
10fc0e: 83 38 00 cmpl $0x0,(%eax)
10fc11: 75 12 jne 10fc25 <fifo_open+0x21e>
if (err)
10fc13: 85 f6 test %esi,%esi
10fc15: 74 09 je 10fc20 <fifo_open+0x219> <== ALWAYS TAKEN
pipe_free(pipe);
10fc17: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10fc19: e8 1c fd ff ff call 10f93a <pipe_free> <== NOT EXECUTED
10fc1e: eb 05 jmp 10fc25 <fifo_open+0x21e> <== NOT EXECUTED
else
*pipep = pipe;
10fc20: 8b 55 08 mov 0x8(%ebp),%edx
10fc23: 89 1a mov %ebx,(%edx)
}
out:
pipe_unlock();
10fc25: e8 fa fc ff ff call 10f924 <pipe_unlock>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
10fc2a: 85 f6 test %esi,%esi
10fc2c: 0f 85 94 01 00 00 jne 10fdc6 <fifo_open+0x3bf>
return err;
pipe = *pipep;
10fc32: 8b 45 08 mov 0x8(%ebp),%eax
10fc35: 8b 18 mov (%eax),%ebx
switch (LIBIO_ACCMODE(iop)) {
10fc37: 8b 55 0c mov 0xc(%ebp),%edx
10fc3a: 8b 42 14 mov 0x14(%edx),%eax
10fc3d: 83 e0 06 and $0x6,%eax
10fc40: 83 f8 04 cmp $0x4,%eax
10fc43: 0f 84 91 00 00 00 je 10fcda <fifo_open+0x2d3>
10fc49: 83 f8 06 cmp $0x6,%eax
10fc4c: 0f 84 10 01 00 00 je 10fd62 <fifo_open+0x35b>
10fc52: 83 f8 02 cmp $0x2,%eax
10fc55: 0f 85 49 01 00 00 jne 10fda4 <fifo_open+0x39d> <== NEVER TAKEN
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
10fc5b: ff 43 20 incl 0x20(%ebx)
if (pipe->Readers ++ == 0)
10fc5e: 8b 43 10 mov 0x10(%ebx),%eax
10fc61: 8d 50 01 lea 0x1(%eax),%edx
10fc64: 89 53 10 mov %edx,0x10(%ebx)
10fc67: 85 c0 test %eax,%eax
10fc69: 75 11 jne 10fc7c <fifo_open+0x275> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
10fc6b: 57 push %edi
10fc6c: 57 push %edi
10fc6d: 8d 45 e4 lea -0x1c(%ebp),%eax
10fc70: 50 push %eax
10fc71: ff 73 30 pushl 0x30(%ebx)
10fc74: e8 07 18 00 00 call 111480 <rtems_barrier_release>
10fc79: 83 c4 10 add $0x10,%esp
if (pipe->Writers == 0) {
10fc7c: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fc80: 0f 85 1e 01 00 00 jne 10fda4 <fifo_open+0x39d>
/* Not an error */
if (LIBIO_NODELAY(iop))
10fc86: 8b 45 0c mov 0xc(%ebp),%eax
10fc89: f6 40 14 01 testb $0x1,0x14(%eax)
10fc8d: 0f 85 11 01 00 00 jne 10fda4 <fifo_open+0x39d>
break;
prevCounter = pipe->writerCounter;
10fc93: 8b 7b 24 mov 0x24(%ebx),%edi
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
10fc96: 83 ec 0c sub $0xc,%esp
10fc99: ff 73 28 pushl 0x28(%ebx)
10fc9c: e8 5b c0 ff ff call 10bcfc <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
10fca1: 5a pop %edx
10fca2: 59 pop %ecx
10fca3: 6a 00 push $0x0
10fca5: ff 73 2c pushl 0x2c(%ebx)
10fca8: e8 2b 18 00 00 call 1114d8 <rtems_barrier_wait>
10fcad: 83 c4 10 add $0x10,%esp
10fcb0: 85 c0 test %eax,%eax
10fcb2: 0f 85 f9 00 00 00 jne 10fdb1 <fifo_open+0x3aa> <== NEVER TAKEN
goto out_error;
if (! PIPE_LOCK(pipe))
10fcb8: 50 push %eax
10fcb9: 6a 00 push $0x0
10fcbb: 6a 00 push $0x0
10fcbd: ff 73 28 pushl 0x28(%ebx)
10fcc0: e8 4b bf ff ff call 10bc10 <rtems_semaphore_obtain>
10fcc5: 83 c4 10 add $0x10,%esp
10fcc8: 85 c0 test %eax,%eax
10fcca: 0f 85 e1 00 00 00 jne 10fdb1 <fifo_open+0x3aa> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->writerCounter);
10fcd0: 3b 7b 24 cmp 0x24(%ebx),%edi
10fcd3: 74 c1 je 10fc96 <fifo_open+0x28f> <== NEVER TAKEN
10fcd5: e9 ca 00 00 00 jmp 10fda4 <fifo_open+0x39d>
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
10fcda: ff 43 24 incl 0x24(%ebx)
if (pipe->Writers ++ == 0)
10fcdd: 8b 43 14 mov 0x14(%ebx),%eax
10fce0: 8d 50 01 lea 0x1(%eax),%edx
10fce3: 89 53 14 mov %edx,0x14(%ebx)
10fce6: 85 c0 test %eax,%eax
10fce8: 75 11 jne 10fcfb <fifo_open+0x2f4> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
10fcea: 57 push %edi
10fceb: 57 push %edi
10fcec: 8d 45 e4 lea -0x1c(%ebp),%eax
10fcef: 50 push %eax
10fcf0: ff 73 2c pushl 0x2c(%ebx)
10fcf3: e8 88 17 00 00 call 111480 <rtems_barrier_release>
10fcf8: 83 c4 10 add $0x10,%esp
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
10fcfb: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10fcff: 0f 85 9f 00 00 00 jne 10fda4 <fifo_open+0x39d>
10fd05: 8b 55 0c mov 0xc(%ebp),%edx
10fd08: f6 42 14 01 testb $0x1,0x14(%edx)
10fd0c: 74 18 je 10fd26 <fifo_open+0x31f>
PIPE_UNLOCK(pipe);
10fd0e: 83 ec 0c sub $0xc,%esp
10fd11: ff 73 28 pushl 0x28(%ebx)
10fd14: e8 e3 bf ff ff call 10bcfc <rtems_semaphore_release>
err = -ENXIO;
goto out_error;
10fd19: 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;
10fd1c: be fa ff ff ff mov $0xfffffffa,%esi
goto out_error;
10fd21: e9 90 00 00 00 jmp 10fdb6 <fifo_open+0x3af>
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
10fd26: 8b 7b 20 mov 0x20(%ebx),%edi
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
10fd29: 83 ec 0c sub $0xc,%esp
10fd2c: ff 73 28 pushl 0x28(%ebx)
10fd2f: e8 c8 bf ff ff call 10bcfc <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
10fd34: 5a pop %edx
10fd35: 59 pop %ecx
10fd36: 6a 00 push $0x0
10fd38: ff 73 30 pushl 0x30(%ebx)
10fd3b: e8 98 17 00 00 call 1114d8 <rtems_barrier_wait>
10fd40: 83 c4 10 add $0x10,%esp
10fd43: 85 c0 test %eax,%eax
10fd45: 75 6a jne 10fdb1 <fifo_open+0x3aa> <== NEVER TAKEN
goto out_error;
if (! PIPE_LOCK(pipe))
10fd47: 50 push %eax
10fd48: 6a 00 push $0x0
10fd4a: 6a 00 push $0x0
10fd4c: ff 73 28 pushl 0x28(%ebx)
10fd4f: e8 bc be ff ff call 10bc10 <rtems_semaphore_obtain>
10fd54: 83 c4 10 add $0x10,%esp
10fd57: 85 c0 test %eax,%eax
10fd59: 75 56 jne 10fdb1 <fifo_open+0x3aa> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->readerCounter);
10fd5b: 3b 7b 20 cmp 0x20(%ebx),%edi
10fd5e: 74 c9 je 10fd29 <fifo_open+0x322> <== NEVER TAKEN
10fd60: eb 42 jmp 10fda4 <fifo_open+0x39d>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
10fd62: ff 43 20 incl 0x20(%ebx)
if (pipe->Readers ++ == 0)
10fd65: 8b 43 10 mov 0x10(%ebx),%eax
10fd68: 8d 50 01 lea 0x1(%eax),%edx
10fd6b: 89 53 10 mov %edx,0x10(%ebx)
10fd6e: 85 c0 test %eax,%eax
10fd70: 75 11 jne 10fd83 <fifo_open+0x37c> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
10fd72: 51 push %ecx
10fd73: 51 push %ecx
10fd74: 8d 45 e4 lea -0x1c(%ebp),%eax
10fd77: 50 push %eax
10fd78: ff 73 30 pushl 0x30(%ebx)
10fd7b: e8 00 17 00 00 call 111480 <rtems_barrier_release>
10fd80: 83 c4 10 add $0x10,%esp
pipe->writerCounter ++;
10fd83: ff 43 24 incl 0x24(%ebx)
if (pipe->Writers ++ == 0)
10fd86: 8b 43 14 mov 0x14(%ebx),%eax
10fd89: 8d 50 01 lea 0x1(%eax),%edx
10fd8c: 89 53 14 mov %edx,0x14(%ebx)
10fd8f: 85 c0 test %eax,%eax
10fd91: 75 11 jne 10fda4 <fifo_open+0x39d> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
10fd93: 52 push %edx
10fd94: 52 push %edx
10fd95: 8d 45 e4 lea -0x1c(%ebp),%eax
10fd98: 50 push %eax
10fd99: ff 73 2c pushl 0x2c(%ebx)
10fd9c: e8 df 16 00 00 call 111480 <rtems_barrier_release>
10fda1: 83 c4 10 add $0x10,%esp
break;
}
PIPE_UNLOCK(pipe);
10fda4: 83 ec 0c sub $0xc,%esp
10fda7: ff 73 28 pushl 0x28(%ebx)
10fdaa: e8 4d bf ff ff call 10bcfc <rtems_semaphore_release>
10fdaf: eb 12 jmp 10fdc3 <fifo_open+0x3bc>
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
10fdb1: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
10fdb6: 50 push %eax
10fdb7: 50 push %eax
10fdb8: ff 75 0c pushl 0xc(%ebp)
10fdbb: ff 75 08 pushl 0x8(%ebp)
10fdbe: e8 b2 fb ff ff call 10f975 <pipe_release>
return err;
10fdc3: 83 c4 10 add $0x10,%esp
}
10fdc6: 89 f0 mov %esi,%eax
10fdc8: 8d 65 f4 lea -0xc(%ebp),%esp
10fdcb: 5b pop %ebx
10fdcc: 5e pop %esi
10fdcd: 5f pop %edi
10fdce: c9 leave
10fdcf: c3 ret
00107d8c <fpathconf>:
long fpathconf(
int fd,
int name
)
{
107d8c: 55 push %ebp
107d8d: 89 e5 mov %esp,%ebp
107d8f: 83 ec 08 sub $0x8,%esp
107d92: 8b 45 08 mov 0x8(%ebp),%eax
107d95: 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);
107d98: 3b 05 44 21 12 00 cmp 0x122144,%eax
107d9e: 73 11 jae 107db1 <fpathconf+0x25>
iop = rtems_libio_iop(fd);
107da0: 6b c0 38 imul $0x38,%eax,%eax
107da3: 03 05 98 61 12 00 add 0x126198,%eax
rtems_libio_check_is_open(iop);
107da9: 8b 48 14 mov 0x14(%eax),%ecx
107dac: f6 c5 01 test $0x1,%ch
107daf: 75 0d jne 107dbe <fpathconf+0x32> <== ALWAYS TAKEN
107db1: e8 5e a1 00 00 call 111f14 <__errno>
107db6: c7 00 09 00 00 00 movl $0x9,(%eax)
107dbc: eb 5b jmp 107e19 <fpathconf+0x8d>
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
107dbe: 80 e1 02 and $0x2,%cl
107dc1: 74 4b je 107e0e <fpathconf+0x82>
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
107dc3: 8b 40 28 mov 0x28(%eax),%eax
switch ( name ) {
107dc6: 83 fa 0b cmp $0xb,%edx
107dc9: 77 43 ja 107e0e <fpathconf+0x82>
107dcb: ff 24 95 50 ff 11 00 jmp *0x11ff50(,%edx,4)
case _PC_LINK_MAX:
return_value = the_limits->link_max;
107dd2: 8b 40 38 mov 0x38(%eax),%eax
break;
107dd5: eb 45 jmp 107e1c <fpathconf+0x90>
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
107dd7: 8b 40 3c mov 0x3c(%eax),%eax
break;
107dda: eb 40 jmp 107e1c <fpathconf+0x90>
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
107ddc: 8b 40 40 mov 0x40(%eax),%eax
break;
107ddf: eb 3b jmp 107e1c <fpathconf+0x90>
case _PC_NAME_MAX:
return_value = the_limits->name_max;
107de1: 8b 40 44 mov 0x44(%eax),%eax
break;
107de4: eb 36 jmp 107e1c <fpathconf+0x90>
case _PC_PATH_MAX:
return_value = the_limits->path_max;
107de6: 8b 40 48 mov 0x48(%eax),%eax
break;
107de9: eb 31 jmp 107e1c <fpathconf+0x90>
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
107deb: 8b 40 4c mov 0x4c(%eax),%eax
break;
107dee: eb 2c jmp 107e1c <fpathconf+0x90>
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
107df0: 8b 40 54 mov 0x54(%eax),%eax
break;
107df3: eb 27 jmp 107e1c <fpathconf+0x90>
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
107df5: 8b 40 58 mov 0x58(%eax),%eax
break;
107df8: eb 22 jmp 107e1c <fpathconf+0x90>
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
107dfa: 8b 40 64 mov 0x64(%eax),%eax
break;
107dfd: eb 1d jmp 107e1c <fpathconf+0x90>
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
107dff: 8b 40 50 mov 0x50(%eax),%eax
break;
107e02: eb 18 jmp 107e1c <fpathconf+0x90>
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
107e04: 8b 40 5c mov 0x5c(%eax),%eax
break;
107e07: eb 13 jmp 107e1c <fpathconf+0x90>
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
107e09: 8b 40 60 mov 0x60(%eax),%eax
break;
107e0c: eb 0e jmp 107e1c <fpathconf+0x90>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
107e0e: e8 01 a1 00 00 call 111f14 <__errno>
107e13: c7 00 16 00 00 00 movl $0x16,(%eax)
107e19: 83 c8 ff or $0xffffffff,%eax
break;
}
return return_value;
}
107e1c: c9 leave
107e1d: c3 ret
00107348 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
107348: 55 push %ebp
107349: 89 e5 mov %esp,%ebp
10734b: 53 push %ebx
10734c: 83 ec 04 sub $0x4,%esp
10734f: 8b 5d 08 mov 0x8(%ebp),%ebx
MSBUMP(free_calls, 1);
107352: ff 05 bc 41 12 00 incl 0x1241bc
if ( !ptr )
107358: 85 db test %ebx,%ebx
10735a: 74 5f je 1073bb <free+0x73>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10735c: 83 3d 64 44 12 00 03 cmpl $0x3,0x124464
107363: 75 15 jne 10737a <free+0x32> <== NEVER TAKEN
!malloc_is_system_state_OK() ) {
107365: e8 56 01 00 00 call 1074c0 <malloc_is_system_state_OK>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10736a: 84 c0 test %al,%al
10736c: 75 0c jne 10737a <free+0x32>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
10736e: 89 5d 08 mov %ebx,0x8(%ebp)
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
107371: 8b 5d fc mov -0x4(%ebp),%ebx
107374: c9 leave
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
107375: e9 ae 01 00 00 jmp 107528 <malloc_deferred_free>
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
10737a: a1 10 26 12 00 mov 0x122610,%eax
10737f: 85 c0 test %eax,%eax
107381: 74 0a je 10738d <free+0x45>
(*rtems_malloc_statistics_helpers->at_free)(ptr);
107383: 83 ec 0c sub $0xc,%esp
107386: 53 push %ebx
107387: ff 50 08 call *0x8(%eax)
10738a: 83 c4 10 add $0x10,%esp
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
10738d: 50 push %eax
10738e: 50 push %eax
10738f: 53 push %ebx
107390: ff 35 50 01 12 00 pushl 0x120150
107396: e8 15 46 00 00 call 10b9b0 <_Protected_heap_Free>
10739b: 83 c4 10 add $0x10,%esp
10739e: 84 c0 test %al,%al
1073a0: 75 19 jne 1073bb <free+0x73>
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
ptr,
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
1073a2: a1 50 01 12 00 mov 0x120150,%eax
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_free)(ptr);
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
1073a7: ff 70 1c pushl 0x1c(%eax)
1073aa: ff 70 18 pushl 0x18(%eax)
1073ad: 53 push %ebx
1073ae: 68 db e5 11 00 push $0x11e5db
1073b3: e8 d8 0b 00 00 call 107f90 <printk>
1073b8: 83 c4 10 add $0x10,%esp
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
1073bb: 8b 5d fc mov -0x4(%ebp),%ebx
1073be: c9 leave
1073bf: c3 ret
001085d0 <free_user_env>:
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
1085d0: 55 push %ebp
1085d1: 89 e5 mov %esp,%ebp
1085d3: 53 push %ebx
1085d4: 83 ec 04 sub $0x4,%esp
1085d7: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
1085da: 81 fb c8 51 12 00 cmp $0x1251c8,%ebx
1085e0: 74 26 je 108608 <free_user_env+0x38> <== NEVER TAKEN
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
1085e2: 83 ec 0c sub $0xc,%esp
1085e5: 8d 43 04 lea 0x4(%ebx),%eax
1085e8: 50 push %eax
1085e9: e8 6a f1 ff ff call 107758 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &env->root_directory);
1085ee: 8d 43 18 lea 0x18(%ebx),%eax
1085f1: 89 04 24 mov %eax,(%esp)
1085f4: e8 5f f1 ff ff call 107758 <rtems_filesystem_freenode>
free(env);
1085f9: 83 c4 10 add $0x10,%esp
1085fc: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
1085ff: 8b 5d fc mov -0x4(%ebp),%ebx
108602: c9 leave
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
108603: e9 64 f1 ff ff jmp 10776c <free>
}
}
108608: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10860b: c9 leave <== NOT EXECUTED
10860c: c3 ret <== NOT EXECUTED
0011de58 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
11de58: 55 push %ebp
11de59: 89 e5 mov %esp,%ebp
11de5b: 57 push %edi
11de5c: 56 push %esi
11de5d: 53 push %ebx
11de5e: 83 ec 2c sub $0x2c,%esp
11de61: 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 );
11de64: 31 db xor %ebx,%ebx
11de66: 3b 05 44 31 12 00 cmp 0x123144,%eax
11de6c: 73 09 jae 11de77 <getdents+0x1f> <== NEVER TAKEN
11de6e: 6b d8 38 imul $0x38,%eax,%ebx
11de71: 03 1d c0 72 12 00 add 0x1272c0,%ebx
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
11de77: 8d 7d d4 lea -0x2c(%ebp),%edi
11de7a: 8d 73 18 lea 0x18(%ebx),%esi
11de7d: b9 05 00 00 00 mov $0x5,%ecx
11de82: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
11de84: 83 ec 0c sub $0xc,%esp
11de87: 8d 45 d4 lea -0x2c(%ebp),%eax
11de8a: 50 push %eax
11de8b: 8b 45 e0 mov -0x20(%ebp),%eax
11de8e: ff 50 10 call *0x10(%eax)
11de91: 83 c4 10 add $0x10,%esp
11de94: 48 dec %eax
11de95: 74 10 je 11dea7 <getdents+0x4f>
rtems_set_errno_and_return_minus_one( ENOTDIR );
11de97: e8 98 41 ff ff call 112034 <__errno>
11de9c: c7 00 14 00 00 00 movl $0x14,(%eax)
11dea2: 83 c8 ff or $0xffffffff,%eax
11dea5: eb 11 jmp 11deb8 <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 );
11dea7: 50 push %eax
11dea8: 8b 43 20 mov 0x20(%ebx),%eax
11deab: ff 75 10 pushl 0x10(%ebp)
11deae: ff 75 0c pushl 0xc(%ebp)
11deb1: 53 push %ebx
11deb2: ff 50 08 call *0x8(%eax)
11deb5: 83 c4 10 add $0x10,%esp
}
11deb8: 8d 65 f4 lea -0xc(%ebp),%esp
11debb: 5b pop %ebx
11debc: 5e pop %esi
11debd: 5f pop %edi
11debe: c9 leave
11debf: c3 ret
00110690 <imfs_dir_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
110690: 55 push %ebp
110691: 89 e5 mov %esp,%ebp
110693: 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 )
110696: 8b 4a 18 mov 0x18(%edx),%ecx
return -1; /* It wasn't a directory --> return error */
110699: 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 )
11069c: 83 79 4c 01 cmpl $0x1,0x4c(%ecx)
1106a0: 75 10 jne 1106b2 <imfs_dir_open+0x22> <== NEVER TAKEN
return -1; /* It wasn't a directory --> return error */
iop->offset = 0;
1106a2: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
1106a9: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
return 0;
1106b0: 31 c0 xor %eax,%eax
}
1106b2: c9 leave
1106b3: c3 ret
001108f1 <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
1108f1: 55 push %ebp
1108f2: 89 e5 mov %esp,%ebp
1108f4: 53 push %ebx
1108f5: 83 ec 04 sub $0x4,%esp
1108f8: 8b 45 0c mov 0xc(%ebp),%eax
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
1108fb: 8b 18 mov (%eax),%ebx
1108fd: 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 ) )
110900: 39 53 50 cmp %edx,0x50(%ebx)
110903: 74 0d je 110912 <imfs_dir_rmnod+0x21>
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
110905: e8 a2 07 00 00 call 1110ac <__errno>
11090a: c7 00 5a 00 00 00 movl $0x5a,(%eax)
110910: eb 13 jmp 110925 <imfs_dir_rmnod+0x34>
/*
* You cannot remove the file system root node.
*/
if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
110912: 8b 40 10 mov 0x10(%eax),%eax
110915: 39 58 1c cmp %ebx,0x1c(%eax)
110918: 75 10 jne 11092a <imfs_dir_rmnod+0x39>
rtems_set_errno_and_return_minus_one( EBUSY );
11091a: e8 8d 07 00 00 call 1110ac <__errno>
11091f: c7 00 10 00 00 00 movl $0x10,(%eax)
110925: 83 c8 ff or $0xffffffff,%eax
110928: eb 1c jmp 110946 <imfs_dir_rmnod+0x55>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
11092a: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx)
11092e: 75 ea jne 11091a <imfs_dir_rmnod+0x29> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBUSY );
IMFS_create_orphan( the_jnode );
110930: 83 ec 0c sub $0xc,%esp
110933: 53 push %ebx
110934: e8 23 d4 ff ff call 10dd5c <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
110939: 89 1c 24 mov %ebx,(%esp)
11093c: e8 5d d4 ff ff call 10dd9e <IMFS_check_node_remove>
return 0;
110941: 83 c4 10 add $0x10,%esp
110944: 31 c0 xor %eax,%eax
}
110946: 8b 5d fc mov -0x4(%ebp),%ebx
110949: c9 leave
11094a: c3 ret
00107c6c <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
107c6c: 55 push %ebp
107c6d: 89 e5 mov %esp,%ebp
107c6f: 53 push %ebx
107c70: 83 ec 04 sub $0x4,%esp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
107c73: 80 3d 5c 60 12 00 00 cmpb $0x0,0x12605c
107c7a: 0f 85 b8 00 00 00 jne 107d38 <init_etc_passwd_group+0xcc>
return;
etc_passwd_initted = 1;
107c80: c6 05 5c 60 12 00 01 movb $0x1,0x12605c
mkdir("/etc", 0777);
107c87: 50 push %eax
107c88: 50 push %eax
107c89: 68 ff 01 00 00 push $0x1ff
107c8e: 68 87 fe 11 00 push $0x11fe87
107c93: e8 7c 07 00 00 call 108414 <mkdir>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
107c98: 59 pop %ecx
107c99: 5b pop %ebx
107c9a: 68 d2 eb 11 00 push $0x11ebd2
107c9f: 68 8c fe 11 00 push $0x11fe8c
107ca4: e8 ef a9 00 00 call 112698 <fopen>
107ca9: 83 c4 10 add $0x10,%esp
107cac: 85 c0 test %eax,%eax
107cae: 74 06 je 107cb6 <init_etc_passwd_group+0x4a>
fclose(fp);
107cb0: 83 ec 0c sub $0xc,%esp
107cb3: 50 push %eax
107cb4: eb 2a jmp 107ce0 <init_etc_passwd_group+0x74>
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
107cb6: 52 push %edx
107cb7: 52 push %edx
107cb8: 68 ec ea 11 00 push $0x11eaec
107cbd: 68 8c fe 11 00 push $0x11fe8c
107cc2: e8 d1 a9 00 00 call 112698 <fopen>
107cc7: 89 c3 mov %eax,%ebx
107cc9: 83 c4 10 add $0x10,%esp
107ccc: 85 c0 test %eax,%eax
107cce: 74 18 je 107ce8 <init_etc_passwd_group+0x7c><== NEVER TAKEN
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
107cd0: 50 push %eax
107cd1: 50 push %eax
107cd2: 53 push %ebx
107cd3: 68 98 fe 11 00 push $0x11fe98
107cd8: e8 87 aa 00 00 call 112764 <fputs>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
107cdd: 89 1c 24 mov %ebx,(%esp)
107ce0: e8 af a2 00 00 call 111f94 <fclose>
107ce5: 83 c4 10 add $0x10,%esp
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
107ce8: 51 push %ecx
107ce9: 51 push %ecx
107cea: 68 d2 eb 11 00 push $0x11ebd2
107cef: 68 ff fe 11 00 push $0x11feff
107cf4: e8 9f a9 00 00 call 112698 <fopen>
107cf9: 83 c4 10 add $0x10,%esp
107cfc: 85 c0 test %eax,%eax
107cfe: 74 06 je 107d06 <init_etc_passwd_group+0x9a>
fclose(fp);
107d00: 83 ec 0c sub $0xc,%esp
107d03: 50 push %eax
107d04: eb 2a jmp 107d30 <init_etc_passwd_group+0xc4>
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
107d06: 52 push %edx
107d07: 52 push %edx
107d08: 68 ec ea 11 00 push $0x11eaec
107d0d: 68 ff fe 11 00 push $0x11feff
107d12: e8 81 a9 00 00 call 112698 <fopen>
107d17: 89 c3 mov %eax,%ebx
107d19: 83 c4 10 add $0x10,%esp
107d1c: 85 c0 test %eax,%eax
107d1e: 74 18 je 107d38 <init_etc_passwd_group+0xcc><== NEVER TAKEN
fprintf( fp, "root:x:0:root\n"
107d20: 50 push %eax
107d21: 50 push %eax
107d22: 53 push %ebx
107d23: 68 0a ff 11 00 push $0x11ff0a
107d28: e8 37 aa 00 00 call 112764 <fputs>
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
107d2d: 89 1c 24 mov %ebx,(%esp)
107d30: e8 5f a2 00 00 call 111f94 <fclose>
107d35: 83 c4 10 add $0x10,%esp
}
}
107d38: 8b 5d fc mov -0x4(%ebp),%ebx
107d3b: c9 leave
107d3c: c3 ret
00108e0c <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
108e0c: 55 push %ebp
108e0d: 89 e5 mov %esp,%ebp
108e0f: 53 push %ebx
108e10: 83 ec 14 sub $0x14,%esp
108e13: 89 d3 mov %edx,%ebx
108e15: 88 c1 mov %al,%cl
if (tty->termios.c_iflag & ISTRIP)
108e17: 8b 52 30 mov 0x30(%edx),%edx
108e1a: f6 c2 20 test $0x20,%dl
108e1d: 74 03 je 108e22 <iproc+0x16> <== ALWAYS TAKEN
c &= 0x7f;
108e1f: 83 e1 7f and $0x7f,%ecx <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
108e22: f6 c6 02 test $0x2,%dh
108e25: 74 16 je 108e3d <iproc+0x31>
c = tolower (c);
108e27: 0f b6 c9 movzbl %cl,%ecx
108e2a: a1 08 21 12 00 mov 0x122108,%eax
108e2f: 0f be 44 08 01 movsbl 0x1(%eax,%ecx,1),%eax
108e34: 83 e0 03 and $0x3,%eax
108e37: 48 dec %eax
108e38: 75 03 jne 108e3d <iproc+0x31>
108e3a: 83 c1 20 add $0x20,%ecx
if (c == '\r') {
108e3d: 80 f9 0d cmp $0xd,%cl
108e40: 75 14 jne 108e56 <iproc+0x4a>
if (tty->termios.c_iflag & IGNCR)
return 0;
108e42: 31 c0 xor %eax,%eax
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
108e44: f6 c2 80 test $0x80,%dl
108e47: 0f 85 d9 00 00 00 jne 108f26 <iproc+0x11a> <== NEVER TAKEN
return 0;
if (tty->termios.c_iflag & ICRNL)
108e4d: 80 e6 01 and $0x1,%dh
108e50: 74 1a je 108e6c <iproc+0x60> <== NEVER TAKEN
c = '\n';
108e52: b1 0a mov $0xa,%cl
108e54: eb 16 jmp 108e6c <iproc+0x60>
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
108e56: 80 f9 0a cmp $0xa,%cl
108e59: 75 09 jne 108e64 <iproc+0x58>
108e5b: 80 e2 40 and $0x40,%dl
108e5e: 74 0c je 108e6c <iproc+0x60> <== ALWAYS TAKEN
c = '\r';
108e60: b1 0d mov $0xd,%cl <== NOT EXECUTED
108e62: eb 08 jmp 108e6c <iproc+0x60> <== NOT EXECUTED
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
108e64: 84 c9 test %cl,%cl
108e66: 0f 84 87 00 00 00 je 108ef3 <iproc+0xe7> <== NEVER TAKEN
108e6c: 8b 53 3c mov 0x3c(%ebx),%edx
108e6f: f6 c2 02 test $0x2,%dl
108e72: 74 7f je 108ef3 <iproc+0xe7>
if (c == tty->termios.c_cc[VERASE]) {
108e74: 3a 4b 43 cmp 0x43(%ebx),%cl
108e77: 75 04 jne 108e7d <iproc+0x71>
erase (tty, 0);
108e79: 31 d2 xor %edx,%edx
108e7b: eb 0a jmp 108e87 <iproc+0x7b>
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
108e7d: 3a 4b 44 cmp 0x44(%ebx),%cl
108e80: 75 11 jne 108e93 <iproc+0x87>
erase (tty, 1);
108e82: ba 01 00 00 00 mov $0x1,%edx
108e87: 89 d8 mov %ebx,%eax
108e89: e8 05 fe ff ff call 108c93 <erase>
108e8e: e9 91 00 00 00 jmp 108f24 <iproc+0x118>
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
108e93: b8 01 00 00 00 mov $0x1,%eax
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
108e98: 3a 4b 45 cmp 0x45(%ebx),%cl
108e9b: 0f 84 85 00 00 00 je 108f26 <iproc+0x11a> <== NEVER TAKEN
return 1;
} else if (c == '\n') {
108ea1: 80 f9 0a cmp $0xa,%cl
108ea4: 75 1a jne 108ec0 <iproc+0xb4>
if (tty->termios.c_lflag & (ECHO | ECHONL))
108ea6: 80 e2 48 and $0x48,%dl
108ea9: 74 09 je 108eb4 <iproc+0xa8> <== NEVER TAKEN
echo (c, tty);
108eab: 89 da mov %ebx,%edx
108ead: b0 0a mov $0xa,%al
108eaf: e8 87 fd ff ff call 108c3b <echo>
tty->cbuf[tty->ccount++] = c;
108eb4: 8b 43 20 mov 0x20(%ebx),%eax
108eb7: 8b 53 1c mov 0x1c(%ebx),%edx
108eba: c6 04 02 0a movb $0xa,(%edx,%eax,1)
108ebe: eb 28 jmp 108ee8 <iproc+0xdc>
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
108ec0: 3a 4b 4c cmp 0x4c(%ebx),%cl
108ec3: 74 05 je 108eca <iproc+0xbe> <== NEVER TAKEN
108ec5: 3a 4b 51 cmp 0x51(%ebx),%cl
108ec8: 75 29 jne 108ef3 <iproc+0xe7> <== ALWAYS TAKEN
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
108eca: 80 e2 08 and $0x8,%dl <== NOT EXECUTED
108ecd: 74 10 je 108edf <iproc+0xd3> <== NOT EXECUTED
echo (c, tty);
108ecf: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED
108ed2: 89 da mov %ebx,%edx <== NOT EXECUTED
108ed4: 88 4d f4 mov %cl,-0xc(%ebp) <== NOT EXECUTED
108ed7: e8 5f fd ff ff call 108c3b <echo> <== NOT EXECUTED
108edc: 8a 4d f4 mov -0xc(%ebp),%cl <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
108edf: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED
108ee2: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED
108ee5: 88 0c 02 mov %cl,(%edx,%eax,1) <== NOT EXECUTED
108ee8: 40 inc %eax
108ee9: 89 43 20 mov %eax,0x20(%ebx)
return 1;
108eec: b8 01 00 00 00 mov $0x1,%eax
108ef1: eb 33 jmp 108f26 <iproc+0x11a>
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
108ef3: 8b 15 40 20 12 00 mov 0x122040,%edx
108ef9: 4a dec %edx
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
108efa: 31 c0 xor %eax,%eax
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
108efc: 39 53 20 cmp %edx,0x20(%ebx)
108eff: 7d 25 jge 108f26 <iproc+0x11a> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHO)
108f01: f6 43 3c 08 testb $0x8,0x3c(%ebx)
108f05: 74 10 je 108f17 <iproc+0x10b> <== NEVER TAKEN
echo (c, tty);
108f07: 0f b6 c1 movzbl %cl,%eax
108f0a: 89 da mov %ebx,%edx
108f0c: 88 4d f4 mov %cl,-0xc(%ebp)
108f0f: e8 27 fd ff ff call 108c3b <echo>
108f14: 8a 4d f4 mov -0xc(%ebp),%cl
tty->cbuf[tty->ccount++] = c;
108f17: 8b 43 20 mov 0x20(%ebx),%eax
108f1a: 8b 53 1c mov 0x1c(%ebx),%edx
108f1d: 88 0c 02 mov %cl,(%edx,%eax,1)
108f20: 40 inc %eax
108f21: 89 43 20 mov %eax,0x20(%ebx)
}
return 0;
108f24: 31 c0 xor %eax,%eax
}
108f26: 83 c4 14 add $0x14,%esp
108f29: 5b pop %ebx
108f2a: c9 leave
108f2b: c3 ret
00121620 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
121620: 55 push %ebp
121621: 89 e5 mov %esp,%ebp
121623: 57 push %edi
121624: 56 push %esi
121625: 53 push %ebx
121626: 83 ec 4c sub $0x4c,%esp
121629: 8b 5d 0c mov 0xc(%ebp),%ebx
12162c: 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() )
12162f: e8 64 fd ff ff call 121398 <getpid>
121634: 39 45 08 cmp %eax,0x8(%ebp)
121637: 74 0d je 121646 <killinfo+0x26>
rtems_set_errno_and_return_minus_one( ESRCH );
121639: e8 16 43 ff ff call 115954 <__errno>
12163e: c7 00 03 00 00 00 movl $0x3,(%eax)
121644: eb 0f jmp 121655 <killinfo+0x35>
/*
* Validate the signal passed.
*/
if ( !sig )
121646: 85 db test %ebx,%ebx
121648: 75 13 jne 12165d <killinfo+0x3d>
rtems_set_errno_and_return_minus_one( EINVAL );
12164a: e8 05 43 ff ff call 115954 <__errno>
12164f: c7 00 16 00 00 00 movl $0x16,(%eax)
121655: 83 c8 ff or $0xffffffff,%eax
121658: e9 ef 01 00 00 jmp 12184c <killinfo+0x22c>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
12165d: 8d 4b ff lea -0x1(%ebx),%ecx
if ( !is_valid_signo(sig) )
121660: 83 f9 1f cmp $0x1f,%ecx
121663: 77 e5 ja 12164a <killinfo+0x2a>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
121665: 6b d3 0c imul $0xc,%ebx,%edx
return 0;
121668: 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 )
12166a: 83 ba c0 a9 12 00 01 cmpl $0x1,0x12a9c0(%edx)
121671: 0f 84 d5 01 00 00 je 12184c <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 ) )
121677: 83 fb 04 cmp $0x4,%ebx
12167a: 74 0a je 121686 <killinfo+0x66>
12167c: 83 fb 08 cmp $0x8,%ebx
12167f: 74 05 je 121686 <killinfo+0x66>
121681: 83 fb 0b cmp $0xb,%ebx
121684: 75 16 jne 12169c <killinfo+0x7c>
return pthread_kill( pthread_self(), sig );
121686: e8 89 03 00 00 call 121a14 <pthread_self>
12168b: 56 push %esi
12168c: 56 push %esi
12168d: 53 push %ebx
12168e: 50 push %eax
12168f: e8 d8 02 00 00 call 12196c <pthread_kill>
121694: 83 c4 10 add $0x10,%esp
121697: e9 b0 01 00 00 jmp 12184c <killinfo+0x22c>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
12169c: be 01 00 00 00 mov $0x1,%esi
1216a1: d3 e6 shl %cl,%esi
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
1216a3: 89 5d dc mov %ebx,-0x24(%ebp)
siginfo->si_code = SI_USER;
1216a6: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
if ( !value ) {
1216ad: 85 ff test %edi,%edi
1216af: 75 09 jne 1216ba <killinfo+0x9a>
siginfo->si_value.sival_int = 0;
1216b1: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
1216b8: eb 05 jmp 1216bf <killinfo+0x9f>
} else {
siginfo->si_value = *value;
1216ba: 8b 07 mov (%edi),%eax
1216bc: 89 45 e4 mov %eax,-0x1c(%ebp)
1216bf: a1 58 a4 12 00 mov 0x12a458,%eax
1216c4: 40 inc %eax
1216c5: a3 58 a4 12 00 mov %eax,0x12a458
/*
* 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;
1216ca: a1 a8 a9 12 00 mov 0x12a9a8,%eax
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
1216cf: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx
1216d5: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx
1216db: f7 d2 not %edx
1216dd: 85 d6 test %edx,%esi
1216df: 0f 85 ed 00 00 00 jne 1217d2 <killinfo+0x1b2>
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = the_chain->first ;
1216e5: 8b 15 44 ab 12 00 mov 0x12ab44,%edx
1216eb: eb 23 jmp 121710 <killinfo+0xf0>
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
1216ed: 89 d0 mov %edx,%eax
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
1216ef: 8b 8a f8 00 00 00 mov 0xf8(%edx),%ecx
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
1216f5: 85 72 30 test %esi,0x30(%edx)
1216f8: 0f 85 d4 00 00 00 jne 1217d2 <killinfo+0x1b2>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
1216fe: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx
121704: f7 d1 not %ecx
121706: 85 ce test %ecx,%esi
121708: 0f 85 c4 00 00 00 jne 1217d2 <killinfo+0x1b2>
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = the_chain->first ;
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
12170e: 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 = the_chain->first ;
121710: 81 fa 48 ab 12 00 cmp $0x12ab48,%edx
121716: 75 d5 jne 1216ed <killinfo+0xcd>
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
121718: 0f b6 0d f4 61 12 00 movzbl 0x1261f4,%ecx
12171f: 41 inc %ecx
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
121720: 31 c0 xor %eax,%eax
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
121722: 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 ] )
121729: 8b 7d cc mov -0x34(%ebp),%edi
12172c: 8b 14 bd 30 a4 12 00 mov 0x12a430(,%edi,4),%edx
121733: 85 d2 test %edx,%edx
121735: 0f 84 86 00 00 00 je 1217c1 <killinfo+0x1a1> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
12173b: 8b 52 04 mov 0x4(%edx),%edx
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
12173e: 0f b7 7a 10 movzwl 0x10(%edx),%edi
121742: 89 7d c4 mov %edi,-0x3c(%ebp)
object_table = the_info->local_table;
121745: 8b 52 1c mov 0x1c(%edx),%edx
121748: 89 55 c0 mov %edx,-0x40(%ebp)
for ( index = 1 ; index <= maximum ; index++ ) {
12174b: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp)
121752: 89 5d b4 mov %ebx,-0x4c(%ebp)
121755: eb 5f jmp 1217b6 <killinfo+0x196>
the_thread = (Thread_Control *) object_table[ index ];
121757: 8b 5d d0 mov -0x30(%ebp),%ebx
12175a: 8b 7d c0 mov -0x40(%ebp),%edi
12175d: 8b 14 9f mov (%edi,%ebx,4),%edx
if ( !the_thread )
121760: 85 d2 test %edx,%edx
121762: 74 4f je 1217b3 <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 )
121764: 8b 5a 14 mov 0x14(%edx),%ebx
121767: 89 5d d4 mov %ebx,-0x2c(%ebp)
12176a: 39 cb cmp %ecx,%ebx
12176c: 77 45 ja 1217b3 <killinfo+0x193>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
12176e: 8b ba f8 00 00 00 mov 0xf8(%edx),%edi
121774: 8b bf d0 00 00 00 mov 0xd0(%edi),%edi
12177a: f7 d7 not %edi
12177c: 85 fe test %edi,%esi
12177e: 74 33 je 1217b3 <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 ) {
121780: 39 cb cmp %ecx,%ebx
121782: 72 2a jb 1217ae <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 ) ) {
121784: 85 c0 test %eax,%eax
121786: 74 2b je 1217b3 <killinfo+0x193> <== NEVER TAKEN
121788: 8b 78 10 mov 0x10(%eax),%edi
12178b: 89 7d c8 mov %edi,-0x38(%ebp)
12178e: 85 ff test %edi,%edi
121790: 74 21 je 1217b3 <killinfo+0x193> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
121792: 8b 7a 10 mov 0x10(%edx),%edi
121795: 85 ff test %edi,%edi
121797: 74 15 je 1217ae <killinfo+0x18e>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
121799: f7 45 c8 00 00 00 10 testl $0x10000000,-0x38(%ebp)
1217a0: 75 11 jne 1217b3 <killinfo+0x193>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
1217a2: 81 e7 00 00 00 10 and $0x10000000,%edi
1217a8: 74 09 je 1217b3 <killinfo+0x193>
1217aa: 89 d9 mov %ebx,%ecx
1217ac: eb 03 jmp 1217b1 <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 ) ) {
1217ae: 8b 4d d4 mov -0x2c(%ebp),%ecx
1217b1: 89 d0 mov %edx,%eax
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
1217b3: ff 45 d0 incl -0x30(%ebp)
1217b6: 8b 55 c4 mov -0x3c(%ebp),%edx
1217b9: 39 55 d0 cmp %edx,-0x30(%ebp)
1217bc: 76 99 jbe 121757 <killinfo+0x137>
1217be: 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++) {
1217c1: ff 45 cc incl -0x34(%ebp)
1217c4: 83 7d cc 04 cmpl $0x4,-0x34(%ebp)
1217c8: 0f 85 5b ff ff ff jne 121729 <killinfo+0x109>
}
}
}
}
if ( interested ) {
1217ce: 85 c0 test %eax,%eax
1217d0: 74 13 je 1217e5 <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 ) ) {
1217d2: 51 push %ecx
mask = signo_to_mask( sig );
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
1217d3: 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 ) ) {
1217d6: 52 push %edx
1217d7: 53 push %ebx
1217d8: 50 push %eax
1217d9: e8 8a 00 00 00 call 121868 <_POSIX_signals_Unblock_thread>
1217de: 83 c4 10 add $0x10,%esp
1217e1: 84 c0 test %al,%al
1217e3: 75 60 jne 121845 <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 );
1217e5: 83 ec 0c sub $0xc,%esp
1217e8: 56 push %esi
1217e9: e8 66 00 00 00 call 121854 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
1217ee: 6b db 0c imul $0xc,%ebx,%ebx
1217f1: 83 c4 10 add $0x10,%esp
1217f4: 83 bb b8 a9 12 00 02 cmpl $0x2,0x12a9b8(%ebx)
1217fb: 75 48 jne 121845 <killinfo+0x225>
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
1217fd: 83 ec 0c sub $0xc,%esp
121800: 68 38 ab 12 00 push $0x12ab38
121805: e8 2a d9 fe ff call 10f134 <_Chain_Get>
if ( !psiginfo ) {
12180a: 83 c4 10 add $0x10,%esp
12180d: 85 c0 test %eax,%eax
12180f: 75 15 jne 121826 <killinfo+0x206>
_Thread_Enable_dispatch();
121811: e8 80 ee fe ff call 110696 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
121816: e8 39 41 ff ff call 115954 <__errno>
12181b: c7 00 0b 00 00 00 movl $0xb,(%eax)
121821: e9 2f fe ff ff jmp 121655 <killinfo+0x35>
}
psiginfo->Info = *siginfo;
121826: 8d 78 08 lea 0x8(%eax),%edi
121829: 8d 75 dc lea -0x24(%ebp),%esi
12182c: b9 03 00 00 00 mov $0x3,%ecx
121831: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
121833: 52 push %edx
121834: 52 push %edx
121835: 50 push %eax
121836: 81 c3 b0 ab 12 00 add $0x12abb0,%ebx
12183c: 53 push %ebx
12183d: e8 b6 d8 fe ff call 10f0f8 <_Chain_Append>
121842: 83 c4 10 add $0x10,%esp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
121845: e8 4c ee fe ff call 110696 <_Thread_Enable_dispatch>
return 0;
12184a: 31 c0 xor %eax,%eax
}
12184c: 8d 65 f4 lea -0xc(%ebp),%esp
12184f: 5b pop %ebx
121850: 5e pop %esi
121851: 5f pop %edi
121852: c9 leave
121853: c3 ret
0011c734 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
11c734: 55 push %ebp
11c735: 89 e5 mov %esp,%ebp
11c737: 53 push %ebx
11c738: 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()))
11c73b: 83 3d 64 44 12 00 03 cmpl $0x3,0x124464
11c742: 75 4f jne 11c793 <libc_wrapup+0x5f> <== NEVER TAKEN
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
11c744: 8b 1d e0 f0 11 00 mov 0x11f0e0,%ebx
11c74a: 39 1d 20 21 12 00 cmp %ebx,0x122120
11c750: 74 12 je 11c764 <libc_wrapup+0x30>
_wrapup_reent(_global_impure_ptr);
11c752: 83 ec 0c sub $0xc,%esp
11c755: 53 push %ebx
11c756: e8 b5 05 00 00 call 11cd10 <_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;
11c75b: 89 1d 20 21 12 00 mov %ebx,0x122120
11c761: 83 c4 10 add $0x10,%esp
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
11c764: 83 ec 0c sub $0xc,%esp
11c767: a1 20 21 12 00 mov 0x122120,%eax
11c76c: ff 70 04 pushl 0x4(%eax)
11c76f: e8 90 4a ff ff call 111204 <fclose>
fclose (stdout);
11c774: 5a pop %edx
11c775: a1 20 21 12 00 mov 0x122120,%eax
11c77a: ff 70 08 pushl 0x8(%eax)
11c77d: e8 82 4a ff ff call 111204 <fclose>
fclose (stderr);
11c782: 58 pop %eax
11c783: a1 20 21 12 00 mov 0x122120,%eax
11c788: ff 70 0c pushl 0xc(%eax)
11c78b: e8 74 4a ff ff call 111204 <fclose>
11c790: 83 c4 10 add $0x10,%esp
}
11c793: 8b 5d fc mov -0x4(%ebp),%ebx
11c796: c9 leave
11c797: c3 ret
0011c640 <lseek>:
off_t lseek(
int fd,
off_t offset,
int whence
)
{
11c640: 55 push %ebp
11c641: 89 e5 mov %esp,%ebp
11c643: 57 push %edi
11c644: 56 push %esi
11c645: 53 push %ebx
11c646: 83 ec 1c sub $0x1c,%esp
11c649: 8b 5d 08 mov 0x8(%ebp),%ebx
11c64c: 8b 45 0c mov 0xc(%ebp),%eax
11c64f: 8b 55 10 mov 0x10(%ebp),%edx
11c652: 8b 4d 14 mov 0x14(%ebp),%ecx
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
11c655: 3b 1d 44 01 12 00 cmp 0x120144,%ebx
11c65b: 73 0f jae 11c66c <lseek+0x2c>
iop = rtems_libio_iop( fd );
11c65d: 6b db 38 imul $0x38,%ebx,%ebx
11c660: 03 1d 98 41 12 00 add 0x124198,%ebx
rtems_libio_check_is_open(iop);
11c666: f6 43 15 01 testb $0x1,0x15(%ebx)
11c66a: 75 0d jne 11c679 <lseek+0x39>
11c66c: e8 3b 4a ff ff call 1110ac <__errno>
11c671: c7 00 09 00 00 00 movl $0x9,(%eax)
11c677: eb 4b jmp 11c6c4 <lseek+0x84>
/*
* Now process the lseek().
*/
old_offset = iop->offset;
11c679: 8b 73 0c mov 0xc(%ebx),%esi
11c67c: 8b 7b 10 mov 0x10(%ebx),%edi
11c67f: 89 75 e0 mov %esi,-0x20(%ebp)
11c682: 89 7d e4 mov %edi,-0x1c(%ebp)
switch ( whence ) {
11c685: 83 f9 01 cmp $0x1,%ecx
11c688: 74 11 je 11c69b <lseek+0x5b>
11c68a: 83 f9 02 cmp $0x2,%ecx
11c68d: 74 18 je 11c6a7 <lseek+0x67>
11c68f: 85 c9 test %ecx,%ecx
11c691: 75 26 jne 11c6b9 <lseek+0x79>
case SEEK_SET:
iop->offset = offset;
11c693: 89 43 0c mov %eax,0xc(%ebx)
11c696: 89 53 10 mov %edx,0x10(%ebx)
break;
11c699: eb 30 jmp 11c6cb <lseek+0x8b>
case SEEK_CUR:
iop->offset += offset;
11c69b: 8b 75 e0 mov -0x20(%ebp),%esi
11c69e: 8b 7d e4 mov -0x1c(%ebp),%edi
11c6a1: 01 c6 add %eax,%esi
11c6a3: 11 d7 adc %edx,%edi
11c6a5: eb 0a jmp 11c6b1 <lseek+0x71>
break;
case SEEK_END:
iop->offset = iop->size + offset;
11c6a7: 89 c6 mov %eax,%esi
11c6a9: 89 d7 mov %edx,%edi
11c6ab: 03 73 04 add 0x4(%ebx),%esi
11c6ae: 13 7b 08 adc 0x8(%ebx),%edi
11c6b1: 89 73 0c mov %esi,0xc(%ebx)
11c6b4: 89 7b 10 mov %edi,0x10(%ebx)
break;
11c6b7: eb 12 jmp 11c6cb <lseek+0x8b>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
11c6b9: e8 ee 49 ff ff call 1110ac <__errno>
11c6be: c7 00 16 00 00 00 movl $0x16,(%eax)
11c6c4: 83 c8 ff or $0xffffffff,%eax
11c6c7: 89 c2 mov %eax,%edx
11c6c9: eb 23 jmp 11c6ee <lseek+0xae>
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
11c6cb: 8b 73 20 mov 0x20(%ebx),%esi
11c6ce: 51 push %ecx
11c6cf: 52 push %edx
11c6d0: 50 push %eax
11c6d1: 53 push %ebx
11c6d2: ff 56 14 call *0x14(%esi)
if ( status == (off_t) -1 )
11c6d5: 83 c4 10 add $0x10,%esp
11c6d8: 83 fa ff cmp $0xffffffff,%edx
11c6db: 75 11 jne 11c6ee <lseek+0xae>
11c6dd: 83 f8 ff cmp $0xffffffff,%eax
11c6e0: 75 0c jne 11c6ee <lseek+0xae> <== NEVER TAKEN
iop->offset = old_offset;
11c6e2: 8b 75 e0 mov -0x20(%ebp),%esi
11c6e5: 8b 7d e4 mov -0x1c(%ebp),%edi
11c6e8: 89 73 0c mov %esi,0xc(%ebx)
11c6eb: 89 7b 10 mov %edi,0x10(%ebx)
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
11c6ee: 8d 65 f4 lea -0xc(%ebp),%esp
11c6f1: 5b pop %ebx
11c6f2: 5e pop %esi
11c6f3: 5f pop %edi
11c6f4: c9 leave
11c6f5: c3 ret
001075e4 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
1075e4: 55 push %ebp
1075e5: 89 e5 mov %esp,%ebp
1075e7: 56 push %esi
1075e8: 53 push %ebx
1075e9: 8b 75 08 mov 0x8(%ebp),%esi
void *return_this;
MSBUMP(malloc_calls, 1);
1075ec: ff 05 b4 41 12 00 incl 0x1241b4
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
1075f2: e8 07 ff ff ff call 1074fe <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
return (void *) 0;
1075f7: 31 db xor %ebx,%ebx
malloc_deferred_frees_process();
/*
* Validate the parameters
*/
if ( !size )
1075f9: 85 f6 test %esi,%esi
1075fb: 74 78 je 107675 <malloc+0x91>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
1075fd: 83 3d 64 44 12 00 03 cmpl $0x3,0x124464
107604: 75 09 jne 10760f <malloc+0x2b>
!malloc_is_system_state_OK() )
107606: e8 b5 fe ff ff call 1074c0 <malloc_is_system_state_OK>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10760b: 84 c0 test %al,%al
10760d: 74 66 je 107675 <malloc+0x91> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
10760f: 6a 00 push $0x0
107611: 6a 00 push $0x0
107613: 56 push %esi
107614: ff 35 50 01 12 00 pushl 0x120150
10761a: e8 59 43 00 00 call 10b978 <_Protected_heap_Allocate_aligned_with_boundary>
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
10761f: 83 c4 10 add $0x10,%esp
107622: 89 c3 mov %eax,%ebx
107624: 85 c0 test %eax,%eax
107626: 75 28 jne 107650 <malloc+0x6c>
if (rtems_malloc_sbrk_helpers)
107628: a1 14 26 12 00 mov 0x122614,%eax
10762d: 85 c0 test %eax,%eax
10762f: 74 10 je 107641 <malloc+0x5d>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
107631: 83 ec 0c sub $0xc,%esp
107634: 56 push %esi
107635: ff 50 04 call *0x4(%eax)
107638: 89 c3 mov %eax,%ebx
if ( !return_this ) {
10763a: 83 c4 10 add $0x10,%esp
10763d: 85 c0 test %eax,%eax
10763f: 75 0f jne 107650 <malloc+0x6c>
errno = ENOMEM;
107641: e8 66 9a 00 00 call 1110ac <__errno>
107646: c7 00 0c 00 00 00 movl $0xc,(%eax)
return (void *) 0;
10764c: 31 db xor %ebx,%ebx
10764e: eb 25 jmp 107675 <malloc+0x91>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
107650: a1 18 26 12 00 mov 0x122618,%eax
107655: 85 c0 test %eax,%eax
107657: 74 09 je 107662 <malloc+0x7e>
(*rtems_malloc_dirty_helper)( return_this, size );
107659: 52 push %edx
10765a: 52 push %edx
10765b: 56 push %esi
10765c: 53 push %ebx
10765d: ff d0 call *%eax
10765f: 83 c4 10 add $0x10,%esp
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
107662: a1 10 26 12 00 mov 0x122610,%eax
107667: 85 c0 test %eax,%eax
107669: 74 0a je 107675 <malloc+0x91>
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
10766b: 83 ec 0c sub $0xc,%esp
10766e: 53 push %ebx
10766f: ff 50 04 call *0x4(%eax)
107672: 83 c4 10 add $0x10,%esp
return return_this;
}
107675: 89 d8 mov %ebx,%eax
107677: 8d 65 f8 lea -0x8(%ebp),%esp
10767a: 5b pop %ebx
10767b: 5e pop %esi
10767c: c9 leave
10767d: c3 ret
0010794c <malloc_sbrk_extend_and_allocate>:
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
10794c: 55 push %ebp
10794d: 89 e5 mov %esp,%ebp
10794f: 57 push %edi
107950: 56 push %esi
107951: 53 push %ebx
107952: 83 ec 0c sub $0xc,%esp
107955: 8b 7d 08 mov 0x8(%ebp),%edi
* Round to the "requested sbrk amount" so hopefully we won't have
* to grow again for a while. This effectively does sbrk() calls
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
107958: 8b 0d 94 53 12 00 mov 0x125394,%ecx
if ( sbrk_amount == 0 )
return (void *) 0;
10795e: 31 f6 xor %esi,%esi
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
107960: 85 c9 test %ecx,%ecx
107962: 74 67 je 1079cb <malloc_sbrk_extend_and_allocate+0x7f><== NEVER TAKEN
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
107964: 8d 1c 0f lea (%edi,%ecx,1),%ebx
107967: 89 d8 mov %ebx,%eax
107969: 31 d2 xor %edx,%edx
10796b: f7 f1 div %ecx
10796d: 89 c3 mov %eax,%ebx
10796f: 0f af d9 imul %ecx,%ebx
starting_address = (void *) sbrk(the_size);
107972: 83 ec 0c sub $0xc,%esp
107975: 53 push %ebx
107976: e8 d8 8a ff ff call 100453 <sbrk>
if ( starting_address == (void*) -1 )
10797b: 83 c4 10 add $0x10,%esp
10797e: 83 f8 ff cmp $0xffffffff,%eax
107981: 74 48 je 1079cb <malloc_sbrk_extend_and_allocate+0x7f>
return (void *) 0;
if ( !_Protected_heap_Extend(
107983: 52 push %edx
107984: 53 push %ebx
107985: 50 push %eax
107986: ff 35 d0 11 12 00 pushl 0x1211d0
10798c: e8 7f 43 00 00 call 10bd10 <_Protected_heap_Extend>
107991: 83 c4 10 add $0x10,%esp
107994: 84 c0 test %al,%al
107996: 75 18 jne 1079b0 <malloc_sbrk_extend_and_allocate+0x64>
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
107998: 83 ec 0c sub $0xc,%esp
10799b: f7 db neg %ebx
10799d: 53 push %ebx
10799e: e8 b0 8a ff ff call 100453 <sbrk>
errno = ENOMEM;
1079a3: e8 dc 9c 00 00 call 111684 <__errno>
1079a8: c7 00 0c 00 00 00 movl $0xc,(%eax)
1079ae: eb 18 jmp 1079c8 <malloc_sbrk_extend_and_allocate+0x7c>
return (void *) 0;
}
MSBUMP(space_available, the_size);
1079b0: 01 1d 68 53 12 00 add %ebx,0x125368
1079b6: 6a 00 push $0x0
1079b8: 6a 00 push $0x0
1079ba: 57 push %edi
1079bb: ff 35 d0 11 12 00 pushl 0x1211d0
1079c1: e8 12 43 00 00 call 10bcd8 <_Protected_heap_Allocate_aligned_with_boundary>
1079c6: 89 c6 mov %eax,%esi
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
1079c8: 83 c4 10 add $0x10,%esp
}
1079cb: 89 f0 mov %esi,%eax
1079cd: 8d 65 f4 lea -0xc(%ebp),%esp
1079d0: 5b pop %ebx
1079d1: 5e pop %esi
1079d2: 5f pop %edi
1079d3: c9 leave
1079d4: c3 ret
0011039b <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
11039b: 55 push %ebp
11039c: 89 e5 mov %esp,%ebp
11039e: 53 push %ebx
11039f: 83 ec 14 sub $0x14,%esp
1103a2: 8b 4d 08 mov 0x8(%ebp),%ecx
1103a5: 8b 45 0c mov 0xc(%ebp),%eax
1103a8: 8b 55 10 mov 0x10(%ebp),%edx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
1103ab: 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 )
1103ae: 3b 53 54 cmp 0x54(%ebx),%edx
1103b1: 7c 15 jl 1103c8 <memfile_ftruncate+0x2d><== NEVER TAKEN
1103b3: 7f 05 jg 1103ba <memfile_ftruncate+0x1f><== NEVER TAKEN
1103b5: 3b 43 50 cmp 0x50(%ebx),%eax
1103b8: 76 0e jbe 1103c8 <memfile_ftruncate+0x2d>
return IMFS_memfile_extend( the_jnode, length );
1103ba: 51 push %ecx
1103bb: 52 push %edx
1103bc: 50 push %eax
1103bd: 53 push %ebx
1103be: e8 cb fc ff ff call 11008e <IMFS_memfile_extend>
1103c3: 83 c4 10 add $0x10,%esp
1103c6: eb 24 jmp 1103ec <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;
1103c8: 89 43 50 mov %eax,0x50(%ebx)
1103cb: 89 53 54 mov %edx,0x54(%ebx)
iop->size = the_jnode->info.file.size;
1103ce: 89 41 04 mov %eax,0x4(%ecx)
1103d1: 89 51 08 mov %edx,0x8(%ecx)
IMFS_update_atime( the_jnode );
1103d4: 50 push %eax
1103d5: 50 push %eax
1103d6: 6a 00 push $0x0
1103d8: 8d 45 f0 lea -0x10(%ebp),%eax
1103db: 50 push %eax
1103dc: e8 df 6f ff ff call 1073c0 <gettimeofday>
1103e1: 8b 45 f0 mov -0x10(%ebp),%eax
1103e4: 89 43 40 mov %eax,0x40(%ebx)
return 0;
1103e7: 83 c4 10 add $0x10,%esp
1103ea: 31 c0 xor %eax,%eax
}
1103ec: 8b 5d fc mov -0x4(%ebp),%ebx
1103ef: c9 leave
1103f0: c3 ret
001103f1 <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
1103f1: 55 push %ebp
1103f2: 89 e5 mov %esp,%ebp
1103f4: 56 push %esi
1103f5: 53 push %ebx
1103f6: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
1103f9: 8b 73 18 mov 0x18(%ebx),%esi
if (the_jnode->type == IMFS_LINEAR_FILE) {
1103fc: 83 7e 4c 06 cmpl $0x6,0x4c(%esi)
110400: 75 1a jne 11041c <memfile_lseek+0x2b>
if (iop->offset > the_jnode->info.linearfile.size)
110402: 8b 56 50 mov 0x50(%esi),%edx
110405: 8b 46 54 mov 0x54(%esi),%eax
110408: 39 43 10 cmp %eax,0x10(%ebx)
11040b: 7c 41 jl 11044e <memfile_lseek+0x5d> <== NEVER TAKEN
11040d: 7f 05 jg 110414 <memfile_lseek+0x23> <== NEVER TAKEN
11040f: 39 53 0c cmp %edx,0xc(%ebx)
110412: 76 3a jbe 11044e <memfile_lseek+0x5d> <== ALWAYS TAKEN
iop->offset = the_jnode->info.linearfile.size;
110414: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED
110417: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED
11041a: eb 32 jmp 11044e <memfile_lseek+0x5d> <== NOT EXECUTED
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
11041c: 50 push %eax
11041d: ff 73 10 pushl 0x10(%ebx)
110420: ff 73 0c pushl 0xc(%ebx)
110423: 56 push %esi
110424: e8 65 fc ff ff call 11008e <IMFS_memfile_extend>
110429: 83 c4 10 add $0x10,%esp
11042c: 85 c0 test %eax,%eax
11042e: 74 12 je 110442 <memfile_lseek+0x51>
rtems_set_errno_and_return_minus_one( ENOSPC );
110430: e8 77 0c 00 00 call 1110ac <__errno>
110435: c7 00 1c 00 00 00 movl $0x1c,(%eax)
11043b: 83 c8 ff or $0xffffffff,%eax
11043e: 89 c2 mov %eax,%edx
110440: eb 12 jmp 110454 <memfile_lseek+0x63>
iop->size = the_jnode->info.file.size;
110442: 8b 46 50 mov 0x50(%esi),%eax
110445: 8b 56 54 mov 0x54(%esi),%edx
110448: 89 43 04 mov %eax,0x4(%ebx)
11044b: 89 53 08 mov %edx,0x8(%ebx)
}
return iop->offset;
11044e: 8b 43 0c mov 0xc(%ebx),%eax
110451: 8b 53 10 mov 0x10(%ebx),%edx
}
110454: 8d 65 f8 lea -0x8(%ebp),%esp
110457: 5b pop %ebx
110458: 5e pop %esi
110459: c9 leave
11045a: c3 ret
0011030c <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
11030c: 55 push %ebp
11030d: 89 e5 mov %esp,%ebp
11030f: 56 push %esi
110310: 53 push %ebx
110311: 8b 75 08 mov 0x8(%ebp),%esi
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
110314: 8b 5e 18 mov 0x18(%esi),%ebx
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
110317: f7 46 14 04 02 00 00 testl $0x204,0x14(%esi)
11031e: 74 54 je 110374 <memfile_open+0x68>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
110320: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx)
110324: 75 4e jne 110374 <memfile_open+0x68> <== ALWAYS TAKEN
uint32_t count = the_jnode->info.linearfile.size;
110326: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
110329: 8b 53 58 mov 0x58(%ebx),%edx <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
11032c: c7 43 4c 05 00 00 00 movl $0x5,0x4c(%ebx) <== NOT EXECUTED
the_jnode->info.file.size = 0;
110333: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED
11033a: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
110341: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
110348: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
11034f: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED
if ((count != 0)
110356: 85 c0 test %eax,%eax <== NOT EXECUTED
110358: 74 1a je 110374 <memfile_open+0x68> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
11035a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
11035d: 50 push %eax <== NOT EXECUTED
11035e: 52 push %edx <== NOT EXECUTED
11035f: 6a 00 push $0x0 <== NOT EXECUTED
110361: 6a 00 push $0x0 <== NOT EXECUTED
110363: 53 push %ebx <== NOT EXECUTED
110364: e8 17 fe ff ff call 110180 <IMFS_memfile_write> <== NOT EXECUTED
110369: 89 c2 mov %eax,%edx <== NOT EXECUTED
11036b: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
return -1;
11036e: 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))
110371: 42 inc %edx <== NOT EXECUTED
110372: 74 20 je 110394 <memfile_open+0x88> <== NOT EXECUTED
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
110374: f6 46 15 02 testb $0x2,0x15(%esi)
110378: 74 0c je 110386 <memfile_open+0x7a>
iop->offset = the_jnode->info.file.size;
11037a: 8b 43 50 mov 0x50(%ebx),%eax
11037d: 8b 53 54 mov 0x54(%ebx),%edx
110380: 89 46 0c mov %eax,0xc(%esi)
110383: 89 56 10 mov %edx,0x10(%esi)
iop->size = the_jnode->info.file.size;
110386: 8b 43 50 mov 0x50(%ebx),%eax
110389: 8b 53 54 mov 0x54(%ebx),%edx
11038c: 89 46 04 mov %eax,0x4(%esi)
11038f: 89 56 08 mov %edx,0x8(%esi)
return 0;
110392: 31 c0 xor %eax,%eax
}
110394: 8d 65 f8 lea -0x8(%ebp),%esp
110397: 5b pop %ebx
110398: 5e pop %esi
110399: c9 leave
11039a: c3 ret
001077b5 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
1077b5: 55 push %ebp
1077b6: 89 e5 mov %esp,%ebp
1077b8: 57 push %edi
1077b9: 56 push %esi
1077ba: 53 push %ebx
1077bb: 83 ec 4c sub $0x4c,%esp
1077be: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
1077c1: 83 7d 14 01 cmpl $0x1,0x14(%ebp)
1077c5: 77 13 ja 1077da <mount+0x25>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
1077c7: 83 ec 0c sub $0xc,%esp
1077ca: 56 push %esi
1077cb: e8 57 6b 00 00 call 10e327 <rtems_filesystem_get_mount_handler>
1077d0: 89 45 b0 mov %eax,-0x50(%ebp)
if ( !mount_h )
1077d3: 83 c4 10 add $0x10,%esp
1077d6: 85 c0 test %eax,%eax
1077d8: 75 10 jne 1077ea <mount+0x35>
rtems_set_errno_and_return_minus_one( EINVAL );
1077da: e8 cd 98 00 00 call 1110ac <__errno>
1077df: c7 00 16 00 00 00 movl $0x16,(%eax)
1077e5: e9 ca 00 00 00 jmp 1078b4 <mount+0xff>
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
bool has_target = target != NULL;
1077ea: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
1077ee: 0f 95 45 b7 setne -0x49(%ebp)
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
1077f2: 8b 45 0c mov 0xc(%ebp),%eax
1077f5: 89 45 b8 mov %eax,-0x48(%ebp)
1077f8: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
1077fc: 75 07 jne 107805 <mount+0x50>
1077fe: c7 45 b8 d4 e5 11 00 movl $0x11e5d4,-0x48(%ebp)
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
107805: 83 ca ff or $0xffffffff,%edx
107808: 31 c0 xor %eax,%eax
10780a: 89 d1 mov %edx,%ecx
10780c: 89 f7 mov %esi,%edi
10780e: f2 ae repnz scas %es:(%edi),%al
107810: f7 d1 not %ecx
107812: 89 4d bc mov %ecx,-0x44(%ebp)
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
107815: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
10781c: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
107820: 74 0c je 10782e <mount+0x79>
107822: 89 d1 mov %edx,%ecx
107824: 8b 7d 08 mov 0x8(%ebp),%edi
107827: f2 ae repnz scas %es:(%edi),%al
107829: f7 d1 not %ecx
10782b: 89 4d c4 mov %ecx,-0x3c(%ebp)
size_t target_size = strlen( target ) + 1;
10782e: 31 c0 xor %eax,%eax
107830: 83 c9 ff or $0xffffffff,%ecx
107833: 8b 7d b8 mov -0x48(%ebp),%edi
107836: f2 ae repnz scas %es:(%edi),%al
107838: f7 d1 not %ecx
10783a: 89 4d c0 mov %ecx,-0x40(%ebp)
10783d: 49 dec %ecx
10783e: 89 4d ac mov %ecx,-0x54(%ebp)
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
107841: 50 push %eax
107842: 50 push %eax
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
107843: 8b 55 c4 mov -0x3c(%ebp),%edx
107846: 8b 7d bc mov -0x44(%ebp),%edi
107849: 8d 44 3a 74 lea 0x74(%edx,%edi,1),%eax
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
10784d: 03 45 c0 add -0x40(%ebp),%eax
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
107850: 50 push %eax
107851: 6a 01 push $0x1
107853: e8 84 f9 ff ff call 1071dc <calloc>
107858: 89 c3 mov %eax,%ebx
if ( mt_entry != NULL ) {
10785a: 83 c4 10 add $0x10,%esp
10785d: 85 c0 test %eax,%eax
10785f: 74 48 je 1078a9 <mount+0xf4> <== NEVER TAKEN
char *str = (char *) mt_entry + sizeof( *mt_entry );
107861: 8d 40 74 lea 0x74(%eax),%eax
memcpy( str, filesystemtype, filesystemtype_size );
107864: 89 c7 mov %eax,%edi
107866: 8b 4d bc mov -0x44(%ebp),%ecx
107869: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10786b: 89 fa mov %edi,%edx
mt_entry->type = str;
10786d: 89 43 6c mov %eax,0x6c(%ebx)
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
107870: 8b 75 08 mov 0x8(%ebp),%esi
107873: 8b 4d c4 mov -0x3c(%ebp),%ecx
107876: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
107878: 89 f8 mov %edi,%eax
mt_entry->dev = str;
10787a: 89 53 70 mov %edx,0x70(%ebx)
str += source_size;
memcpy( str, target, target_size );
10787d: 8b 75 b8 mov -0x48(%ebp),%esi
107880: 8b 4d c0 mov -0x40(%ebp),%ecx
107883: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
mt_entry->target = str;
107885: 89 43 68 mov %eax,0x68(%ebx)
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
107888: 89 5b 2c mov %ebx,0x2c(%ebx)
mt_entry->options = options;
10788b: 8b 45 14 mov 0x14(%ebp),%eax
10788e: 89 43 30 mov %eax,0x30(%ebx)
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
107891: 8d 7b 38 lea 0x38(%ebx),%edi
107894: be 14 e6 11 00 mov $0x11e614,%esi
107899: b1 0c mov $0xc,%cl
10789b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
10789d: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
1078a1: 0f 84 a3 00 00 00 je 10794a <mount+0x195>
1078a7: eb 13 jmp 1078bc <mount+0x107>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
1078a9: e8 fe 97 00 00 call 1110ac <__errno> <== NOT EXECUTED
1078ae: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
1078b4: 83 c8 ff or $0xffffffff,%eax
1078b7: e9 26 01 00 00 jmp 1079e2 <mount+0x22d>
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
1078bc: 83 ec 0c sub $0xc,%esp
1078bf: 6a 01 push $0x1
1078c1: 8d 75 d4 lea -0x2c(%ebp),%esi
1078c4: 56 push %esi
1078c5: 6a 07 push $0x7
1078c7: ff 75 ac pushl -0x54(%ebp)
1078ca: ff 75 0c pushl 0xc(%ebp)
1078cd: e8 a4 f9 ff ff call 107276 <rtems_filesystem_evaluate_path>
1078d2: 83 c4 20 add $0x20,%esp
1078d5: 40 inc %eax
1078d6: 0f 84 df 00 00 00 je 1079bb <mount+0x206> <== NEVER TAKEN
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
1078dc: 83 ec 0c sub $0xc,%esp
1078df: 56 push %esi
1078e0: 8b 45 e0 mov -0x20(%ebp),%eax
1078e3: ff 50 10 call *0x10(%eax)
1078e6: 83 c4 10 add $0x10,%esp
1078e9: 48 dec %eax
1078ea: 74 10 je 1078fc <mount+0x147>
errno = ENOTDIR;
1078ec: e8 bb 97 00 00 call 1110ac <__errno>
1078f1: c7 00 14 00 00 00 movl $0x14,(%eax)
goto cleanup_and_bail;
1078f7: e9 c1 00 00 00 jmp 1079bd <mount+0x208>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
1078fc: 57 push %edi
1078fd: 57 push %edi
1078fe: ff 75 d4 pushl -0x2c(%ebp)
107901: 68 2c 77 10 00 push $0x10772c
107906: e8 62 fe ff ff call 10776d <rtems_filesystem_mount_iterate>
10790b: 83 c4 10 add $0x10,%esp
10790e: 84 c0 test %al,%al
107910: 74 10 je 107922 <mount+0x16d>
errno = EBUSY;
107912: e8 95 97 00 00 call 1110ac <__errno>
107917: c7 00 10 00 00 00 movl $0x10,(%eax)
goto cleanup_and_bail;
10791d: e9 9b 00 00 00 jmp 1079bd <mount+0x208>
* may have been allocated in loc should not be sent to freenode
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
107922: 8b 45 d4 mov -0x2c(%ebp),%eax
107925: 89 43 08 mov %eax,0x8(%ebx)
mt_entry->mt_point_node.handlers = loc.handlers;
107928: 8b 45 dc mov -0x24(%ebp),%eax
10792b: 89 43 10 mov %eax,0x10(%ebx)
mt_entry->mt_point_node.ops = loc.ops;
10792e: 8b 45 e0 mov -0x20(%ebp),%eax
107931: 89 43 14 mov %eax,0x14(%ebx)
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
107934: 8b 55 e4 mov -0x1c(%ebp),%edx
107937: 89 53 18 mov %edx,0x18(%ebx)
/*
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( loc.ops->mount_h( mt_entry ) ) {
10793a: 83 ec 0c sub $0xc,%esp
10793d: 53 push %ebx
10793e: ff 50 20 call *0x20(%eax)
107941: 83 c4 10 add $0x10,%esp
107944: 85 c0 test %eax,%eax
107946: 74 1d je 107965 <mount+0x1b0> <== ALWAYS TAKEN
107948: eb 73 jmp 1079bd <mount+0x208> <== NOT EXECUTED
)
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
10794a: 31 f6 xor %esi,%esi
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
10794c: 81 3d 34 1f 12 00 38 cmpl $0x121f38,0x121f34
107953: 1f 12 00
107956: 74 0d je 107965 <mount+0x1b0> <== ALWAYS TAKEN
errno = EINVAL;
107958: e8 4f 97 00 00 call 1110ac <__errno> <== NOT EXECUTED
10795d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
goto cleanup_and_bail;
107963: eb 58 jmp 1079bd <mount+0x208> <== NOT EXECUTED
* mt_point_node.node_access will be left to null to indicate that this
* is the root of the entire file system.
*/
}
if ( (*mount_h)( mt_entry, data ) ) {
107965: 51 push %ecx
107966: 51 push %ecx
107967: ff 75 18 pushl 0x18(%ebp)
10796a: 53 push %ebx
10796b: ff 55 b0 call *-0x50(%ebp)
10796e: 83 c4 10 add $0x10,%esp
107971: 85 c0 test %eax,%eax
107973: 74 0f je 107984 <mount+0x1cf>
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
107975: 83 ec 0c sub $0xc,%esp
107978: 53 push %ebx
107979: 8b 45 e0 mov -0x20(%ebp),%eax
10797c: ff 50 28 call *0x28(%eax)
goto cleanup_and_bail;
10797f: 83 c4 10 add $0x10,%esp
107982: eb 39 jmp 1079bd <mount+0x208>
}
/*
* Add the mount table entry to the mount table chain
*/
rtems_libio_lock();
107984: e8 b4 fd ff ff call 10773d <rtems_libio_lock>
107989: 52 push %edx
10798a: 52 push %edx
10798b: 53 push %ebx
10798c: 68 34 1f 12 00 push $0x121f34
107991: e8 3a 30 00 00 call 10a9d0 <_Chain_Append>
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
107996: e8 bc fd ff ff call 107757 <rtems_libio_unlock>
if ( !has_target )
10799b: 83 c4 10 add $0x10,%esp
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
10799e: 31 c0 xor %eax,%eax
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
1079a0: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
1079a4: 75 3c jne 1079e2 <mount+0x22d>
rtems_filesystem_root = mt_entry->mt_fs_root;
1079a6: 8b 3d 50 20 12 00 mov 0x122050,%edi
1079ac: 83 c7 18 add $0x18,%edi
1079af: 8d 73 1c lea 0x1c(%ebx),%esi
1079b2: b9 05 00 00 00 mov $0x5,%ecx
1079b7: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
1079b9: eb 27 jmp 1079e2 <mount+0x22d>
)
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
1079bb: 31 f6 xor %esi,%esi
return 0;
cleanup_and_bail:
free( mt_entry );
1079bd: 83 ec 0c sub $0xc,%esp
1079c0: 53 push %ebx
1079c1: e8 82 f9 ff ff call 107348 <free>
if ( loc_to_free )
1079c6: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( loc_to_free );
return -1;
1079c9: 83 c8 ff or $0xffffffff,%eax
cleanup_and_bail:
free( mt_entry );
if ( loc_to_free )
1079cc: 85 f6 test %esi,%esi
1079ce: 74 12 je 1079e2 <mount+0x22d> <== NEVER TAKEN
rtems_filesystem_freenode( loc_to_free );
1079d0: 83 ec 0c sub $0xc,%esp
1079d3: 56 push %esi
1079d4: 89 45 a8 mov %eax,-0x58(%ebp)
1079d7: e8 58 f9 ff ff call 107334 <rtems_filesystem_freenode>
1079dc: 83 c4 10 add $0x10,%esp
1079df: 8b 45 a8 mov -0x58(%ebp),%eax
return -1;
}
1079e2: 8d 65 f4 lea -0xc(%ebp),%esp
1079e5: 5b pop %ebx
1079e6: 5e pop %esi
1079e7: 5f pop %edi
1079e8: c9 leave
1079e9: c3 ret
00107d3c <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
107d3c: 55 push %ebp
107d3d: 89 e5 mov %esp,%ebp
107d3f: 57 push %edi
107d40: 56 push %esi
107d41: 53 push %ebx
107d42: 83 ec 1c sub $0x1c,%esp
107d45: 8b 4d 08 mov 0x8(%ebp),%ecx
107d48: 8b 5d 0c mov 0xc(%ebp),%ebx
107d4b: 8b 75 10 mov 0x10(%ebp),%esi
107d4e: 8b 7d 14 mov 0x14(%ebp),%edi
107d51: 8b 55 18 mov 0x18(%ebp),%edx
int rv = -1;
if (target != NULL) {
107d54: 85 db test %ebx,%ebx
107d56: 74 3b je 107d93 <mount_and_make_target_path+0x57>
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
107d58: 50 push %eax
107d59: 50 push %eax
107d5a: 68 ff 01 00 00 push $0x1ff
107d5f: 53 push %ebx
107d60: 89 55 e0 mov %edx,-0x20(%ebp)
107d63: 89 4d e4 mov %ecx,-0x1c(%ebp)
107d66: e8 bd 08 00 00 call 108628 <rtems_mkdir>
if (rv == 0) {
107d6b: 83 c4 10 add $0x10,%esp
107d6e: 85 c0 test %eax,%eax
107d70: 8b 55 e0 mov -0x20(%ebp),%edx
107d73: 8b 4d e4 mov -0x1c(%ebp),%ecx
107d76: 75 29 jne 107da1 <mount_and_make_target_path+0x65><== NEVER TAKEN
rv = mount(
107d78: 89 55 18 mov %edx,0x18(%ebp)
107d7b: 89 7d 14 mov %edi,0x14(%ebp)
107d7e: 89 75 10 mov %esi,0x10(%ebp)
107d81: 89 5d 0c mov %ebx,0xc(%ebp)
107d84: 89 4d 08 mov %ecx,0x8(%ebp)
} else {
errno = EINVAL;
}
return rv;
}
107d87: 8d 65 f4 lea -0xc(%ebp),%esp
107d8a: 5b pop %ebx
107d8b: 5e pop %esi
107d8c: 5f pop %edi
107d8d: c9 leave
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
107d8e: e9 a2 00 00 00 jmp 107e35 <mount>
options,
data
);
}
} else {
errno = EINVAL;
107d93: e8 a0 99 00 00 call 111738 <__errno>
107d98: c7 00 16 00 00 00 movl $0x16,(%eax)
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
107d9e: 83 c8 ff or $0xffffffff,%eax
} else {
errno = EINVAL;
}
return rv;
}
107da1: 8d 65 f4 lea -0xc(%ebp),%esp
107da4: 5b pop %ebx
107da5: 5e pop %esi
107da6: 5f pop %edi
107da7: c9 leave
107da8: c3 ret
0010dff0 <mq_getattr>:
int mq_getattr(
mqd_t mqdes,
struct mq_attr *mqstat
)
{
10dff0: 55 push %ebp
10dff1: 89 e5 mov %esp,%ebp
10dff3: 53 push %ebx
10dff4: 83 ec 14 sub $0x14,%esp
10dff7: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_Message_queue_Control *the_mq;
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
CORE_message_queue_Attributes *the_mq_attr;
if ( !mqstat )
10dffa: 85 db test %ebx,%ebx
10dffc: 75 0d jne 10e00b <mq_getattr+0x1b> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10dffe: e8 d1 8d 00 00 call 116dd4 <__errno>
10e003: c7 00 16 00 00 00 movl $0x16,(%eax)
10e009: eb 49 jmp 10e054 <mq_getattr+0x64>
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(
10e00b: 50 push %eax
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
10e00c: 8d 45 f4 lea -0xc(%ebp),%eax
10e00f: 50 push %eax
10e010: ff 75 08 pushl 0x8(%ebp)
10e013: 68 7c d9 12 00 push $0x12d97c
10e018: e8 af 2d 00 00 call 110dcc <_Objects_Get>
switch ( location ) {
10e01d: 83 c4 10 add $0x10,%esp
10e020: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10e024: 75 23 jne 10e049 <mq_getattr+0x59>
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
10e026: 8b 50 10 mov 0x10(%eax),%edx
* Return the old values.
*/
the_mq_attr = &the_mq->Message_queue.Attributes;
mqstat->mq_flags = the_mq_fd->oflag;
10e029: 8b 40 14 mov 0x14(%eax),%eax
10e02c: 89 03 mov %eax,(%ebx)
mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size;
10e02e: 8b 42 68 mov 0x68(%edx),%eax
10e031: 89 43 08 mov %eax,0x8(%ebx)
mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages;
10e034: 8b 42 60 mov 0x60(%edx),%eax
10e037: 89 43 04 mov %eax,0x4(%ebx)
mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages;
10e03a: 8b 42 64 mov 0x64(%edx),%eax
10e03d: 89 43 0c mov %eax,0xc(%ebx)
_Thread_Enable_dispatch();
10e040: e8 d9 35 00 00 call 11161e <_Thread_Enable_dispatch>
return 0;
10e045: 31 c0 xor %eax,%eax
10e047: eb 0e jmp 10e057 <mq_getattr+0x67>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10e049: e8 86 8d 00 00 call 116dd4 <__errno>
10e04e: c7 00 09 00 00 00 movl $0x9,(%eax)
10e054: 83 c8 ff or $0xffffffff,%eax
}
10e057: 8b 5d fc mov -0x4(%ebp),%ebx
10e05a: c9 leave
10e05b: c3 ret
00107a45 <newlib_create_hook>:
*/
bool newlib_create_hook(
rtems_tcb *current_task __attribute__((unused)),
rtems_tcb *creating_task
)
{
107a45: 55 push %ebp
107a46: 89 e5 mov %esp,%ebp
107a48: 57 push %edi
107a49: 56 push %esi
107a4a: 53 push %ebx
107a4b: 83 ec 1c sub $0x1c,%esp
struct _reent *ptr;
if (_Thread_libc_reent == 0)
107a4e: 83 3d 6c 43 12 00 00 cmpl $0x0,0x12436c
107a55: 75 14 jne 107a6b <newlib_create_hook+0x26>
{
_REENT = _global_impure_ptr;
107a57: a1 e0 f0 11 00 mov 0x11f0e0,%eax
107a5c: a3 20 21 12 00 mov %eax,0x122120
RTEMS_INLINE_ROUTINE void _Thread_Set_libc_reent (
struct _reent **libc_reent
)
{
_Thread_libc_reent = libc_reent;
107a61: c7 05 6c 43 12 00 20 movl $0x122120,0x12436c
107a68: 21 12 00
ptr = (struct _reent *) calloc(1, sizeof(struct _reent));
#else
/* It is OK to allocate from the workspace because these
* hooks run with thread dispatching disabled.
*/
ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent));
107a6b: 83 ec 0c sub $0xc,%esp
107a6e: 68 24 04 00 00 push $0x424
107a73: e8 5a 54 00 00 call 10ced2 <_Workspace_Allocate>
107a78: 89 c2 mov %eax,%edx
#endif
if (ptr) {
107a7a: 83 c4 10 add $0x10,%esp
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
creating_task->libc_reent = ptr;
return TRUE;
}
return FALSE;
107a7d: 31 c0 xor %eax,%eax
* hooks run with thread dispatching disabled.
*/
ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent));
#endif
if (ptr) {
107a7f: 85 d2 test %edx,%edx
107a81: 0f 84 28 02 00 00 je 107caf <newlib_create_hook+0x26a><== NEVER TAKEN
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
107a87: c7 02 00 00 00 00 movl $0x0,(%edx)
107a8d: 8d b2 ec 02 00 00 lea 0x2ec(%edx),%esi
107a93: 89 72 04 mov %esi,0x4(%edx)
107a96: 8d 8a 54 03 00 00 lea 0x354(%edx),%ecx
107a9c: 89 4a 08 mov %ecx,0x8(%edx)
107a9f: 8d 8a bc 03 00 00 lea 0x3bc(%edx),%ecx
107aa5: 89 4a 0c mov %ecx,0xc(%edx)
107aa8: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
107aaf: 8d 4a 14 lea 0x14(%edx),%ecx
107ab2: bb 19 00 00 00 mov $0x19,%ebx
107ab7: 89 cf mov %ecx,%edi
107ab9: 89 d9 mov %ebx,%ecx
107abb: f3 aa rep stos %al,%es:(%edi)
107abd: 89 cb mov %ecx,%ebx
107abf: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx)
107ac6: c7 42 34 66 e3 11 00 movl $0x11e366,0x34(%edx)
107acd: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx)
107ad4: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx)
107adb: c7 42 40 00 00 00 00 movl $0x0,0x40(%edx)
107ae2: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx)
107ae9: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx)
107af0: c7 42 4c 00 00 00 00 movl $0x0,0x4c(%edx)
107af7: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx)
107afe: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx)
107b05: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx)
107b0c: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx)
107b13: c6 42 60 00 movb $0x0,0x60(%edx)
107b17: 8d 42 7c lea 0x7c(%edx),%eax
107b1a: 89 45 e4 mov %eax,-0x1c(%ebp)
107b1d: b1 09 mov $0x9,%cl
107b1f: 89 c7 mov %eax,%edi
107b21: 89 d8 mov %ebx,%eax
107b23: f3 ab rep stos %eax,%es:(%edi)
107b25: c7 82 a0 00 00 00 00 movl $0x0,0xa0(%edx)
107b2c: 00 00 00
107b2f: c7 82 a4 00 00 00 01 movl $0x1,0xa4(%edx)
107b36: 00 00 00
107b39: c7 82 a8 00 00 00 00 movl $0x0,0xa8(%edx)
107b40: 00 00 00
107b43: 66 c7 82 ac 00 00 00 movw $0x330e,0xac(%edx)
107b4a: 0e 33
107b4c: 66 c7 82 ae 00 00 00 movw $0xabcd,0xae(%edx)
107b53: cd ab
107b55: 66 c7 82 b0 00 00 00 movw $0x1234,0xb0(%edx)
107b5c: 34 12
107b5e: 66 c7 82 b2 00 00 00 movw $0xe66d,0xb2(%edx)
107b65: 6d e6
107b67: 66 c7 82 b4 00 00 00 movw $0xdeec,0xb4(%edx)
107b6e: ec de
107b70: 66 c7 82 b6 00 00 00 movw $0x5,0xb6(%edx)
107b77: 05 00
107b79: 66 c7 82 b8 00 00 00 movw $0xb,0xb8(%edx)
107b80: 0b 00
107b82: c7 82 bc 00 00 00 00 movl $0x0,0xbc(%edx)
107b89: 00 00 00
107b8c: c7 82 c0 00 00 00 00 movl $0x0,0xc0(%edx)
107b93: 00 00 00
107b96: c7 82 c4 00 00 00 00 movl $0x0,0xc4(%edx)
107b9d: 00 00 00
107ba0: c7 82 c8 00 00 00 00 movl $0x0,0xc8(%edx)
107ba7: 00 00 00
107baa: c7 82 cc 00 00 00 00 movl $0x0,0xcc(%edx)
107bb1: 00 00 00
107bb4: c7 82 d0 00 00 00 00 movl $0x0,0xd0(%edx)
107bbb: 00 00 00
107bbe: c7 82 f8 00 00 00 00 movl $0x0,0xf8(%edx)
107bc5: 00 00 00
107bc8: c7 82 fc 00 00 00 00 movl $0x0,0xfc(%edx)
107bcf: 00 00 00
107bd2: c7 82 00 01 00 00 00 movl $0x0,0x100(%edx)
107bd9: 00 00 00
107bdc: c7 82 04 01 00 00 00 movl $0x0,0x104(%edx)
107be3: 00 00 00
107be6: c7 82 08 01 00 00 00 movl $0x0,0x108(%edx)
107bed: 00 00 00
107bf0: c7 82 0c 01 00 00 00 movl $0x0,0x10c(%edx)
107bf7: 00 00 00
107bfa: c7 82 10 01 00 00 00 movl $0x0,0x110(%edx)
107c01: 00 00 00
107c04: c7 82 14 01 00 00 00 movl $0x0,0x114(%edx)
107c0b: 00 00 00
107c0e: c7 82 18 01 00 00 00 movl $0x0,0x118(%edx)
107c15: 00 00 00
107c18: c7 82 1c 01 00 00 00 movl $0x0,0x11c(%edx)
107c1f: 00 00 00
107c22: c6 82 d4 00 00 00 00 movb $0x0,0xd4(%edx)
107c29: c6 82 dc 00 00 00 00 movb $0x0,0xdc(%edx)
107c30: c7 82 f4 00 00 00 00 movl $0x0,0xf4(%edx)
107c37: 00 00 00
107c3a: c7 82 48 01 00 00 00 movl $0x0,0x148(%edx)
107c41: 00 00 00
107c44: c7 82 4c 01 00 00 00 movl $0x0,0x14c(%edx)
107c4b: 00 00 00
107c4e: c7 82 50 01 00 00 00 movl $0x0,0x150(%edx)
107c55: 00 00 00
107c58: c7 82 54 01 00 00 00 movl $0x0,0x154(%edx)
107c5f: 00 00 00
107c62: c7 82 d4 02 00 00 00 movl $0x0,0x2d4(%edx)
107c69: 00 00 00
107c6c: c7 82 d4 01 00 00 00 movl $0x0,0x1d4(%edx)
107c73: 00 00 00
107c76: c7 82 dc 02 00 00 00 movl $0x0,0x2dc(%edx)
107c7d: 00 00 00
107c80: c7 82 e0 02 00 00 00 movl $0x0,0x2e0(%edx)
107c87: 00 00 00
107c8a: c7 82 e4 02 00 00 00 movl $0x0,0x2e4(%edx)
107c91: 00 00 00
107c94: c7 82 e8 02 00 00 00 movl $0x0,0x2e8(%edx)
107c9b: 00 00 00
107c9e: b1 4e mov $0x4e,%cl
107ca0: 89 f7 mov %esi,%edi
107ca2: f3 ab rep stos %eax,%es:(%edi)
creating_task->libc_reent = ptr;
107ca4: 8b 45 0c mov 0xc(%ebp),%eax
107ca7: 89 90 f0 00 00 00 mov %edx,0xf0(%eax)
return TRUE;
107cad: b0 01 mov $0x1,%al
}
return FALSE;
}
107caf: 8d 65 f4 lea -0xc(%ebp),%esp
107cb2: 5b pop %ebx
107cb3: 5e pop %esi
107cb4: 5f pop %edi
107cb5: c9 leave
107cb6: c3 ret
00107cb7 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
107cb7: 55 push %ebp
107cb8: 89 e5 mov %esp,%ebp
107cba: 57 push %edi
107cbb: 56 push %esi
107cbc: 53 push %ebx
107cbd: 83 ec 0c sub $0xc,%esp
107cc0: 8b 7d 08 mov 0x8(%ebp),%edi
107cc3: 8b 75 0c mov 0xc(%ebp),%esi
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
107cc6: 39 f7 cmp %esi,%edi
107cc8: 75 08 jne 107cd2 <newlib_delete_hook+0x1b>
ptr = _REENT;
107cca: 8b 1d 20 21 12 00 mov 0x122120,%ebx
107cd0: eb 06 jmp 107cd8 <newlib_delete_hook+0x21>
} else {
ptr = deleted_task->libc_reent;
107cd2: 8b 9e f0 00 00 00 mov 0xf0(%esi),%ebx
}
if (ptr && ptr != _global_impure_ptr) {
107cd8: 85 db test %ebx,%ebx
107cda: 74 20 je 107cfc <newlib_delete_hook+0x45><== NEVER TAKEN
107cdc: 3b 1d e0 f0 11 00 cmp 0x11f0e0,%ebx
107ce2: 74 18 je 107cfc <newlib_delete_hook+0x45>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
107ce4: 50 push %eax
107ce5: 50 push %eax
107ce6: 68 f4 79 10 00 push $0x1079f4
107ceb: 53 push %ebx
107cec: e8 a3 9b 00 00 call 111894 <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
107cf1: 89 1c 24 mov %ebx,(%esp)
107cf4: e8 f2 51 00 00 call 10ceeb <_Workspace_Free>
107cf9: 83 c4 10 add $0x10,%esp
#endif
}
deleted_task->libc_reent = NULL;
107cfc: c7 86 f0 00 00 00 00 movl $0x0,0xf0(%esi)
107d03: 00 00 00
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
107d06: 39 f7 cmp %esi,%edi
107d08: 75 0a jne 107d14 <newlib_delete_hook+0x5d>
_REENT = 0;
107d0a: c7 05 20 21 12 00 00 movl $0x0,0x122120
107d11: 00 00 00
}
}
107d14: 8d 65 f4 lea -0xc(%ebp),%esp
107d17: 5b pop %ebx
107d18: 5e pop %esi
107d19: 5f pop %edi
107d1a: c9 leave
107d1b: c3 ret
001079f4 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
1079f4: 55 push %ebp
1079f5: 89 e5 mov %esp,%ebp
1079f7: 53 push %ebx
1079f8: 83 ec 10 sub $0x10,%esp
1079fb: 8b 5d 08 mov 0x8(%ebp),%ebx
switch ( fileno(fp) ) {
1079fe: 53 push %ebx
1079ff: e8 7c 9a 00 00 call 111480 <fileno>
107a04: 83 c4 10 add $0x10,%esp
107a07: 83 f8 02 cmp $0x2,%eax
107a0a: 77 26 ja 107a32 <newlib_free_buffers+0x3e><== NEVER TAKEN
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
107a0c: f6 43 0c 80 testb $0x80,0xc(%ebx)
107a10: 74 2c je 107a3e <newlib_free_buffers+0x4a><== ALWAYS TAKEN
free( fp->_bf._base );
107a12: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107a15: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
107a18: e8 2b f9 ff ff call 107348 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
107a1d: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
107a23: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED
107a29: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED
107a30: eb 09 jmp 107a3b <newlib_free_buffers+0x47><== NOT EXECUTED
}
break;
default:
fclose(fp);
107a32: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107a35: 53 push %ebx <== NOT EXECUTED
107a36: e8 c9 97 00 00 call 111204 <fclose> <== NOT EXECUTED
107a3b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return 0;
}
107a3e: 31 c0 xor %eax,%eax
107a40: 8b 5d fc mov -0x4(%ebp),%ebx
107a43: c9 leave
107a44: c3 ret
00107d7c <open>:
int open(
const char *pathname,
int flags,
...
)
{
107d7c: 55 push %ebp
107d7d: 89 e5 mov %esp,%ebp
107d7f: 57 push %edi
107d80: 56 push %esi
107d81: 53 push %ebx
107d82: 83 ec 3c sub $0x3c,%esp
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
107d85: 8b 45 0c mov 0xc(%ebp),%eax
107d88: 40 inc %eax
if ( ( status & _FREAD ) == _FREAD )
107d89: 89 c6 mov %eax,%esi
107d8b: 83 e6 01 and $0x1,%esi
eval_flags |= RTEMS_LIBIO_PERMS_READ;
107d8e: f7 de neg %esi
107d90: 83 e6 04 and $0x4,%esi
if ( ( status & _FWRITE ) == _FWRITE )
107d93: a8 02 test $0x2,%al
107d95: 74 03 je 107d9a <open+0x1e>
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
107d97: 83 ce 02 or $0x2,%esi
va_start(ap, flags);
mode = va_arg( ap, int );
107d9a: 8b 45 10 mov 0x10(%ebp),%eax
107d9d: 89 45 c4 mov %eax,-0x3c(%ebp)
* code does not require changes here since network file
* descriptors are obtained using socket(), not open().
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
107da0: e8 66 63 00 00 call 10e10b <rtems_libio_allocate>
107da5: 89 c3 mov %eax,%ebx
if ( iop == 0 ) {
107da7: 85 c0 test %eax,%eax
107da9: 0f 84 56 01 00 00 je 107f05 <open+0x189>
}
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
107daf: 83 c9 ff or $0xffffffff,%ecx
107db2: 8b 7d 08 mov 0x8(%ebp),%edi
107db5: 31 c0 xor %eax,%eax
107db7: f2 ae repnz scas %es:(%edi),%al
107db9: f7 d1 not %ecx
107dbb: 49 dec %ecx
107dbc: 83 ec 0c sub $0xc,%esp
107dbf: 6a 01 push $0x1
107dc1: 8d 45 d4 lea -0x2c(%ebp),%eax
107dc4: 50 push %eax
107dc5: 56 push %esi
107dc6: 51 push %ecx
107dc7: ff 75 08 pushl 0x8(%ebp)
107dca: e8 a7 f4 ff ff call 107276 <rtems_filesystem_evaluate_path>
107dcf: 89 c6 mov %eax,%esi
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
107dd1: 83 c4 20 add $0x20,%esp
107dd4: 83 f8 ff cmp $0xffffffff,%eax
107dd7: 75 6c jne 107e45 <open+0xc9>
if ( errno != ENOENT ) {
107dd9: e8 ce 92 00 00 call 1110ac <__errno>
107dde: 83 38 02 cmpl $0x2,(%eax)
107de1: 75 27 jne 107e0a <open+0x8e>
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
107de3: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
107dea: 0f 84 1c 01 00 00 je 107f0c <open+0x190>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
107df0: 6a 00 push $0x0
107df2: 6a 00 push $0x0
107df4: 8b 45 c4 mov -0x3c(%ebp),%eax
107df7: 80 cc 80 or $0x80,%ah
107dfa: 50 push %eax
107dfb: ff 75 08 pushl 0x8(%ebp)
107dfe: e8 99 f8 ff ff call 10769c <mknod>
if ( rc ) {
107e03: 83 c4 10 add $0x10,%esp
107e06: 85 c0 test %eax,%eax
107e08: 74 0e je 107e18 <open+0x9c> <== ALWAYS TAKEN
rc = errno;
107e0a: e8 9d 92 00 00 call 1110ac <__errno>
107e0f: 8b 30 mov (%eax),%esi
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
107e11: 31 ff xor %edi,%edi
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
if ( rc ) {
rc = errno;
goto done;
107e13: e9 10 01 00 00 jmp 107f28 <open+0x1ac>
/*
* After we do the mknod(), we have to evaluate the path to get the
* "loc" structure needed to actually have the file itself open.
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
107e18: 89 f1 mov %esi,%ecx
107e1a: 8b 7d 08 mov 0x8(%ebp),%edi
107e1d: 31 c0 xor %eax,%eax
107e1f: f2 ae repnz scas %es:(%edi),%al
107e21: f7 d1 not %ecx
107e23: 49 dec %ecx
107e24: 83 ec 0c sub $0xc,%esp
107e27: 6a 01 push $0x1
107e29: 8d 45 d4 lea -0x2c(%ebp),%eax
107e2c: 50 push %eax
107e2d: 6a 00 push $0x0
107e2f: 51 push %ecx
107e30: ff 75 08 pushl 0x8(%ebp)
107e33: e8 3e f4 ff ff call 107276 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
107e38: 83 c4 20 add $0x20,%esp
107e3b: 85 c0 test %eax,%eax
107e3d: 0f 85 d2 00 00 00 jne 107f15 <open+0x199> <== NEVER TAKEN
107e43: eb 13 jmp 107e58 <open+0xdc>
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
107e45: 8b 45 0c mov 0xc(%ebp),%eax
107e48: 25 00 0a 00 00 and $0xa00,%eax
107e4d: 3d 00 0a 00 00 cmp $0xa00,%eax
107e52: 0f 84 c6 00 00 00 je 107f1e <open+0x1a2> <== NEVER TAKEN
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
107e58: 8b 73 14 mov 0x14(%ebx),%esi
107e5b: 83 ec 0c sub $0xc,%esp
107e5e: ff 75 0c pushl 0xc(%ebp)
107e61: e8 32 62 00 00 call 10e098 <rtems_libio_fcntl_flags>
107e66: 09 f0 or %esi,%eax
107e68: 89 43 14 mov %eax,0x14(%ebx)
iop->pathinfo = loc;
107e6b: 8d 7b 18 lea 0x18(%ebx),%edi
107e6e: 8d 75 d4 lea -0x2c(%ebp),%esi
107e71: b9 05 00 00 00 mov $0x5,%ecx
107e76: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
107e78: 8b 43 20 mov 0x20(%ebx),%eax
107e7b: ff 75 c4 pushl -0x3c(%ebp)
107e7e: ff 75 0c pushl 0xc(%ebp)
107e81: ff 75 08 pushl 0x8(%ebp)
107e84: 53 push %ebx
107e85: ff 10 call *(%eax)
if ( rc ) {
107e87: 83 c4 20 add $0x20,%esp
107e8a: 85 c0 test %eax,%eax
107e8c: 74 0f je 107e9d <open+0x121>
rc = errno;
107e8e: e8 19 92 00 00 call 1110ac <__errno>
107e93: 8b 30 mov (%eax),%esi
rc = EEXIST;
loc_to_free = &loc;
goto done;
}
loc_to_free = &loc;
107e95: 8d 7d d4 lea -0x2c(%ebp),%edi
iop->pathinfo = loc;
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
if ( rc ) {
rc = errno;
goto done;
107e98: e9 8b 00 00 00 jmp 107f28 <open+0x1ac>
}
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
107e9d: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
107ea4: 0f 84 ae 00 00 00 je 107f58 <open+0x1dc>
rc = ftruncate( iop - rtems_libio_iops, 0 );
107eaa: 50 push %eax
107eab: 6a 00 push $0x0
107ead: 6a 00 push $0x0
107eaf: 89 d8 mov %ebx,%eax
107eb1: 2b 05 98 41 12 00 sub 0x124198,%eax
107eb7: c1 f8 03 sar $0x3,%eax
107eba: 69 c0 b7 6d db b6 imul $0xb6db6db7,%eax,%eax
107ec0: 50 push %eax
107ec1: e8 ea 60 00 00 call 10dfb0 <ftruncate>
107ec6: 89 c6 mov %eax,%esi
if ( rc ) {
107ec8: 83 c4 10 add $0x10,%esp
107ecb: 85 c0 test %eax,%eax
107ecd: 0f 84 85 00 00 00 je 107f58 <open+0x1dc>
if(errno) rc = errno;
107ed3: e8 d4 91 00 00 call 1110ac <__errno>
107ed8: 83 38 00 cmpl $0x0,(%eax)
107edb: 74 07 je 107ee4 <open+0x168> <== NEVER TAKEN
107edd: e8 ca 91 00 00 call 1110ac <__errno>
107ee2: 8b 30 mov (%eax),%esi
close( iop - rtems_libio_iops );
107ee4: 83 ec 0c sub $0xc,%esp
107ee7: 2b 1d 98 41 12 00 sub 0x124198,%ebx
107eed: c1 fb 03 sar $0x3,%ebx
107ef0: 69 db b7 6d db b6 imul $0xb6db6db7,%ebx,%ebx
107ef6: 53 push %ebx
107ef7: e8 44 60 00 00 call 10df40 <close>
107efc: 83 c4 10 add $0x10,%esp
/* those are released by close(): */
iop = 0;
loc_to_free = NULL;
107eff: 31 ff xor %edi,%edi
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
close( iop - rtems_libio_iops );
/* those are released by close(): */
iop = 0;
107f01: 31 db xor %ebx,%ebx
107f03: eb 23 jmp 107f28 <open+0x1ac>
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
rc = ENFILE;
107f05: be 17 00 00 00 mov $0x17,%esi
107f0a: eb 40 jmp 107f4c <open+0x1d0>
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
107f0c: 31 ff xor %edi,%edi
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
rc = ENOENT;
107f0e: be 02 00 00 00 mov $0x2,%esi
107f13: eb 17 jmp 107f2c <open+0x1b0>
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
107f15: 31 ff xor %edi,%edi <== NOT EXECUTED
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
107f17: be 0d 00 00 00 mov $0xd,%esi <== NOT EXECUTED
107f1c: eb 0e jmp 107f2c <open+0x1b0> <== NOT EXECUTED
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
/* We were trying to create a file that already exists */
rc = EEXIST;
loc_to_free = &loc;
107f1e: 8d 7d d4 lea -0x2c(%ebp),%edi
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
/* We were trying to create a file that already exists */
rc = EEXIST;
107f21: be 11 00 00 00 mov $0x11,%esi
107f26: eb 04 jmp 107f2c <open+0x1b0>
* Single exit and clean up path.
*/
done:
va_end(ap);
if ( rc ) {
107f28: 85 f6 test %esi,%esi
107f2a: 74 2c je 107f58 <open+0x1dc> <== NEVER TAKEN
if ( iop )
107f2c: 85 db test %ebx,%ebx
107f2e: 74 0c je 107f3c <open+0x1c0>
rtems_libio_free( iop );
107f30: 83 ec 0c sub $0xc,%esp
107f33: 53 push %ebx
107f34: e8 4b 62 00 00 call 10e184 <rtems_libio_free>
107f39: 83 c4 10 add $0x10,%esp
if ( loc_to_free )
107f3c: 85 ff test %edi,%edi
107f3e: 74 0c je 107f4c <open+0x1d0>
rtems_filesystem_freenode( loc_to_free );
107f40: 83 ec 0c sub $0xc,%esp
107f43: 57 push %edi
107f44: e8 eb f3 ff ff call 107334 <rtems_filesystem_freenode>
107f49: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( rc );
107f4c: e8 5b 91 00 00 call 1110ac <__errno>
107f51: 89 30 mov %esi,(%eax)
107f53: 83 c8 ff or $0xffffffff,%eax
107f56: eb 0f jmp 107f67 <open+0x1eb>
}
return iop - rtems_libio_iops;
107f58: 2b 1d 98 41 12 00 sub 0x124198,%ebx
107f5e: c1 fb 03 sar $0x3,%ebx
107f61: 69 c3 b7 6d db b6 imul $0xb6db6db7,%ebx,%eax
}
107f67: 8d 65 f4 lea -0xc(%ebp),%esp
107f6a: 5b pop %ebx
107f6b: 5e pop %esi
107f6c: 5f pop %edi
107f6d: c9 leave
107f6e: c3 ret
00108b1e <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
108b1e: 55 push %ebp
108b1f: 89 e5 mov %esp,%ebp
108b21: 56 push %esi
108b22: 53 push %ebx
108b23: 83 ec 10 sub $0x10,%esp
108b26: 89 d3 mov %edx,%ebx
108b28: 88 45 f4 mov %al,-0xc(%ebp)
int i;
if (tty->termios.c_oflag & OPOST) {
108b2b: 8b 52 34 mov 0x34(%edx),%edx
108b2e: f6 c2 01 test $0x1,%dl
108b31: 0f 84 ed 00 00 00 je 108c24 <oproc+0x106> <== NEVER TAKEN
switch (c) {
108b37: 3c 09 cmp $0x9,%al
108b39: 74 75 je 108bb0 <oproc+0x92>
108b3b: 77 0d ja 108b4a <oproc+0x2c> <== ALWAYS TAKEN
108b3d: 3c 08 cmp $0x8,%al <== NOT EXECUTED
108b3f: 0f 85 aa 00 00 00 jne 108bef <oproc+0xd1> <== NOT EXECUTED
108b45: e9 98 00 00 00 jmp 108be2 <oproc+0xc4> <== NOT EXECUTED
108b4a: 3c 0a cmp $0xa,%al
108b4c: 74 0a je 108b58 <oproc+0x3a>
108b4e: 3c 0d cmp $0xd,%al
108b50: 0f 85 99 00 00 00 jne 108bef <oproc+0xd1> <== ALWAYS TAKEN
108b56: eb 32 jmp 108b8a <oproc+0x6c> <== NOT EXECUTED
case '\n':
if (tty->termios.c_oflag & ONLRET)
108b58: f6 c2 20 test $0x20,%dl
108b5b: 74 07 je 108b64 <oproc+0x46> <== ALWAYS TAKEN
tty->column = 0;
108b5d: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
108b64: 80 e2 04 and $0x4,%dl
108b67: 0f 84 b7 00 00 00 je 108c24 <oproc+0x106> <== NEVER TAKEN
rtems_termios_puts ("\r", 1, tty);
108b6d: 56 push %esi
108b6e: 53 push %ebx
108b6f: 6a 01 push $0x1
108b71: 68 b8 e6 11 00 push $0x11e6b8
108b76: e8 83 fe ff ff call 1089fe <rtems_termios_puts>
tty->column = 0;
108b7b: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx)
108b82: 83 c4 10 add $0x10,%esp
108b85: e9 9a 00 00 00 jmp 108c24 <oproc+0x106>
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
108b8a: f6 c2 10 test $0x10,%dl <== NOT EXECUTED
108b8d: 74 0a je 108b99 <oproc+0x7b> <== NOT EXECUTED
108b8f: 83 7b 28 00 cmpl $0x0,0x28(%ebx) <== NOT EXECUTED
108b93: 0f 84 9b 00 00 00 je 108c34 <oproc+0x116> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
108b99: f6 c2 08 test $0x8,%dl <== NOT EXECUTED
108b9c: 74 09 je 108ba7 <oproc+0x89> <== NOT EXECUTED
c = '\n';
108b9e: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
108ba2: 80 e2 20 and $0x20,%dl <== NOT EXECUTED
108ba5: 74 7d je 108c24 <oproc+0x106> <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
108ba7: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED
break;
108bae: eb 74 jmp 108c24 <oproc+0x106> <== NOT EXECUTED
case '\t':
i = 8 - (tty->column & 7);
108bb0: 8b 4b 28 mov 0x28(%ebx),%ecx
108bb3: 89 ce mov %ecx,%esi
108bb5: 83 e6 07 and $0x7,%esi
108bb8: b8 08 00 00 00 mov $0x8,%eax
108bbd: 29 f0 sub %esi,%eax
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
108bbf: 81 e2 00 18 00 00 and $0x1800,%edx
108bc5: 81 fa 00 18 00 00 cmp $0x1800,%edx
108bcb: 8d 14 08 lea (%eax,%ecx,1),%edx
108bce: 75 0d jne 108bdd <oproc+0xbf> <== NEVER TAKEN
tty->column += i;
108bd0: 89 53 28 mov %edx,0x28(%ebx)
rtems_termios_puts ( " ", i, tty);
108bd3: 51 push %ecx
108bd4: 53 push %ebx
108bd5: 50 push %eax
108bd6: 68 78 e2 11 00 push $0x11e278
108bdb: eb 4f jmp 108c2c <oproc+0x10e>
return;
}
tty->column += i;
108bdd: 89 53 28 mov %edx,0x28(%ebx) <== NOT EXECUTED
break;
108be0: eb 42 jmp 108c24 <oproc+0x106> <== NOT EXECUTED
case '\b':
if (tty->column > 0)
108be2: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
108be5: 85 c0 test %eax,%eax <== NOT EXECUTED
108be7: 7e 3b jle 108c24 <oproc+0x106> <== NOT EXECUTED
tty->column--;
108be9: 48 dec %eax <== NOT EXECUTED
108bea: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
108bed: eb 35 jmp 108c24 <oproc+0x106> <== NOT EXECUTED
break;
default:
if (tty->termios.c_oflag & OLCUC)
108bef: 80 e2 02 and $0x2,%dl
108bf2: 74 1c je 108c10 <oproc+0xf2> <== ALWAYS TAKEN
c = toupper(c);
108bf4: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
108bf7: 8b 15 08 21 12 00 mov 0x122108,%edx <== NOT EXECUTED
108bfd: 0f be 54 02 01 movsbl 0x1(%edx,%eax,1),%edx <== NOT EXECUTED
108c02: 83 e2 03 and $0x3,%edx <== NOT EXECUTED
108c05: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED
108c08: 75 03 jne 108c0d <oproc+0xef> <== NOT EXECUTED
108c0a: 83 e8 20 sub $0x20,%eax <== NOT EXECUTED
108c0d: 88 45 f4 mov %al,-0xc(%ebp) <== NOT EXECUTED
if (!iscntrl(c))
108c10: 0f b6 45 f4 movzbl -0xc(%ebp),%eax
108c14: 8b 15 08 21 12 00 mov 0x122108,%edx
108c1a: f6 44 02 01 20 testb $0x20,0x1(%edx,%eax,1)
108c1f: 75 03 jne 108c24 <oproc+0x106> <== NEVER TAKEN
tty->column++;
108c21: ff 43 28 incl 0x28(%ebx)
break;
}
}
rtems_termios_puts (&c, 1, tty);
108c24: 52 push %edx
108c25: 53 push %ebx
108c26: 6a 01 push $0x1
108c28: 8d 45 f4 lea -0xc(%ebp),%eax
108c2b: 50 push %eax
108c2c: e8 cd fd ff ff call 1089fe <rtems_termios_puts>
108c31: 83 c4 10 add $0x10,%esp
}
108c34: 8d 65 f8 lea -0x8(%ebp),%esp
108c37: 5b pop %ebx
108c38: 5e pop %esi
108c39: c9 leave
108c3a: c3 ret
0010ede0 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
10ede0: 55 push %ebp
10ede1: 89 e5 mov %esp,%ebp
10ede3: 57 push %edi
10ede4: 56 push %esi
10ede5: 53 push %ebx
10ede6: 83 ec 34 sub $0x34,%esp
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
10ede9: 68 ff 01 00 00 push $0x1ff
10edee: 68 80 04 12 00 push $0x120480
10edf3: e8 5c 14 00 00 call 110254 <rtems_mkdir>
10edf8: 83 c4 10 add $0x10,%esp
return -1;
10edfb: 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)
10ee02: 85 c0 test %eax,%eax
10ee04: 0f 85 e8 00 00 00 jne 10eef2 <pipe_create+0x112> <== NEVER TAKEN
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
10ee0a: 8d 5d d9 lea -0x27(%ebp),%ebx
10ee0d: be 85 04 12 00 mov $0x120485,%esi
10ee12: b9 0a 00 00 00 mov $0xa,%ecx
10ee17: 89 df mov %ebx,%edi
10ee19: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
10ee1b: 0f b7 05 a0 5f 12 00 movzwl 0x125fa0,%eax
10ee22: 8d 50 01 lea 0x1(%eax),%edx
10ee25: 66 89 15 a0 5f 12 00 mov %dx,0x125fa0
10ee2c: 57 push %edi
10ee2d: 50 push %eax
10ee2e: 68 90 04 12 00 push $0x120490
10ee33: 8d 45 e3 lea -0x1d(%ebp),%eax
10ee36: 50 push %eax
10ee37: e8 d0 44 00 00 call 11330c <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
10ee3c: 59 pop %ecx
10ee3d: 5e pop %esi
10ee3e: 68 80 01 00 00 push $0x180
10ee43: 53 push %ebx
10ee44: e8 cb 11 00 00 call 110014 <mkfifo>
10ee49: 83 c4 10 add $0x10,%esp
10ee4c: 85 c0 test %eax,%eax
10ee4e: 74 0a je 10ee5a <pipe_create+0x7a>
if (errno != EEXIST){
10ee50: e8 cb 3a 00 00 call 112920 <__errno>
10ee55: e9 98 00 00 00 jmp 10eef2 <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);
10ee5a: 52 push %edx
10ee5b: 52 push %edx
10ee5c: 68 00 40 00 00 push $0x4000
10ee61: 53 push %ebx
10ee62: e8 7d 9f ff ff call 108de4 <open>
10ee67: 8b 55 08 mov 0x8(%ebp),%edx
10ee6a: 89 02 mov %eax,(%edx)
if (filsdes[0] < 0) {
10ee6c: 83 c4 10 add $0x10,%esp
10ee6f: 85 c0 test %eax,%eax
10ee71: 79 0d jns 10ee80 <pipe_create+0xa0>
err = errno;
10ee73: e8 a8 3a 00 00 call 112920 <__errno>
10ee78: 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);
10ee7a: 83 ec 0c sub $0xc,%esp
10ee7d: 53 push %ebx
10ee7e: eb 51 jmp 10eed1 <pipe_create+0xf1>
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
10ee80: 31 d2 xor %edx,%edx
10ee82: 3b 05 44 21 12 00 cmp 0x122144,%eax
10ee88: 73 09 jae 10ee93 <pipe_create+0xb3> <== NEVER TAKEN
10ee8a: 6b d0 38 imul $0x38,%eax,%edx
10ee8d: 03 15 a0 61 12 00 add 0x1261a0,%edx
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
10ee93: 83 62 14 fe andl $0xfffffffe,0x14(%edx)
filsdes[1] = open(fifopath, O_WRONLY);
10ee97: 50 push %eax
10ee98: 50 push %eax
10ee99: 6a 01 push $0x1
10ee9b: 8d 45 d9 lea -0x27(%ebp),%eax
10ee9e: 50 push %eax
10ee9f: e8 40 9f ff ff call 108de4 <open>
10eea4: 8b 55 08 mov 0x8(%ebp),%edx
10eea7: 89 42 04 mov %eax,0x4(%edx)
if (filsdes[1] < 0) {
10eeaa: 83 c4 10 add $0x10,%esp
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
10eead: 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) {
10eeaf: 85 c0 test %eax,%eax
10eeb1: 79 17 jns 10eeca <pipe_create+0xea>
err = errno;
10eeb3: e8 68 3a 00 00 call 112920 <__errno>
10eeb8: 8b 30 mov (%eax),%esi
close(filsdes[0]);
10eeba: 83 ec 0c sub $0xc,%esp
10eebd: 8b 45 08 mov 0x8(%ebp),%eax
10eec0: ff 30 pushl (%eax)
10eec2: e8 25 91 ff ff call 107fec <close>
10eec7: 83 c4 10 add $0x10,%esp
}
unlink(fifopath);
10eeca: 83 ec 0c sub $0xc,%esp
10eecd: 8d 45 d9 lea -0x27(%ebp),%eax
10eed0: 50 push %eax
10eed1: e8 aa ba ff ff call 10a980 <unlink>
10eed6: 83 c4 10 add $0x10,%esp
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
10eed9: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
10eee0: 85 f6 test %esi,%esi
10eee2: 74 0e je 10eef2 <pipe_create+0x112>
rtems_set_errno_and_return_minus_one(err);
10eee4: e8 37 3a 00 00 call 112920 <__errno>
10eee9: 89 30 mov %esi,(%eax)
10eeeb: c7 45 d4 ff ff ff ff movl $0xffffffff,-0x2c(%ebp)
return 0;
}
10eef2: 8b 45 d4 mov -0x2c(%ebp),%eax
10eef5: 8d 65 f4 lea -0xc(%ebp),%esp
10eef8: 5b pop %ebx
10eef9: 5e pop %esi
10eefa: 5f pop %edi
10eefb: c9 leave
10eefc: c3 ret
001100ea <pipe_ioctl>:
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
1100ea: 55 push %ebp
1100eb: 89 e5 mov %esp,%ebp
1100ed: 56 push %esi
1100ee: 53 push %ebx
1100ef: 8b 5d 08 mov 0x8(%ebp),%ebx
1100f2: 8b 75 10 mov 0x10(%ebp),%esi
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
1100f5: b8 ea ff ff ff mov $0xffffffea,%eax
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
1100fa: 81 7d 0c 7f 66 04 40 cmpl $0x4004667f,0xc(%ebp)
110101: 75 36 jne 110139 <pipe_ioctl+0x4f>
if (buffer == NULL)
return -EFAULT;
110103: b0 f2 mov $0xf2,%al
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
110105: 85 f6 test %esi,%esi
110107: 74 30 je 110139 <pipe_ioctl+0x4f>
return -EFAULT;
if (! PIPE_LOCK(pipe))
110109: 51 push %ecx
11010a: 6a 00 push $0x0
11010c: 6a 00 push $0x0
11010e: ff 73 28 pushl 0x28(%ebx)
110111: e8 fa ba ff ff call 10bc10 <rtems_semaphore_obtain>
110116: 89 c2 mov %eax,%edx
110118: 83 c4 10 add $0x10,%esp
return -EINTR;
11011b: b8 fc ff ff ff mov $0xfffffffc,%eax
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
if (! PIPE_LOCK(pipe))
110120: 85 d2 test %edx,%edx
110122: 75 15 jne 110139 <pipe_ioctl+0x4f> <== NEVER TAKEN
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
110124: 8b 43 0c mov 0xc(%ebx),%eax
110127: 89 06 mov %eax,(%esi)
PIPE_UNLOCK(pipe);
110129: 83 ec 0c sub $0xc,%esp
11012c: ff 73 28 pushl 0x28(%ebx)
11012f: e8 c8 bb ff ff call 10bcfc <rtems_semaphore_release>
return 0;
110134: 83 c4 10 add $0x10,%esp
110137: 31 c0 xor %eax,%eax
}
return -EINVAL;
}
110139: 8d 65 f8 lea -0x8(%ebp),%esp
11013c: 5b pop %ebx
11013d: 5e pop %esi
11013e: c9 leave
11013f: c3 ret
0010fdd0 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
10fdd0: 55 push %ebp
10fdd1: 89 e5 mov %esp,%ebp
10fdd3: 57 push %edi
10fdd4: 56 push %esi
10fdd5: 53 push %ebx
10fdd6: 83 ec 30 sub $0x30,%esp
10fdd9: 8b 5d 08 mov 0x8(%ebp),%ebx
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
10fddc: 6a 00 push $0x0
10fdde: 6a 00 push $0x0
10fde0: ff 73 28 pushl 0x28(%ebx)
10fde3: e8 28 be ff ff call 10bc10 <rtems_semaphore_obtain>
10fde8: 83 c4 10 add $0x10,%esp
return -EINTR;
10fdeb: c7 45 d4 fc ff ff ff movl $0xfffffffc,-0x2c(%ebp)
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
10fdf2: 85 c0 test %eax,%eax
10fdf4: 0f 85 2f 01 00 00 jne 10ff29 <pipe_read+0x159> <== NEVER TAKEN
10fdfa: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
10fe01: e9 f0 00 00 00 jmp 10fef6 <pipe_read+0x126>
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
10fe06: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fe0a: 0f 84 f2 00 00 00 je 10ff02 <pipe_read+0x132>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
10fe10: 8b 45 14 mov 0x14(%ebp),%eax
10fe13: f6 40 14 01 testb $0x1,0x14(%eax)
10fe17: 0f 85 e9 00 00 00 jne 10ff06 <pipe_read+0x136>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
10fe1d: ff 43 18 incl 0x18(%ebx)
PIPE_UNLOCK(pipe);
10fe20: 83 ec 0c sub $0xc,%esp
10fe23: ff 73 28 pushl 0x28(%ebx)
10fe26: e8 d1 be ff ff call 10bcfc <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
10fe2b: 5f pop %edi
10fe2c: 58 pop %eax
10fe2d: 6a 00 push $0x0
10fe2f: ff 73 2c pushl 0x2c(%ebx)
10fe32: e8 a1 16 00 00 call 1114d8 <rtems_barrier_wait>
10fe37: 83 c4 0c add $0xc,%esp
10fe3a: 83 f8 01 cmp $0x1,%eax
10fe3d: 19 f6 sbb %esi,%esi
10fe3f: f7 d6 not %esi
10fe41: 83 e6 fc and $0xfffffffc,%esi
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
10fe44: 6a 00 push $0x0
10fe46: 6a 00 push $0x0
10fe48: ff 73 28 pushl 0x28(%ebx)
10fe4b: e8 c0 bd ff ff call 10bc10 <rtems_semaphore_obtain>
10fe50: 83 c4 10 add $0x10,%esp
10fe53: 85 c0 test %eax,%eax
10fe55: 0f 85 c0 00 00 00 jne 10ff1b <pipe_read+0x14b> <== NEVER TAKEN
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
10fe5b: ff 4b 18 decl 0x18(%ebx)
if (ret != 0)
10fe5e: 85 f6 test %esi,%esi
10fe60: 0f 85 a5 00 00 00 jne 10ff0b <pipe_read+0x13b> <== NEVER TAKEN
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
10fe66: 8b 53 0c mov 0xc(%ebx),%edx
10fe69: 85 d2 test %edx,%edx
10fe6b: 74 99 je 10fe06 <pipe_read+0x36>
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
10fe6d: 8b 45 10 mov 0x10(%ebp),%eax
10fe70: 2b 45 d4 sub -0x2c(%ebp),%eax
10fe73: 89 55 d0 mov %edx,-0x30(%ebp)
10fe76: 39 c2 cmp %eax,%edx
10fe78: 76 03 jbe 10fe7d <pipe_read+0xad>
10fe7a: 89 45 d0 mov %eax,-0x30(%ebp)
chunk1 = pipe->Size - pipe->Start;
10fe7d: 8b 73 08 mov 0x8(%ebx),%esi
10fe80: 8b 43 04 mov 0x4(%ebx),%eax
10fe83: 29 f0 sub %esi,%eax
if (chunk > chunk1) {
10fe85: 39 45 d0 cmp %eax,-0x30(%ebp)
10fe88: 8b 7d 0c mov 0xc(%ebp),%edi
10fe8b: 8b 4d d4 mov -0x2c(%ebp),%ecx
10fe8e: 8d 14 0f lea (%edi,%ecx,1),%edx
10fe91: 7e 1b jle 10feae <pipe_read+0xde>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
10fe93: 03 33 add (%ebx),%esi
10fe95: 89 d7 mov %edx,%edi
10fe97: 89 c1 mov %eax,%ecx
10fe99: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
10fe9b: 8b 55 d4 mov -0x2c(%ebp),%edx
10fe9e: 01 c2 add %eax,%edx
10fea0: 03 55 0c add 0xc(%ebp),%edx
10fea3: 8b 4d d0 mov -0x30(%ebp),%ecx
10fea6: 29 c1 sub %eax,%ecx
10fea8: 8b 33 mov (%ebx),%esi
10feaa: 89 d7 mov %edx,%edi
10feac: eb 07 jmp 10feb5 <pipe_read+0xe5>
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
10feae: 03 33 add (%ebx),%esi
10feb0: 89 d7 mov %edx,%edi
10feb2: 8b 4d d0 mov -0x30(%ebp),%ecx
10feb5: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
pipe->Start += chunk;
10feb7: 8b 45 d0 mov -0x30(%ebp),%eax
10feba: 03 43 08 add 0x8(%ebx),%eax
pipe->Start %= pipe->Size;
10febd: 31 d2 xor %edx,%edx
10febf: f7 73 04 divl 0x4(%ebx)
10fec2: 89 53 08 mov %edx,0x8(%ebx)
pipe->Length -= chunk;
10fec5: 8b 43 0c mov 0xc(%ebx),%eax
10fec8: 2b 45 d0 sub -0x30(%ebp),%eax
10fecb: 89 43 0c mov %eax,0xc(%ebx)
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
10fece: 85 c0 test %eax,%eax
10fed0: 75 07 jne 10fed9 <pipe_read+0x109>
pipe->Start = 0;
10fed2: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
if (pipe->waitingWriters > 0)
10fed9: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx)
10fedd: 74 11 je 10fef0 <pipe_read+0x120>
PIPE_WAKEUPWRITERS(pipe);
10fedf: 56 push %esi
10fee0: 56 push %esi
10fee1: 8d 45 e4 lea -0x1c(%ebp),%eax
10fee4: 50 push %eax
10fee5: ff 73 30 pushl 0x30(%ebx)
10fee8: e8 93 15 00 00 call 111480 <rtems_barrier_release>
10feed: 83 c4 10 add $0x10,%esp
read += chunk;
10fef0: 8b 4d d0 mov -0x30(%ebp),%ecx
10fef3: 01 4d d4 add %ecx,-0x2c(%ebp)
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
10fef6: 8b 7d 10 mov 0x10(%ebp),%edi
10fef9: 39 7d d4 cmp %edi,-0x2c(%ebp)
10fefc: 0f 82 64 ff ff ff jb 10fe66 <pipe_read+0x96>
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
10ff02: 31 f6 xor %esi,%esi
10ff04: eb 05 jmp 10ff0b <pipe_read+0x13b>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
10ff06: be f5 ff ff ff mov $0xfffffff5,%esi
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
10ff0b: 83 ec 0c sub $0xc,%esp
10ff0e: ff 73 28 pushl 0x28(%ebx)
10ff11: e8 e6 bd ff ff call 10bcfc <rtems_semaphore_release>
10ff16: 83 c4 10 add $0x10,%esp
10ff19: eb 05 jmp 10ff20 <pipe_read+0x150>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
10ff1b: be fc ff ff ff mov $0xfffffffc,%esi
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
10ff20: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10ff24: 7f 03 jg 10ff29 <pipe_read+0x159>
return read;
return ret;
10ff26: 89 75 d4 mov %esi,-0x2c(%ebp)
}
10ff29: 8b 45 d4 mov -0x2c(%ebp),%eax
10ff2c: 8d 65 f4 lea -0xc(%ebp),%esp
10ff2f: 5b pop %ebx
10ff30: 5e pop %esi
10ff31: 5f pop %edi
10ff32: c9 leave
10ff33: c3 ret
0010f975 <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
10f975: 55 push %ebp
10f976: 89 e5 mov %esp,%ebp
10f978: 57 push %edi
10f979: 56 push %esi
10f97a: 53 push %ebx
10f97b: 83 ec 1c sub $0x1c,%esp
10f97e: 8b 7d 08 mov 0x8(%ebp),%edi
pipe_control_t *pipe = *pipep;
10f981: 8b 1f mov (%edi),%ebx
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
10f983: 8b 45 0c mov 0xc(%ebp),%eax
10f986: 8b 40 14 mov 0x14(%eax),%eax
10f989: 89 c6 mov %eax,%esi
10f98b: 83 e6 06 and $0x6,%esi
if (mode & LIBIO_FLAGS_READ)
10f98e: a8 02 test $0x2,%al
10f990: 74 03 je 10f995 <pipe_release+0x20>
pipe->Readers --;
10f992: ff 4b 10 decl 0x10(%ebx)
if (mode & LIBIO_FLAGS_WRITE)
10f995: f7 c6 04 00 00 00 test $0x4,%esi
10f99b: 74 03 je 10f9a0 <pipe_release+0x2b>
pipe->Writers --;
10f99d: ff 4b 14 decl 0x14(%ebx)
PIPE_UNLOCK(pipe);
10f9a0: 83 ec 0c sub $0xc,%esp
10f9a3: ff 73 28 pushl 0x28(%ebx)
10f9a6: e8 51 c3 ff ff call 10bcfc <rtems_semaphore_release>
if (pipe->Readers == 0 && pipe->Writers == 0) {
10f9ab: 8b 43 10 mov 0x10(%ebx),%eax
10f9ae: 83 c4 10 add $0x10,%esp
10f9b1: 85 c0 test %eax,%eax
10f9b3: 75 15 jne 10f9ca <pipe_release+0x55>
10f9b5: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10f9b9: 75 0f jne 10f9ca <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);
10f9bb: 89 d8 mov %ebx,%eax
10f9bd: e8 78 ff ff ff call 10f93a <pipe_free>
*pipep = NULL;
10f9c2: c7 07 00 00 00 00 movl $0x0,(%edi)
10f9c8: eb 30 jmp 10f9fa <pipe_release+0x85>
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
10f9ca: 83 fe 04 cmp $0x4,%esi
10f9cd: 74 0f je 10f9de <pipe_release+0x69>
10f9cf: 85 c0 test %eax,%eax
10f9d1: 75 0b jne 10f9de <pipe_release+0x69> <== NEVER TAKEN
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
10f9d3: 57 push %edi
10f9d4: 57 push %edi
10f9d5: 8d 45 e4 lea -0x1c(%ebp),%eax
10f9d8: 50 push %eax
10f9d9: ff 73 30 pushl 0x30(%ebx)
10f9dc: eb 14 jmp 10f9f2 <pipe_release+0x7d>
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
10f9de: 83 fe 02 cmp $0x2,%esi
10f9e1: 74 17 je 10f9fa <pipe_release+0x85> <== NEVER TAKEN
10f9e3: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10f9e7: 75 11 jne 10f9fa <pipe_release+0x85> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
10f9e9: 56 push %esi
10f9ea: 56 push %esi
10f9eb: 8d 45 e4 lea -0x1c(%ebp),%eax
10f9ee: 50 push %eax
10f9ef: ff 73 2c pushl 0x2c(%ebx)
10f9f2: e8 89 1a 00 00 call 111480 <rtems_barrier_release>
10f9f7: 83 c4 10 add $0x10,%esp
pipe_unlock();
10f9fa: e8 25 ff ff ff call 10f924 <pipe_unlock>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
10f9ff: 8d 65 f4 lea -0xc(%ebp),%esp
10fa02: 5b pop %ebx
10fa03: 5e pop %esi
10fa04: 5f pop %edi
10fa05: c9 leave
10fa06: c3 ret
0010ff34 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
10ff34: 55 push %ebp
10ff35: 89 e5 mov %esp,%ebp
10ff37: 57 push %edi
10ff38: 56 push %esi
10ff39: 53 push %ebx
10ff3a: 83 ec 2c sub $0x2c,%esp
10ff3d: 8b 5d 08 mov 0x8(%ebp),%ebx
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
10ff40: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
)
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
10ff47: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10ff4b: 0f 84 8e 01 00 00 je 1100df <pipe_write+0x1ab> <== NEVER TAKEN
return 0;
if (! PIPE_LOCK(pipe))
10ff51: 52 push %edx
10ff52: 6a 00 push $0x0
10ff54: 6a 00 push $0x0
10ff56: ff 73 28 pushl 0x28(%ebx)
10ff59: e8 b2 bc ff ff call 10bc10 <rtems_semaphore_obtain>
10ff5e: 83 c4 10 add $0x10,%esp
return -EINTR;
10ff61: c7 45 d4 fc ff ff ff movl $0xfffffffc,-0x2c(%ebp)
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
10ff68: 85 c0 test %eax,%eax
10ff6a: 0f 85 6f 01 00 00 jne 1100df <pipe_write+0x1ab> <== NEVER TAKEN
return -EINTR;
if (pipe->Readers == 0) {
10ff70: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10ff74: 0f 84 16 01 00 00 je 110090 <pipe_write+0x15c>
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
10ff7a: bf 01 00 00 00 mov $0x1,%edi
10ff7f: 8b 45 10 mov 0x10(%ebp),%eax
10ff82: 3b 43 04 cmp 0x4(%ebx),%eax
10ff85: 77 02 ja 10ff89 <pipe_write+0x55> <== NEVER TAKEN
10ff87: 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;
10ff89: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
10ff90: e9 eb 00 00 00 jmp 110080 <pipe_write+0x14c>
/* 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)) {
10ff95: 8b 4d 14 mov 0x14(%ebp),%ecx
10ff98: f6 41 14 01 testb $0x1,0x14(%ecx)
10ff9c: 0f 85 fc 00 00 00 jne 11009e <pipe_write+0x16a>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
10ffa2: ff 43 1c incl 0x1c(%ebx)
PIPE_UNLOCK(pipe);
10ffa5: 83 ec 0c sub $0xc,%esp
10ffa8: ff 73 28 pushl 0x28(%ebx)
10ffab: e8 4c bd ff ff call 10bcfc <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
10ffb0: 5e pop %esi
10ffb1: 58 pop %eax
10ffb2: 6a 00 push $0x0
10ffb4: ff 73 30 pushl 0x30(%ebx)
10ffb7: e8 1c 15 00 00 call 1114d8 <rtems_barrier_wait>
10ffbc: 83 c4 0c add $0xc,%esp
10ffbf: 83 f8 01 cmp $0x1,%eax
10ffc2: 19 f6 sbb %esi,%esi
10ffc4: f7 d6 not %esi
10ffc6: 83 e6 fc and $0xfffffffc,%esi
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
10ffc9: 6a 00 push $0x0
10ffcb: 6a 00 push $0x0
10ffcd: ff 73 28 pushl 0x28(%ebx)
10ffd0: e8 3b bc ff ff call 10bc10 <rtems_semaphore_obtain>
10ffd5: 83 c4 10 add $0x10,%esp
10ffd8: 85 c0 test %eax,%eax
10ffda: 0f 85 f1 00 00 00 jne 1100d1 <pipe_write+0x19d> <== NEVER TAKEN
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
10ffe0: ff 4b 1c decl 0x1c(%ebx)
if (ret != 0)
10ffe3: 85 f6 test %esi,%esi
10ffe5: 0f 85 bf 00 00 00 jne 1100aa <pipe_write+0x176> <== NEVER TAKEN
goto out_locked;
if (pipe->Readers == 0) {
10ffeb: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10ffef: 0f 84 b0 00 00 00 je 1100a5 <pipe_write+0x171> <== 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) {
10fff5: 8b 73 04 mov 0x4(%ebx),%esi
10fff8: 8b 43 0c mov 0xc(%ebx),%eax
10fffb: 89 f1 mov %esi,%ecx
10fffd: 29 c1 sub %eax,%ecx
10ffff: 39 f9 cmp %edi,%ecx
110001: 72 92 jb 10ff95 <pipe_write+0x61>
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
110003: 8b 55 10 mov 0x10(%ebp),%edx
110006: 2b 55 d4 sub -0x2c(%ebp),%edx
110009: 89 4d d0 mov %ecx,-0x30(%ebp)
11000c: 39 d1 cmp %edx,%ecx
11000e: 76 03 jbe 110013 <pipe_write+0xdf>
110010: 89 55 d0 mov %edx,-0x30(%ebp)
chunk1 = pipe->Size - PIPE_WSTART(pipe);
110013: 03 43 08 add 0x8(%ebx),%eax
110016: 31 d2 xor %edx,%edx
110018: f7 f6 div %esi
11001a: 29 d6 sub %edx,%esi
11001c: 89 75 cc mov %esi,-0x34(%ebp)
if (chunk > chunk1) {
11001f: 39 75 d0 cmp %esi,-0x30(%ebp)
110022: 8b 4d 0c mov 0xc(%ebp),%ecx
110025: 8b 45 d4 mov -0x2c(%ebp),%eax
110028: 8d 34 01 lea (%ecx,%eax,1),%esi
11002b: 7e 20 jle 11004d <pipe_write+0x119>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
11002d: 8b 03 mov (%ebx),%eax
11002f: 01 d0 add %edx,%eax
110031: 89 c7 mov %eax,%edi
110033: 8b 4d cc mov -0x34(%ebp),%ecx
110036: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
110038: 8b 03 mov (%ebx),%eax
11003a: 8b 4d d0 mov -0x30(%ebp),%ecx
11003d: 2b 4d cc sub -0x34(%ebp),%ecx
110040: 8b 75 cc mov -0x34(%ebp),%esi
110043: 03 75 d4 add -0x2c(%ebp),%esi
110046: 03 75 0c add 0xc(%ebp),%esi
110049: 89 c7 mov %eax,%edi
11004b: eb 09 jmp 110056 <pipe_write+0x122>
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
11004d: 8b 03 mov (%ebx),%eax
11004f: 01 d0 add %edx,%eax
110051: 89 c7 mov %eax,%edi
110053: 8b 4d d0 mov -0x30(%ebp),%ecx
110056: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
pipe->Length += chunk;
110058: 8b 45 d0 mov -0x30(%ebp),%eax
11005b: 01 43 0c add %eax,0xc(%ebx)
if (pipe->waitingReaders > 0)
11005e: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
110062: 74 11 je 110075 <pipe_write+0x141>
PIPE_WAKEUPREADERS(pipe);
110064: 51 push %ecx
110065: 51 push %ecx
110066: 8d 4d e4 lea -0x1c(%ebp),%ecx
110069: 51 push %ecx
11006a: ff 73 2c pushl 0x2c(%ebx)
11006d: e8 0e 14 00 00 call 111480 <rtems_barrier_release>
110072: 83 c4 10 add $0x10,%esp
written += chunk;
110075: 8b 45 d0 mov -0x30(%ebp),%eax
110078: 01 45 d4 add %eax,-0x2c(%ebp)
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
11007b: 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) {
110080: 8b 4d 10 mov 0x10(%ebp),%ecx
110083: 39 4d d4 cmp %ecx,-0x2c(%ebp)
110086: 0f 82 69 ff ff ff jb 10fff5 <pipe_write+0xc1>
11008c: 31 f6 xor %esi,%esi
11008e: eb 1a jmp 1100aa <pipe_write+0x176>
if (! PIPE_LOCK(pipe))
return -EINTR;
if (pipe->Readers == 0) {
ret = -EPIPE;
110090: 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;
110095: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
11009c: eb 0c jmp 1100aa <pipe_write+0x176>
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
11009e: be f5 ff ff ff mov $0xfffffff5,%esi
1100a3: eb 05 jmp 1100aa <pipe_write+0x176>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
1100a5: 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);
1100aa: 83 ec 0c sub $0xc,%esp
1100ad: ff 73 28 pushl 0x28(%ebx)
1100b0: e8 47 bc ff ff call 10bcfc <rtems_semaphore_release>
1100b5: 83 c4 10 add $0x10,%esp
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
1100b8: 83 fe e0 cmp $0xffffffe0,%esi
1100bb: 75 19 jne 1100d6 <pipe_write+0x1a2>
kill(getpid(), SIGPIPE);
1100bd: e8 1e 07 00 00 call 1107e0 <getpid>
1100c2: 52 push %edx
1100c3: 52 push %edx
1100c4: 6a 0d push $0xd
1100c6: 50 push %eax
1100c7: e8 9c 09 00 00 call 110a68 <kill>
1100cc: 83 c4 10 add $0x10,%esp
1100cf: eb 05 jmp 1100d6 <pipe_write+0x1a2>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
1100d1: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
1100d6: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
1100da: 7f 03 jg 1100df <pipe_write+0x1ab>
1100dc: 89 75 d4 mov %esi,-0x2c(%ebp)
return written;
return ret;
}
1100df: 8b 45 d4 mov -0x2c(%ebp),%eax
1100e2: 8d 65 f4 lea -0xc(%ebp),%esp
1100e5: 5b pop %ebx
1100e6: 5e pop %esi
1100e7: 5f pop %edi
1100e8: c9 leave
1100e9: c3 ret
0010a7d4 <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
10a7d4: 55 push %ebp
10a7d5: 89 e5 mov %esp,%ebp
10a7d7: 53 push %ebx
10a7d8: 83 ec 04 sub $0x4,%esp
10a7db: 8b 45 0c mov 0xc(%ebp),%eax
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
10a7de: ff 05 c4 aa 12 00 incl 0x12aac4
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
10a7e4: 8d 58 ff lea -0x1(%eax),%ebx
10a7e7: 85 c3 test %eax,%ebx
10a7e9: 75 0d jne 10a7f8 <posix_memalign+0x24> <== NEVER TAKEN
10a7eb: 83 f8 03 cmp $0x3,%eax
10a7ee: 76 08 jbe 10a7f8 <posix_memalign+0x24>
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
}
10a7f0: 59 pop %ecx
10a7f1: 5b pop %ebx
10a7f2: c9 leave
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
10a7f3: e9 74 01 00 00 jmp 10a96c <rtems_memalign>
}
10a7f8: b8 16 00 00 00 mov $0x16,%eax
10a7fd: 5a pop %edx
10a7fe: 5b pop %ebx
10a7ff: c9 leave
10a800: c3 ret
0010efd8 <pthread_attr_getinheritsched>:
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
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 || !inheritsched )
return EINVAL;
10efe1: b8 16 00 00 00 mov $0x16,%eax
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
10efe6: 85 d2 test %edx,%edx
10efe8: 74 17 je 10f001 <pthread_attr_getinheritsched+0x29><== NEVER TAKEN
10efea: 85 c9 test %ecx,%ecx
10efec: 74 0e je 10effc <pthread_attr_getinheritsched+0x24>
10efee: 83 3a 00 cmpl $0x0,(%edx)
10eff1: 74 09 je 10effc <pthread_attr_getinheritsched+0x24>
return EINVAL;
*inheritsched = attr->inheritsched;
10eff3: 8b 42 10 mov 0x10(%edx),%eax
10eff6: 89 01 mov %eax,(%ecx)
return 0;
10eff8: 31 c0 xor %eax,%eax
10effa: eb 05 jmp 10f001 <pthread_attr_getinheritsched+0x29>
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
return EINVAL;
10effc: b8 16 00 00 00 mov $0x16,%eax
*inheritsched = attr->inheritsched;
return 0;
}
10f001: c9 leave
10f002: c3 ret
0010f1f4 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
10f1f4: 55 push %ebp
10f1f5: 89 e5 mov %esp,%ebp
10f1f7: 8b 55 08 mov 0x8(%ebp),%edx
10f1fa: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10f1fd: b8 16 00 00 00 mov $0x16,%eax
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
10f202: 85 d2 test %edx,%edx
10f204: 74 1e je 10f224 <pthread_attr_setschedpolicy+0x30>
10f206: 83 3a 00 cmpl $0x0,(%edx)
10f209: 74 19 je 10f224 <pthread_attr_setschedpolicy+0x30>
return EINVAL;
switch ( policy ) {
10f20b: 83 f9 04 cmp $0x4,%ecx
10f20e: 77 0f ja 10f21f <pthread_attr_setschedpolicy+0x2b>
10f210: b0 01 mov $0x1,%al
10f212: d3 e0 shl %cl,%eax
10f214: a8 17 test $0x17,%al
10f216: 74 07 je 10f21f <pthread_attr_setschedpolicy+0x2b><== NEVER TAKEN
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
10f218: 89 4a 14 mov %ecx,0x14(%edx)
return 0;
10f21b: 31 c0 xor %eax,%eax
10f21d: eb 05 jmp 10f224 <pthread_attr_setschedpolicy+0x30>
default:
return ENOTSUP;
10f21f: b8 86 00 00 00 mov $0x86,%eax
}
}
10f224: c9 leave
10f225: c3 ret
0010a514 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
10a514: 55 push %ebp
10a515: 89 e5 mov %esp,%ebp
10a517: 57 push %edi
10a518: 56 push %esi
10a519: 53 push %ebx
10a51a: 83 ec 1c sub $0x1c,%esp
10a51d: 8b 5d 08 mov 0x8(%ebp),%ebx
10a520: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Error check parameters
*/
if ( !barrier )
return EINVAL;
10a523: b8 16 00 00 00 mov $0x16,%eax
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
10a528: 85 db test %ebx,%ebx
10a52a: 0f 84 96 00 00 00 je 10a5c6 <pthread_barrier_init+0xb2>
return EINVAL;
if ( count == 0 )
10a530: 85 f6 test %esi,%esi
10a532: 0f 84 8e 00 00 00 je 10a5c6 <pthread_barrier_init+0xb2>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10a538: 8b 7d 0c mov 0xc(%ebp),%edi
10a53b: 85 ff test %edi,%edi
10a53d: 75 0f jne 10a54e <pthread_barrier_init+0x3a>
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
10a53f: 83 ec 0c sub $0xc,%esp
10a542: 8d 7d d8 lea -0x28(%ebp),%edi
10a545: 57 push %edi
10a546: e8 19 ff ff ff call 10a464 <pthread_barrierattr_init>
10a54b: 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;
10a54e: 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 )
10a553: 83 3f 00 cmpl $0x0,(%edi)
10a556: 74 6e je 10a5c6 <pthread_barrier_init+0xb2>
return EINVAL;
switch ( the_attr->process_shared ) {
10a558: 83 7f 04 00 cmpl $0x0,0x4(%edi)
10a55c: 75 68 jne 10a5c6 <pthread_barrier_init+0xb2><== NEVER TAKEN
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
10a55e: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
the_attributes.maximum_count = count;
10a565: 89 75 e4 mov %esi,-0x1c(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a568: a1 f4 63 12 00 mov 0x1263f4,%eax
10a56d: 40 inc %eax
10a56e: a3 f4 63 12 00 mov %eax,0x1263f4
* 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 );
10a573: 83 ec 0c sub $0xc,%esp
10a576: 68 c0 67 12 00 push $0x1267c0
10a57b: e8 08 1e 00 00 call 10c388 <_Objects_Allocate>
10a580: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
10a582: 83 c4 10 add $0x10,%esp
10a585: 85 c0 test %eax,%eax
10a587: 75 0c jne 10a595 <pthread_barrier_init+0x81>
_Thread_Enable_dispatch();
10a589: e8 08 2a 00 00 call 10cf96 <_Thread_Enable_dispatch>
return EAGAIN;
10a58e: b8 0b 00 00 00 mov $0xb,%eax
10a593: eb 31 jmp 10a5c6 <pthread_barrier_init+0xb2>
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
10a595: 50 push %eax
10a596: 50 push %eax
10a597: 8d 45 e0 lea -0x20(%ebp),%eax
10a59a: 50 push %eax
10a59b: 8d 46 10 lea 0x10(%esi),%eax
10a59e: 50 push %eax
10a59f: e8 9c 14 00 00 call 10ba40 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10a5a4: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a5a7: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a5aa: 8b 15 dc 67 12 00 mov 0x1267dc,%edx
10a5b0: 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;
10a5b3: 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;
10a5ba: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10a5bc: e8 d5 29 00 00 call 10cf96 <_Thread_Enable_dispatch>
return 0;
10a5c1: 83 c4 10 add $0x10,%esp
10a5c4: 31 c0 xor %eax,%eax
}
10a5c6: 8d 65 f4 lea -0xc(%ebp),%esp
10a5c9: 5b pop %ebx
10a5ca: 5e pop %esi
10a5cb: 5f pop %edi
10a5cc: c9 leave
10a5cd: c3 ret
00109ecc <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
109ecc: 55 push %ebp
109ecd: 89 e5 mov %esp,%ebp
109ecf: 56 push %esi
109ed0: 53 push %ebx
109ed1: 8b 5d 08 mov 0x8(%ebp),%ebx
109ed4: 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 )
109ed7: 85 db test %ebx,%ebx
109ed9: 74 4b je 109f26 <pthread_cleanup_push+0x5a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
109edb: a1 cc 62 12 00 mov 0x1262cc,%eax
109ee0: 40 inc %eax
109ee1: a3 cc 62 12 00 mov %eax,0x1262cc
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
109ee6: 83 ec 0c sub $0xc,%esp
109ee9: 6a 10 push $0x10
109eeb: e8 22 3b 00 00 call 10da12 <_Workspace_Allocate>
if ( handler ) {
109ef0: 83 c4 10 add $0x10,%esp
109ef3: 85 c0 test %eax,%eax
109ef5: 74 24 je 109f1b <pthread_cleanup_push+0x4f><== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
109ef7: 8b 15 1c 68 12 00 mov 0x12681c,%edx
handler_stack = &thread_support->Cancellation_Handlers;
109efd: 8b 92 f8 00 00 00 mov 0xf8(%edx),%edx
109f03: 81 c2 e4 00 00 00 add $0xe4,%edx
handler->routine = routine;
109f09: 89 58 08 mov %ebx,0x8(%eax)
handler->arg = arg;
109f0c: 89 70 0c mov %esi,0xc(%eax)
_Chain_Append( handler_stack, &handler->Node );
109f0f: 51 push %ecx
109f10: 51 push %ecx
109f11: 50 push %eax
109f12: 52 push %edx
109f13: e8 7c 15 00 00 call 10b494 <_Chain_Append>
109f18: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
}
109f1b: 8d 65 f8 lea -0x8(%ebp),%esp
109f1e: 5b pop %ebx
109f1f: 5e pop %esi
109f20: c9 leave
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
109f21: e9 6c 2a 00 00 jmp 10c992 <_Thread_Enable_dispatch>
}
109f26: 8d 65 f8 lea -0x8(%ebp),%esp
109f29: 5b pop %ebx
109f2a: 5e pop %esi
109f2b: c9 leave
109f2c: c3 ret
0010ac3c <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
10ac3c: 55 push %ebp
10ac3d: 89 e5 mov %esp,%ebp
10ac3f: 56 push %esi
10ac40: 53 push %ebx
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
10ac41: 8b 5d 0c mov 0xc(%ebp),%ebx
10ac44: 85 db test %ebx,%ebx
10ac46: 75 05 jne 10ac4d <pthread_cond_init+0x11>
else the_attr = &_POSIX_Condition_variables_Default_attributes;
10ac48: bb 28 0c 12 00 mov $0x120c28,%ebx
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return EINVAL;
10ac4d: 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 )
10ac52: 83 7b 04 01 cmpl $0x1,0x4(%ebx)
10ac56: 74 76 je 10acce <pthread_cond_init+0x92><== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
10ac58: 83 3b 00 cmpl $0x0,(%ebx)
10ac5b: 74 71 je 10acce <pthread_cond_init+0x92>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10ac5d: a1 e4 62 12 00 mov 0x1262e4,%eax
10ac62: 40 inc %eax
10ac63: a3 e4 62 12 00 mov %eax,0x1262e4
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
_Objects_Allocate( &_POSIX_Condition_variables_Information );
10ac68: 83 ec 0c sub $0xc,%esp
10ac6b: 68 48 67 12 00 push $0x126748
10ac70: e8 f3 22 00 00 call 10cf68 <_Objects_Allocate>
10ac75: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
10ac77: 83 c4 10 add $0x10,%esp
10ac7a: 85 c0 test %eax,%eax
10ac7c: 75 0c jne 10ac8a <pthread_cond_init+0x4e>
_Thread_Enable_dispatch();
10ac7e: e8 f3 2e 00 00 call 10db76 <_Thread_Enable_dispatch>
return ENOMEM;
10ac83: b8 0c 00 00 00 mov $0xc,%eax
10ac88: eb 44 jmp 10acce <pthread_cond_init+0x92>
}
the_cond->process_shared = the_attr->process_shared;
10ac8a: 8b 43 04 mov 0x4(%ebx),%eax
10ac8d: 89 46 10 mov %eax,0x10(%esi)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
10ac90: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
_Thread_queue_Initialize(
10ac97: 6a 74 push $0x74
10ac99: 68 00 08 00 10 push $0x10000800
10ac9e: 6a 00 push $0x0
10aca0: 8d 46 18 lea 0x18(%esi),%eax
10aca3: 50 push %eax
10aca4: e8 c3 35 00 00 call 10e26c <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10aca9: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10acac: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10acaf: 8b 15 64 67 12 00 mov 0x126764,%edx
10acb5: 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;
10acb8: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
10acbf: 8b 55 08 mov 0x8(%ebp),%edx
10acc2: 89 02 mov %eax,(%edx)
_Thread_Enable_dispatch();
10acc4: e8 ad 2e 00 00 call 10db76 <_Thread_Enable_dispatch>
return 0;
10acc9: 83 c4 10 add $0x10,%esp
10accc: 31 c0 xor %eax,%eax
}
10acce: 8d 65 f8 lea -0x8(%ebp),%esp
10acd1: 5b pop %ebx
10acd2: 5e pop %esi
10acd3: c9 leave
10acd4: c3 ret
0010aaf0 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
10aaf0: 55 push %ebp
10aaf1: 89 e5 mov %esp,%ebp
10aaf3: 8b 55 08 mov 0x8(%ebp),%edx
if ( !attr || attr->is_initialized == false )
return EINVAL;
10aaf6: b8 16 00 00 00 mov $0x16,%eax
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
10aafb: 85 d2 test %edx,%edx
10aafd: 74 0d je 10ab0c <pthread_condattr_destroy+0x1c>
10aaff: 83 3a 00 cmpl $0x0,(%edx)
10ab02: 74 08 je 10ab0c <pthread_condattr_destroy+0x1c><== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
10ab04: c7 02 00 00 00 00 movl $0x0,(%edx)
return 0;
10ab0a: 30 c0 xor %al,%al
}
10ab0c: c9 leave
10ab0d: c3 ret
0010a224 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
10a224: 55 push %ebp
10a225: 89 e5 mov %esp,%ebp
10a227: 57 push %edi
10a228: 56 push %esi
10a229: 53 push %ebx
10a22a: 83 ec 5c sub $0x5c,%esp
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
10a22d: 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 )
10a234: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a238: 0f 84 0f 02 00 00 je 10a44d <pthread_create+0x229>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
10a23e: 8b 5d 0c mov 0xc(%ebp),%ebx
10a241: 85 db test %ebx,%ebx
10a243: 75 05 jne 10a24a <pthread_create+0x26>
10a245: bb 94 f8 11 00 mov $0x11f894,%ebx
if ( !the_attr->is_initialized )
return EINVAL;
10a24a: 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 )
10a251: 83 3b 00 cmpl $0x0,(%ebx)
10a254: 0f 84 f3 01 00 00 je 10a44d <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) )
10a25a: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a25e: 74 0e je 10a26e <pthread_create+0x4a>
10a260: a1 14 12 12 00 mov 0x121214,%eax
10a265: 39 43 08 cmp %eax,0x8(%ebx)
10a268: 0f 82 df 01 00 00 jb 10a44d <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 ) {
10a26e: 8b 43 10 mov 0x10(%ebx),%eax
10a271: 83 f8 01 cmp $0x1,%eax
10a274: 74 0b je 10a281 <pthread_create+0x5d>
10a276: 83 f8 02 cmp $0x2,%eax
10a279: 0f 85 c7 01 00 00 jne 10a446 <pthread_create+0x222>
10a27f: eb 1f jmp 10a2a0 <pthread_create+0x7c>
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a281: a1 24 58 12 00 mov 0x125824,%eax
10a286: 8b b0 f8 00 00 00 mov 0xf8(%eax),%esi
schedpolicy = api->schedpolicy;
10a28c: 8b 86 84 00 00 00 mov 0x84(%esi),%eax
10a292: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = api->schedparam;
10a295: 8d 7d c4 lea -0x3c(%ebp),%edi
10a298: 81 c6 88 00 00 00 add $0x88,%esi
10a29e: eb 0c jmp 10a2ac <pthread_create+0x88>
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
10a2a0: 8b 43 14 mov 0x14(%ebx),%eax
10a2a3: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = the_attr->schedparam;
10a2a6: 8d 7d c4 lea -0x3c(%ebp),%edi
10a2a9: 8d 73 18 lea 0x18(%ebx),%esi
10a2ac: b9 07 00 00 00 mov $0x7,%ecx
10a2b1: 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;
10a2b3: 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 )
10a2ba: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10a2be: 0f 85 89 01 00 00 jne 10a44d <pthread_create+0x229>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
10a2c4: 83 ec 0c sub $0xc,%esp
10a2c7: ff 75 c4 pushl -0x3c(%ebp)
10a2ca: e8 01 58 00 00 call 10fad0 <_POSIX_Priority_Is_valid>
10a2cf: 83 c4 10 add $0x10,%esp
return EINVAL;
10a2d2: 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 ) )
10a2d9: 84 c0 test %al,%al
10a2db: 0f 84 6c 01 00 00 je 10a44d <pthread_create+0x229> <== NEVER TAKEN
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
10a2e1: 8b 45 c4 mov -0x3c(%ebp),%eax
10a2e4: 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);
10a2e7: 0f b6 3d 18 12 12 00 movzbl 0x121218,%edi
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
10a2ee: 8d 45 e0 lea -0x20(%ebp),%eax
10a2f1: 50 push %eax
10a2f2: 8d 45 e4 lea -0x1c(%ebp),%eax
10a2f5: 50 push %eax
10a2f6: 8d 45 c4 lea -0x3c(%ebp),%eax
10a2f9: 50 push %eax
10a2fa: ff 75 ac pushl -0x54(%ebp)
10a2fd: e8 ee 57 00 00 call 10faf0 <_POSIX_Thread_Translate_sched_param>
10a302: 89 45 b4 mov %eax,-0x4c(%ebp)
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
10a305: 83 c4 10 add $0x10,%esp
10a308: 85 c0 test %eax,%eax
10a30a: 0f 85 3d 01 00 00 jne 10a44d <pthread_create+0x229>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10a310: 83 ec 0c sub $0xc,%esp
10a313: ff 35 7c 53 12 00 pushl 0x12537c
10a319: e8 42 15 00 00 call 10b860 <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
10a31e: c7 04 24 20 55 12 00 movl $0x125520,(%esp)
10a325: e8 9e 1e 00 00 call 10c1c8 <_Objects_Allocate>
10a32a: 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 ) {
10a32d: 83 c4 10 add $0x10,%esp
10a330: 85 c0 test %eax,%eax
10a332: 75 05 jne 10a339 <pthread_create+0x115>
_RTEMS_Unlock_allocator();
10a334: 83 ec 0c sub $0xc,%esp
10a337: eb 53 jmp 10a38c <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(
10a339: 8b 4d e0 mov -0x20(%ebp),%ecx
10a33c: 8b 75 e4 mov -0x1c(%ebp),%esi
10a33f: 8b 53 08 mov 0x8(%ebx),%edx
10a342: a1 14 12 12 00 mov 0x121214,%eax
10a347: d1 e0 shl %eax
10a349: 39 d0 cmp %edx,%eax
10a34b: 73 02 jae 10a34f <pthread_create+0x12b>
10a34d: 89 d0 mov %edx,%eax
10a34f: 52 push %edx
10a350: 6a 00 push $0x0
10a352: 6a 00 push $0x0
10a354: 51 push %ecx
10a355: 56 push %esi
10a356: 6a 01 push $0x1
10a358: 81 e7 ff 00 00 00 and $0xff,%edi
10a35e: 2b 7d a8 sub -0x58(%ebp),%edi
10a361: 57 push %edi
10a362: 6a 01 push $0x1
10a364: 50 push %eax
10a365: ff 73 04 pushl 0x4(%ebx)
10a368: ff 75 b0 pushl -0x50(%ebp)
10a36b: 68 20 55 12 00 push $0x125520
10a370: e8 f3 2a 00 00 call 10ce68 <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
10a375: 83 c4 30 add $0x30,%esp
10a378: 84 c0 test %al,%al
10a37a: 75 2a jne 10a3a6 <pthread_create+0x182>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
10a37c: 56 push %esi
10a37d: 56 push %esi
10a37e: ff 75 b0 pushl -0x50(%ebp)
10a381: 68 20 55 12 00 push $0x125520
10a386: e8 35 21 00 00 call 10c4c0 <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
10a38b: 5b pop %ebx
10a38c: ff 35 7c 53 12 00 pushl 0x12537c
10a392: e8 11 15 00 00 call 10b8a8 <_API_Mutex_Unlock>
return EAGAIN;
10a397: 83 c4 10 add $0x10,%esp
10a39a: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp)
10a3a1: e9 a7 00 00 00 jmp 10a44d <pthread_create+0x229>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10a3a6: 8b 45 b0 mov -0x50(%ebp),%eax
10a3a9: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx
api->Attributes = *the_attr;
10a3af: b9 10 00 00 00 mov $0x10,%ecx
10a3b4: 89 d7 mov %edx,%edi
10a3b6: 89 de mov %ebx,%esi
10a3b8: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
api->detachstate = the_attr->detachstate;
10a3ba: 8b 43 3c mov 0x3c(%ebx),%eax
10a3bd: 89 42 40 mov %eax,0x40(%edx)
api->schedpolicy = schedpolicy;
10a3c0: 8b 45 ac mov -0x54(%ebp),%eax
10a3c3: 89 82 84 00 00 00 mov %eax,0x84(%edx)
api->schedparam = schedparam;
10a3c9: 8d ba 88 00 00 00 lea 0x88(%edx),%edi
10a3cf: 8d 75 c4 lea -0x3c(%ebp),%esi
10a3d2: b1 07 mov $0x7,%cl
10a3d4: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
10a3d6: 83 ec 0c sub $0xc,%esp
10a3d9: 6a 00 push $0x0
10a3db: ff 75 14 pushl 0x14(%ebp)
10a3de: ff 75 10 pushl 0x10(%ebp)
10a3e1: 6a 01 push $0x1
10a3e3: ff 75 b0 pushl -0x50(%ebp)
10a3e6: 89 55 a4 mov %edx,-0x5c(%ebp)
10a3e9: e8 02 34 00 00 call 10d7f0 <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
10a3ee: 83 c4 20 add $0x20,%esp
10a3f1: 83 7d ac 04 cmpl $0x4,-0x54(%ebp)
10a3f5: 8b 55 a4 mov -0x5c(%ebp),%edx
10a3f8: 75 2e jne 10a428 <pthread_create+0x204>
_Watchdog_Insert_ticks(
10a3fa: 83 ec 0c sub $0xc,%esp
&api->Sporadic_timer,
_Timespec_To_ticks( &api->schedparam.sched_ss_repl_period )
10a3fd: 8d 82 90 00 00 00 lea 0x90(%edx),%eax
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
10a403: 50 push %eax
10a404: e8 8f 35 00 00 call 10d998 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a409: 8b 55 a4 mov -0x5c(%ebp),%edx
10a40c: 89 82 b4 00 00 00 mov %eax,0xb4(%edx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a412: 58 pop %eax
10a413: 59 pop %ecx
10a414: 81 c2 a8 00 00 00 add $0xa8,%edx
10a41a: 52 push %edx
10a41b: 68 9c 53 12 00 push $0x12539c
10a420: e8 27 38 00 00 call 10dc4c <_Watchdog_Insert>
10a425: 83 c4 10 add $0x10,%esp
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
10a428: 8b 45 b0 mov -0x50(%ebp),%eax
10a42b: 8b 50 08 mov 0x8(%eax),%edx
10a42e: 8b 45 08 mov 0x8(%ebp),%eax
10a431: 89 10 mov %edx,(%eax)
_RTEMS_Unlock_allocator();
10a433: 83 ec 0c sub $0xc,%esp
10a436: ff 35 7c 53 12 00 pushl 0x12537c
10a43c: e8 67 14 00 00 call 10b8a8 <_API_Mutex_Unlock>
return 0;
10a441: 83 c4 10 add $0x10,%esp
10a444: eb 07 jmp 10a44d <pthread_create+0x229>
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
10a446: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
10a44d: 8b 45 b4 mov -0x4c(%ebp),%eax
10a450: 8d 65 f4 lea -0xc(%ebp),%esp
10a453: 5b pop %ebx
10a454: 5e pop %esi
10a455: 5f pop %edi
10a456: c9 leave
10a457: c3 ret
00110cc0 <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
110cc0: 55 push %ebp
110cc1: 89 e5 mov %esp,%ebp
110cc3: 83 ec 10 sub $0x10,%esp
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
110cc6: ff 75 08 pushl 0x8(%ebp)
110cc9: ff 35 34 48 12 00 pushl 0x124834
110ccf: e8 88 ff ff ff call 110c5c <_POSIX_Thread_Exit>
110cd4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
110cd7: c9 leave <== NOT EXECUTED
110cd8: c3 ret <== NOT EXECUTED
0010bf30 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
10bf30: 55 push %ebp
10bf31: 89 e5 mov %esp,%ebp
10bf33: 53 push %ebx
10bf34: 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 );
10bf37: 8d 45 f4 lea -0xc(%ebp),%eax
10bf3a: 50 push %eax
10bf3b: ff 75 0c pushl 0xc(%ebp)
10bf3e: e8 b9 00 00 00 call 10bffc <_POSIX_Absolute_timeout_to_ticks>
10bf43: 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,
10bf45: 83 c4 0c add $0xc,%esp
10bf48: 83 f8 03 cmp $0x3,%eax
10bf4b: 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 );
10bf4e: ff 75 f4 pushl -0xc(%ebp)
10bf51: 0f b6 c2 movzbl %dl,%eax
10bf54: 50 push %eax
10bf55: ff 75 08 pushl 0x8(%ebp)
10bf58: 88 55 e4 mov %dl,-0x1c(%ebp)
10bf5b: e8 e8 fe ff ff call 10be48 <_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) ) {
10bf60: 83 c4 10 add $0x10,%esp
10bf63: 8a 55 e4 mov -0x1c(%ebp),%dl
10bf66: 84 d2 test %dl,%dl
10bf68: 75 1d jne 10bf87 <pthread_mutex_timedlock+0x57>
10bf6a: 83 f8 10 cmp $0x10,%eax
10bf6d: 75 18 jne 10bf87 <pthread_mutex_timedlock+0x57><== NEVER TAKEN
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10bf6f: 85 db test %ebx,%ebx
10bf71: 74 08 je 10bf7b <pthread_mutex_timedlock+0x4b><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10bf73: 4b dec %ebx
10bf74: 83 fb 01 cmp $0x1,%ebx
10bf77: 77 0e ja 10bf87 <pthread_mutex_timedlock+0x57><== NEVER TAKEN
10bf79: eb 07 jmp 10bf82 <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;
10bf7b: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED
10bf80: eb 05 jmp 10bf87 <pthread_mutex_timedlock+0x57><== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10bf82: b8 74 00 00 00 mov $0x74,%eax
}
return lock_status;
}
10bf87: 8b 5d fc mov -0x4(%ebp),%ebx
10bf8a: c9 leave
10bf8b: c3 ret
0010bba8 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
10bba8: 55 push %ebp
10bba9: 89 e5 mov %esp,%ebp
10bbab: 8b 55 08 mov 0x8(%ebp),%edx
10bbae: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10bbb1: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
10bbb6: 85 d2 test %edx,%edx
10bbb8: 74 0f je 10bbc9 <pthread_mutexattr_setpshared+0x21>
10bbba: 83 3a 00 cmpl $0x0,(%edx)
10bbbd: 74 0a je 10bbc9 <pthread_mutexattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10bbbf: 83 f9 01 cmp $0x1,%ecx
10bbc2: 77 05 ja 10bbc9 <pthread_mutexattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10bbc4: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10bbc7: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10bbc9: c9 leave
10bbca: c3 ret
00109dc0 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
109dc0: 55 push %ebp
109dc1: 89 e5 mov %esp,%ebp
109dc3: 8b 55 08 mov 0x8(%ebp),%edx
109dc6: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
109dc9: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
109dce: 85 d2 test %edx,%edx
109dd0: 74 0f je 109de1 <pthread_mutexattr_settype+0x21>
109dd2: 83 3a 00 cmpl $0x0,(%edx)
109dd5: 74 0a je 109de1 <pthread_mutexattr_settype+0x21><== NEVER TAKEN
return EINVAL;
switch ( type ) {
109dd7: 83 f9 03 cmp $0x3,%ecx
109dda: 77 05 ja 109de1 <pthread_mutexattr_settype+0x21>
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
109ddc: 89 4a 10 mov %ecx,0x10(%edx)
return 0;
109ddf: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
109de1: c9 leave
109de2: c3 ret
0010a870 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
10a870: 55 push %ebp
10a871: 89 e5 mov %esp,%ebp
10a873: 56 push %esi
10a874: 53 push %ebx
10a875: 83 ec 10 sub $0x10,%esp
10a878: 8b 5d 08 mov 0x8(%ebp),%ebx
10a87b: 8b 75 0c mov 0xc(%ebp),%esi
if ( !once_control || !init_routine )
10a87e: 85 f6 test %esi,%esi
10a880: 74 51 je 10a8d3 <pthread_once+0x63>
10a882: 85 db test %ebx,%ebx
10a884: 74 4d je 10a8d3 <pthread_once+0x63>
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
10a886: 31 c0 xor %eax,%eax
)
{
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
10a888: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a88c: 75 4a jne 10a8d8 <pthread_once+0x68>
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
10a88e: 52 push %edx
10a88f: 8d 45 f4 lea -0xc(%ebp),%eax
10a892: 50 push %eax
10a893: 68 00 01 00 00 push $0x100
10a898: 68 00 01 00 00 push $0x100
10a89d: e8 9e 0a 00 00 call 10b340 <rtems_task_mode>
if ( !once_control->init_executed ) {
10a8a2: 83 c4 10 add $0x10,%esp
10a8a5: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a8a9: 75 0f jne 10a8ba <pthread_once+0x4a> <== NEVER TAKEN
once_control->is_initialized = true;
10a8ab: c7 03 01 00 00 00 movl $0x1,(%ebx)
once_control->init_executed = true;
10a8b1: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
(*init_routine)();
10a8b8: ff d6 call *%esi
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
10a8ba: 50 push %eax
10a8bb: 8d 45 f4 lea -0xc(%ebp),%eax
10a8be: 50 push %eax
10a8bf: 68 00 01 00 00 push $0x100
10a8c4: ff 75 f4 pushl -0xc(%ebp)
10a8c7: e8 74 0a 00 00 call 10b340 <rtems_task_mode>
10a8cc: 83 c4 10 add $0x10,%esp
}
return 0;
10a8cf: 31 c0 xor %eax,%eax
10a8d1: eb 05 jmp 10a8d8 <pthread_once+0x68>
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
10a8d3: b8 16 00 00 00 mov $0x16,%eax
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
10a8d8: 8d 65 f8 lea -0x8(%ebp),%esp
10a8db: 5b pop %ebx
10a8dc: 5e pop %esi
10a8dd: c9 leave
10a8de: c3 ret
0010b09c <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
10b09c: 55 push %ebp
10b09d: 89 e5 mov %esp,%ebp
10b09f: 56 push %esi
10b0a0: 53 push %ebx
10b0a1: 83 ec 10 sub $0x10,%esp
10b0a4: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Error check parameters
*/
if ( !rwlock )
return EINVAL;
10b0a7: b8 16 00 00 00 mov $0x16,%eax
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
10b0ac: 85 db test %ebx,%ebx
10b0ae: 0f 84 8b 00 00 00 je 10b13f <pthread_rwlock_init+0xa3>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10b0b4: 8b 75 0c mov 0xc(%ebp),%esi
10b0b7: 85 f6 test %esi,%esi
10b0b9: 75 0f jne 10b0ca <pthread_rwlock_init+0x2e>
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
10b0bb: 83 ec 0c sub $0xc,%esp
10b0be: 8d 75 ec lea -0x14(%ebp),%esi
10b0c1: 56 push %esi
10b0c2: e8 5d 09 00 00 call 10ba24 <pthread_rwlockattr_init>
10b0c7: 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;
10b0ca: 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 )
10b0cf: 83 3e 00 cmpl $0x0,(%esi)
10b0d2: 74 6b je 10b13f <pthread_rwlock_init+0xa3><== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
10b0d4: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10b0d8: 75 65 jne 10b13f <pthread_rwlock_init+0xa3><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
10b0da: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b0e1: a1 f4 82 12 00 mov 0x1282f4,%eax
10b0e6: 40 inc %eax
10b0e7: a3 f4 82 12 00 mov %eax,0x1282f4
* 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 );
10b0ec: 83 ec 0c sub $0xc,%esp
10b0ef: 68 00 85 12 00 push $0x128500
10b0f4: e8 2f 23 00 00 call 10d428 <_Objects_Allocate>
10b0f9: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
10b0fb: 83 c4 10 add $0x10,%esp
10b0fe: 85 c0 test %eax,%eax
10b100: 75 0c jne 10b10e <pthread_rwlock_init+0x72>
_Thread_Enable_dispatch();
10b102: e8 2f 2f 00 00 call 10e036 <_Thread_Enable_dispatch>
return EAGAIN;
10b107: b8 0b 00 00 00 mov $0xb,%eax
10b10c: eb 31 jmp 10b13f <pthread_rwlock_init+0xa3>
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
10b10e: 50 push %eax
10b10f: 50 push %eax
10b110: 8d 45 f4 lea -0xc(%ebp),%eax
10b113: 50 push %eax
10b114: 8d 46 10 lea 0x10(%esi),%eax
10b117: 50 push %eax
10b118: e8 6f 1b 00 00 call 10cc8c <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b11d: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10b120: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b123: 8b 15 1c 85 12 00 mov 0x12851c,%edx
10b129: 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;
10b12c: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
10b133: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10b135: e8 fc 2e 00 00 call 10e036 <_Thread_Enable_dispatch>
return 0;
10b13a: 83 c4 10 add $0x10,%esp
10b13d: 31 c0 xor %eax,%eax
}
10b13f: 8d 65 f8 lea -0x8(%ebp),%esp
10b142: 5b pop %ebx
10b143: 5e pop %esi
10b144: c9 leave
10b145: c3 ret
0010b1b0 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10b1b0: 55 push %ebp
10b1b1: 89 e5 mov %esp,%ebp
10b1b3: 57 push %edi
10b1b4: 56 push %esi
10b1b5: 53 push %ebx
10b1b6: 83 ec 2c sub $0x2c,%esp
10b1b9: 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;
10b1bc: 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 )
10b1c1: 85 ff test %edi,%edi
10b1c3: 0f 84 87 00 00 00 je 10b250 <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 );
10b1c9: 50 push %eax
10b1ca: 50 push %eax
10b1cb: 8d 45 e0 lea -0x20(%ebp),%eax
10b1ce: 50 push %eax
10b1cf: ff 75 0c pushl 0xc(%ebp)
10b1d2: e8 39 58 00 00 call 110a10 <_POSIX_Absolute_timeout_to_ticks>
10b1d7: 89 c6 mov %eax,%esi
10b1d9: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b1dc: 8d 45 e4 lea -0x1c(%ebp),%eax
10b1df: 50 push %eax
10b1e0: ff 37 pushl (%edi)
10b1e2: 68 00 85 12 00 push $0x128500
10b1e7: e8 6c 26 00 00 call 10d858 <_Objects_Get>
switch ( location ) {
10b1ec: 83 c4 10 add $0x10,%esp
10b1ef: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b1f3: 75 5b jne 10b250 <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,
10b1f5: 83 fe 03 cmp $0x3,%esi
10b1f8: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
10b1fb: 83 ec 0c sub $0xc,%esp
10b1fe: 6a 00 push $0x0
10b200: ff 75 e0 pushl -0x20(%ebp)
10b203: 0f b6 ca movzbl %dl,%ecx
10b206: 51 push %ecx
10b207: ff 37 pushl (%edi)
10b209: 83 c0 10 add $0x10,%eax
10b20c: 50 push %eax
10b20d: 88 55 d4 mov %dl,-0x2c(%ebp)
10b210: e8 ab 1a 00 00 call 10ccc0 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b215: 83 c4 20 add $0x20,%esp
10b218: e8 19 2e 00 00 call 10e036 <_Thread_Enable_dispatch>
if ( !do_wait ) {
10b21d: 8a 55 d4 mov -0x2c(%ebp),%dl
10b220: 84 d2 test %dl,%dl
10b222: 75 17 jne 10b23b <pthread_rwlock_timedrdlock+0x8b>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
10b224: a1 44 88 12 00 mov 0x128844,%eax
10b229: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b22d: 75 0c jne 10b23b <pthread_rwlock_timedrdlock+0x8b>
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10b22f: 85 f6 test %esi,%esi
10b231: 74 1d je 10b250 <pthread_rwlock_timedrdlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b233: 4e dec %esi
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10b234: 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 ||
10b236: 83 fe 01 cmp $0x1,%esi
10b239: 76 15 jbe 10b250 <pthread_rwlock_timedrdlock+0xa0><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b23b: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b23e: a1 44 88 12 00 mov 0x128844,%eax
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b243: ff 70 34 pushl 0x34(%eax)
10b246: e8 bd 00 00 00 call 10b308 <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b24b: 89 c3 mov %eax,%ebx
10b24d: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b250: 89 d8 mov %ebx,%eax
10b252: 8d 65 f4 lea -0xc(%ebp),%esp
10b255: 5b pop %ebx
10b256: 5e pop %esi
10b257: 5f pop %edi
10b258: c9 leave
10b259: c3 ret
0010b25c <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10b25c: 55 push %ebp
10b25d: 89 e5 mov %esp,%ebp
10b25f: 57 push %edi
10b260: 56 push %esi
10b261: 53 push %ebx
10b262: 83 ec 2c sub $0x2c,%esp
10b265: 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;
10b268: 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 )
10b26d: 85 ff test %edi,%edi
10b26f: 0f 84 87 00 00 00 je 10b2fc <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 );
10b275: 50 push %eax
10b276: 50 push %eax
10b277: 8d 45 e0 lea -0x20(%ebp),%eax
10b27a: 50 push %eax
10b27b: ff 75 0c pushl 0xc(%ebp)
10b27e: e8 8d 57 00 00 call 110a10 <_POSIX_Absolute_timeout_to_ticks>
10b283: 89 c6 mov %eax,%esi
10b285: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b288: 8d 45 e4 lea -0x1c(%ebp),%eax
10b28b: 50 push %eax
10b28c: ff 37 pushl (%edi)
10b28e: 68 00 85 12 00 push $0x128500
10b293: e8 c0 25 00 00 call 10d858 <_Objects_Get>
switch ( location ) {
10b298: 83 c4 10 add $0x10,%esp
10b29b: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b29f: 75 5b jne 10b2fc <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,
10b2a1: 83 fe 03 cmp $0x3,%esi
10b2a4: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
10b2a7: 83 ec 0c sub $0xc,%esp
10b2aa: 6a 00 push $0x0
10b2ac: ff 75 e0 pushl -0x20(%ebp)
10b2af: 0f b6 ca movzbl %dl,%ecx
10b2b2: 51 push %ecx
10b2b3: ff 37 pushl (%edi)
10b2b5: 83 c0 10 add $0x10,%eax
10b2b8: 50 push %eax
10b2b9: 88 55 d4 mov %dl,-0x2c(%ebp)
10b2bc: e8 b7 1a 00 00 call 10cd78 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b2c1: 83 c4 20 add $0x20,%esp
10b2c4: e8 6d 2d 00 00 call 10e036 <_Thread_Enable_dispatch>
if ( !do_wait &&
10b2c9: 8a 55 d4 mov -0x2c(%ebp),%dl
10b2cc: 84 d2 test %dl,%dl
10b2ce: 75 17 jne 10b2e7 <pthread_rwlock_timedwrlock+0x8b>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
10b2d0: a1 44 88 12 00 mov 0x128844,%eax
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
10b2d5: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b2d9: 75 0c jne 10b2e7 <pthread_rwlock_timedwrlock+0x8b>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10b2db: 85 f6 test %esi,%esi
10b2dd: 74 1d je 10b2fc <pthread_rwlock_timedwrlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b2df: 4e dec %esi
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10b2e0: 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 ||
10b2e2: 83 fe 01 cmp $0x1,%esi
10b2e5: 76 15 jbe 10b2fc <pthread_rwlock_timedwrlock+0xa0><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b2e7: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b2ea: a1 44 88 12 00 mov 0x128844,%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(
10b2ef: ff 70 34 pushl 0x34(%eax)
10b2f2: e8 11 00 00 00 call 10b308 <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b2f7: 89 c3 mov %eax,%ebx
10b2f9: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b2fc: 89 d8 mov %ebx,%eax
10b2fe: 8d 65 f4 lea -0xc(%ebp),%esp
10b301: 5b pop %ebx
10b302: 5e pop %esi
10b303: 5f pop %edi
10b304: c9 leave
10b305: c3 ret
0010ba44 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
10ba44: 55 push %ebp
10ba45: 89 e5 mov %esp,%ebp
10ba47: 8b 55 08 mov 0x8(%ebp),%edx
10ba4a: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr )
return EINVAL;
10ba4d: b8 16 00 00 00 mov $0x16,%eax
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
10ba52: 85 d2 test %edx,%edx
10ba54: 74 0f je 10ba65 <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
if ( !attr->is_initialized )
10ba56: 83 3a 00 cmpl $0x0,(%edx)
10ba59: 74 0a je 10ba65 <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10ba5b: 83 f9 01 cmp $0x1,%ecx
10ba5e: 77 05 ja 10ba65 <pthread_rwlockattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10ba60: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10ba63: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10ba65: c9 leave
10ba66: c3 ret
0010c754 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
10c754: 55 push %ebp
10c755: 89 e5 mov %esp,%ebp
10c757: 57 push %edi
10c758: 56 push %esi
10c759: 53 push %ebx
10c75a: 83 ec 2c sub $0x2c,%esp
10c75d: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
10c760: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp)
int rc;
/*
* Check all the parameters
*/
if ( !param )
10c767: 85 f6 test %esi,%esi
10c769: 0f 84 00 01 00 00 je 10c86f <pthread_setschedparam+0x11b>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
10c76f: 8d 45 e0 lea -0x20(%ebp),%eax
10c772: 50 push %eax
10c773: 8d 45 e4 lea -0x1c(%ebp),%eax
10c776: 50 push %eax
10c777: 56 push %esi
10c778: ff 75 0c pushl 0xc(%ebp)
10c77b: e8 00 52 00 00 call 111980 <_POSIX_Thread_Translate_sched_param>
10c780: 89 45 d4 mov %eax,-0x2c(%ebp)
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
10c783: 83 c4 10 add $0x10,%esp
10c786: 85 c0 test %eax,%eax
10c788: 0f 85 e1 00 00 00 jne 10c86f <pthread_setschedparam+0x11b>
10c78e: 53 push %ebx
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _POSIX_Threads_Get( thread, &location );
10c78f: 8d 45 dc lea -0x24(%ebp),%eax
10c792: 50 push %eax
10c793: ff 75 08 pushl 0x8(%ebp)
10c796: 68 80 95 12 00 push $0x129580
10c79b: e8 80 1c 00 00 call 10e420 <_Objects_Get>
10c7a0: 89 c2 mov %eax,%edx
switch ( location ) {
10c7a2: 83 c4 10 add $0x10,%esp
10c7a5: 83 7d dc 00 cmpl $0x0,-0x24(%ebp)
10c7a9: 0f 85 b9 00 00 00 jne 10c868 <pthread_setschedparam+0x114>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10c7af: 8b 98 f8 00 00 00 mov 0xf8(%eax),%ebx
if ( api->schedpolicy == SCHED_SPORADIC )
10c7b5: 83 bb 84 00 00 00 04 cmpl $0x4,0x84(%ebx)
10c7bc: 75 18 jne 10c7d6 <pthread_setschedparam+0x82>
(void) _Watchdog_Remove( &api->Sporadic_timer );
10c7be: 83 ec 0c sub $0xc,%esp
10c7c1: 8d 83 a8 00 00 00 lea 0xa8(%ebx),%eax
10c7c7: 50 push %eax
10c7c8: 89 55 d0 mov %edx,-0x30(%ebp)
10c7cb: e8 48 34 00 00 call 10fc18 <_Watchdog_Remove>
10c7d0: 83 c4 10 add $0x10,%esp
10c7d3: 8b 55 d0 mov -0x30(%ebp),%edx
api->schedpolicy = policy;
10c7d6: 8b 45 0c mov 0xc(%ebp),%eax
10c7d9: 89 83 84 00 00 00 mov %eax,0x84(%ebx)
api->schedparam = *param;
10c7df: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi
10c7e5: b9 07 00 00 00 mov $0x7,%ecx
10c7ea: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_thread->budget_algorithm = budget_algorithm;
10c7ec: 8b 45 e4 mov -0x1c(%ebp),%eax
10c7ef: 89 42 7c mov %eax,0x7c(%edx)
the_thread->budget_callout = budget_callout;
10c7f2: 8b 45 e0 mov -0x20(%ebp),%eax
10c7f5: 89 82 80 00 00 00 mov %eax,0x80(%edx)
switch ( api->schedpolicy ) {
10c7fb: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10c7ff: 78 60 js 10c861 <pthread_setschedparam+0x10d><== NEVER TAKEN
10c801: 83 7d 0c 02 cmpl $0x2,0xc(%ebp)
10c805: 7e 08 jle 10c80f <pthread_setschedparam+0xbb>
10c807: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
10c80b: 75 54 jne 10c861 <pthread_setschedparam+0x10d><== NEVER TAKEN
10c80d: eb 24 jmp 10c833 <pthread_setschedparam+0xdf>
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c80f: a1 04 93 12 00 mov 0x129304,%eax
10c814: 89 42 78 mov %eax,0x78(%edx)
10c817: 0f b6 05 18 52 12 00 movzbl 0x125218,%eax
10c81e: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax
the_thread->real_priority =
10c824: 89 42 18 mov %eax,0x18(%edx)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
10c827: 51 push %ecx
10c828: 6a 01 push $0x1
10c82a: 50 push %eax
10c82b: 52 push %edx
10c82c: e8 3b 1f 00 00 call 10e76c <_Thread_Change_priority>
10c831: eb 2b jmp 10c85e <pthread_setschedparam+0x10a>
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
10c833: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax
10c839: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
_Watchdog_Remove( &api->Sporadic_timer );
10c83f: 83 ec 0c sub $0xc,%esp
10c842: 81 c3 a8 00 00 00 add $0xa8,%ebx
10c848: 53 push %ebx
10c849: 89 55 d0 mov %edx,-0x30(%ebp)
10c84c: e8 c7 33 00 00 call 10fc18 <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
10c851: 58 pop %eax
10c852: 5a pop %edx
10c853: 8b 55 d0 mov -0x30(%ebp),%edx
10c856: 52 push %edx
10c857: 6a 00 push $0x0
10c859: e8 e1 fd ff ff call 10c63f <_POSIX_Threads_Sporadic_budget_TSR>
break;
10c85e: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10c861: e8 98 23 00 00 call 10ebfe <_Thread_Enable_dispatch>
return 0;
10c866: eb 07 jmp 10c86f <pthread_setschedparam+0x11b>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
10c868: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp)
}
10c86f: 8b 45 d4 mov -0x2c(%ebp),%eax
10c872: 8d 65 f4 lea -0xc(%ebp),%esp
10c875: 5b pop %ebx
10c876: 5e pop %esi
10c877: 5f pop %edi
10c878: c9 leave
10c879: c3 ret
0010a640 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
10a640: 55 push %ebp
10a641: 89 e5 mov %esp,%ebp
10a643: 53 push %ebx
10a644: 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() )
10a647: 83 3d 18 68 12 00 00 cmpl $0x0,0x126818
10a64e: 75 48 jne 10a698 <pthread_testcancel+0x58><== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a650: a1 1c 68 12 00 mov 0x12681c,%eax
10a655: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax
10a65b: 8b 15 cc 62 12 00 mov 0x1262cc,%edx
10a661: 42 inc %edx
10a662: 89 15 cc 62 12 00 mov %edx,0x1262cc
*/
void pthread_testcancel( void )
{
POSIX_API_Control *thread_support;
bool cancel = false;
10a668: 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 &&
10a66a: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax)
10a671: 75 0a jne 10a67d <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));
10a673: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax)
10a67a: 0f 95 c3 setne %bl
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
10a67d: e8 10 23 00 00 call 10c992 <_Thread_Enable_dispatch>
if ( cancel )
10a682: 84 db test %bl,%bl
10a684: 74 12 je 10a698 <pthread_testcancel+0x58>
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
10a686: 50 push %eax
10a687: 50 push %eax
10a688: 6a ff push $0xffffffff
10a68a: ff 35 1c 68 12 00 pushl 0x12681c
10a690: e8 9b 51 00 00 call 10f830 <_POSIX_Thread_Exit>
10a695: 83 c4 10 add $0x10,%esp
}
10a698: 8b 5d fc mov -0x4(%ebp),%ebx
10a69b: c9 leave
10a69c: c3 ret
0011c7b4 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
11c7b4: 55 push %ebp
11c7b5: 89 e5 mov %esp,%ebp
11c7b7: 56 push %esi
11c7b8: 53 push %ebx
11c7b9: 8b 5d 08 mov 0x8(%ebp),%ebx
11c7bc: 8b 55 0c mov 0xc(%ebp),%edx
11c7bf: 8b 4d 10 mov 0x10(%ebp),%ecx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11c7c2: 3b 1d 44 01 12 00 cmp 0x120144,%ebx
11c7c8: 73 14 jae 11c7de <read+0x2a> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
11c7ca: 6b db 38 imul $0x38,%ebx,%ebx
11c7cd: 03 1d 98 41 12 00 add 0x124198,%ebx
rtems_libio_check_is_open( iop );
11c7d3: 8b 73 14 mov 0x14(%ebx),%esi
11c7d6: f7 c6 00 01 00 00 test $0x100,%esi
11c7dc: 75 0d jne 11c7eb <read+0x37>
11c7de: e8 c9 48 ff ff call 1110ac <__errno>
11c7e3: c7 00 09 00 00 00 movl $0x9,(%eax)
11c7e9: eb 1a jmp 11c805 <read+0x51>
rtems_libio_check_buffer( buffer );
11c7eb: 85 d2 test %edx,%edx
11c7ed: 74 0b je 11c7fa <read+0x46> <== NEVER TAKEN
rtems_libio_check_count( count );
11c7ef: 31 c0 xor %eax,%eax
11c7f1: 85 c9 test %ecx,%ecx
11c7f3: 74 31 je 11c826 <read+0x72>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
11c7f5: 83 e6 02 and $0x2,%esi
11c7f8: 75 10 jne 11c80a <read+0x56>
11c7fa: e8 ad 48 ff ff call 1110ac <__errno>
11c7ff: c7 00 16 00 00 00 movl $0x16,(%eax)
11c805: 83 c8 ff or $0xffffffff,%eax
11c808: eb 1c jmp 11c826 <read+0x72>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
11c80a: 50 push %eax
11c80b: 8b 43 20 mov 0x20(%ebx),%eax
11c80e: 51 push %ecx
11c80f: 52 push %edx
11c810: 53 push %ebx
11c811: ff 50 08 call *0x8(%eax)
if ( rc > 0 )
11c814: 83 c4 10 add $0x10,%esp
11c817: 85 c0 test %eax,%eax
11c819: 7e 0b jle 11c826 <read+0x72>
iop->offset += rc;
11c81b: 89 c1 mov %eax,%ecx
11c81d: c1 f9 1f sar $0x1f,%ecx
11c820: 01 43 0c add %eax,0xc(%ebx)
11c823: 11 4b 10 adc %ecx,0x10(%ebx)
return rc;
}
11c826: 8d 65 f8 lea -0x8(%ebp),%esp
11c829: 5b pop %ebx
11c82a: 5e pop %esi
11c82b: c9 leave
11c82c: c3 ret
00109ea4 <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
109ea4: 55 push %ebp
109ea5: 89 e5 mov %esp,%ebp
109ea7: 57 push %edi
109ea8: 56 push %esi
109ea9: 53 push %ebx
109eaa: 83 ec 2c sub $0x2c,%esp
109ead: 8b 55 08 mov 0x8(%ebp),%edx
109eb0: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
109eb3: 85 db test %ebx,%ebx
109eb5: 75 10 jne 109ec7 <readlink+0x23>
rtems_set_errno_and_return_minus_one( EFAULT );
109eb7: e8 fc 98 00 00 call 1137b8 <__errno>
109ebc: c7 00 0e 00 00 00 movl $0xe,(%eax)
109ec2: 83 cf ff or $0xffffffff,%edi
109ec5: eb 69 jmp 109f30 <readlink+0x8c>
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
109ec7: 31 c0 xor %eax,%eax
109ec9: 83 c9 ff or $0xffffffff,%ecx
109ecc: 89 d7 mov %edx,%edi
109ece: f2 ae repnz scas %es:(%edi),%al
109ed0: f7 d1 not %ecx
109ed2: 49 dec %ecx
109ed3: 83 ec 0c sub $0xc,%esp
109ed6: 6a 00 push $0x0
109ed8: 8d 75 d4 lea -0x2c(%ebp),%esi
109edb: 56 push %esi
109edc: 6a 00 push $0x0
109ede: 51 push %ecx
109edf: 52 push %edx
109ee0: e8 6d f0 ff ff call 108f52 <rtems_filesystem_evaluate_path>
0, &loc, false );
if ( result != 0 )
109ee5: 83 c4 20 add $0x20,%esp
return -1;
109ee8: 83 cf ff or $0xffffffff,%edi
if (!buf)
rtems_set_errno_and_return_minus_one( EFAULT );
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
0, &loc, false );
if ( result != 0 )
109eeb: 85 c0 test %eax,%eax
109eed: 75 41 jne 109f30 <readlink+0x8c> <== NEVER TAKEN
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
109eef: 83 ec 0c sub $0xc,%esp
109ef2: 56 push %esi
109ef3: 8b 45 e0 mov -0x20(%ebp),%eax
109ef6: ff 50 10 call *0x10(%eax)
109ef9: 83 c4 10 add $0x10,%esp
109efc: 83 f8 04 cmp $0x4,%eax
109eff: 74 16 je 109f17 <readlink+0x73>
rtems_filesystem_freenode( &loc );
109f01: 83 ec 0c sub $0xc,%esp
109f04: 56 push %esi
109f05: e8 06 f1 ff ff call 109010 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EINVAL );
109f0a: e8 a9 98 00 00 call 1137b8 <__errno>
109f0f: c7 00 16 00 00 00 movl $0x16,(%eax)
109f15: eb 16 jmp 109f2d <readlink+0x89>
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
109f17: 50 push %eax
109f18: ff 75 10 pushl 0x10(%ebp)
109f1b: 53 push %ebx
109f1c: 56 push %esi
109f1d: 8b 45 e0 mov -0x20(%ebp),%eax
109f20: ff 50 3c call *0x3c(%eax)
109f23: 89 c7 mov %eax,%edi
rtems_filesystem_freenode( &loc );
109f25: 89 34 24 mov %esi,(%esp)
109f28: e8 e3 f0 ff ff call 109010 <rtems_filesystem_freenode>
return result;
109f2d: 83 c4 10 add $0x10,%esp
}
109f30: 89 f8 mov %edi,%eax
109f32: 8d 65 f4 lea -0xc(%ebp),%esp
109f35: 5b pop %ebx
109f36: 5e pop %esi
109f37: 5f pop %edi
109f38: c9 leave
109f39: c3 ret
00108c64 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
108c64: 55 push %ebp
108c65: 89 e5 mov %esp,%ebp
108c67: 57 push %edi
108c68: 56 push %esi
108c69: 53 push %ebx
108c6a: 83 ec 2c sub $0x2c,%esp
108c6d: 8b 75 08 mov 0x8(%ebp),%esi
108c70: 8b 7d 0c mov 0xc(%ebp),%edi
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
108c73: 3b 35 44 11 12 00 cmp 0x121144,%esi
108c79: 73 11 jae 108c8c <readv+0x28>
iop = rtems_libio_iop( fd );
108c7b: 6b f6 38 imul $0x38,%esi,%esi
108c7e: 03 35 98 51 12 00 add 0x125198,%esi
rtems_libio_check_is_open( iop );
108c84: 8b 46 14 mov 0x14(%esi),%eax
108c87: f6 c4 01 test $0x1,%ah
108c8a: 75 10 jne 108c9c <readv+0x38>
108c8c: e8 fb 8f 00 00 call 111c8c <__errno>
108c91: c7 00 09 00 00 00 movl $0x9,(%eax)
108c97: e9 a4 00 00 00 jmp 108d40 <readv+0xdc>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
108c9c: a8 02 test $0x2,%al
108c9e: 74 35 je 108cd5 <readv+0x71> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
108ca0: 85 ff test %edi,%edi
108ca2: 74 31 je 108cd5 <readv+0x71>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
108ca4: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
108ca8: 7e 2b jle 108cd5 <readv+0x71>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
108caa: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp)
108cb1: 7f 22 jg 108cd5 <readv+0x71> <== NEVER TAKEN
108cb3: b2 01 mov $0x1,%dl
108cb5: 31 c0 xor %eax,%eax
108cb7: 31 c9 xor %ecx,%ecx
108cb9: 89 75 d4 mov %esi,-0x2c(%ebp)
108cbc: eb 03 jmp 108cc1 <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;
108cbe: 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 )
108cc1: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8)
108cc5: 74 0e je 108cd5 <readv+0x71>
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
108cc7: 8b 5c c7 04 mov 0x4(%edi,%eax,8),%ebx
108ccb: 8d 34 19 lea (%ecx,%ebx,1),%esi
108cce: 89 75 e4 mov %esi,-0x1c(%ebp)
if ( total < old )
108cd1: 39 ce cmp %ecx,%esi
108cd3: 7d 0d jge 108ce2 <readv+0x7e>
rtems_set_errno_and_return_minus_one( EINVAL );
108cd5: e8 b2 8f 00 00 call 111c8c <__errno>
108cda: c7 00 16 00 00 00 movl $0x16,(%eax)
108ce0: eb 5e jmp 108d40 <readv+0xdc>
if ( iov[v].iov_len )
all_zeros = false;
108ce2: 85 db test %ebx,%ebx
108ce4: 0f 94 c1 sete %cl
108ce7: f7 d9 neg %ecx
108ce9: 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++ ) {
108ceb: 40 inc %eax
108cec: 3b 45 10 cmp 0x10(%ebp),%eax
108cef: 7c cd jl 108cbe <readv+0x5a>
108cf1: 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;
108cf4: 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 ) {
108cf6: 84 d2 test %dl,%dl
108cf8: 75 49 jne 108d43 <readv+0xdf>
108cfa: 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)(
108d01: 50 push %eax
108d02: 8b 46 20 mov 0x20(%esi),%eax
108d05: 8b 55 e4 mov -0x1c(%ebp),%edx
108d08: ff 74 d7 04 pushl 0x4(%edi,%edx,8)
108d0c: ff 34 d7 pushl (%edi,%edx,8)
108d0f: 56 push %esi
108d10: ff 50 08 call *0x8(%eax)
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
108d13: 83 c4 10 add $0x10,%esp
108d16: 83 f8 00 cmp $0x0,%eax
108d19: 7c 25 jl 108d40 <readv+0xdc> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
108d1b: 74 0d je 108d2a <readv+0xc6> <== NEVER TAKEN
iop->offset += bytes;
108d1d: 89 c1 mov %eax,%ecx
108d1f: c1 f9 1f sar $0x1f,%ecx
108d22: 01 46 0c add %eax,0xc(%esi)
108d25: 11 4e 10 adc %ecx,0x10(%esi)
total += bytes;
108d28: 01 c3 add %eax,%ebx
}
if (bytes != iov[ v ].iov_len)
108d2a: 8b 55 e4 mov -0x1c(%ebp),%edx
108d2d: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax
108d31: 75 10 jne 108d43 <readv+0xdf> <== NEVER TAKEN
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
108d33: 42 inc %edx
108d34: 89 55 e4 mov %edx,-0x1c(%ebp)
108d37: 8b 45 10 mov 0x10(%ebp),%eax
108d3a: 39 c2 cmp %eax,%edx
108d3c: 7c c3 jl 108d01 <readv+0x9d>
108d3e: eb 03 jmp 108d43 <readv+0xdf>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
108d40: 83 cb ff or $0xffffffff,%ebx
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
108d43: 89 d8 mov %ebx,%eax
108d45: 8d 65 f4 lea -0xc(%ebp),%esp
108d48: 5b pop %ebx
108d49: 5e pop %esi
108d4a: 5f pop %edi
108d4b: c9 leave
108d4c: c3 ret
0011c8b8 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
11c8b8: 55 push %ebp
11c8b9: 89 e5 mov %esp,%ebp
11c8bb: 57 push %edi
11c8bc: 56 push %esi
11c8bd: 53 push %ebx
11c8be: 83 ec 2c sub $0x2c,%esp
11c8c1: 8b 5d 08 mov 0x8(%ebp),%ebx
11c8c4: 8b 75 0c mov 0xc(%ebp),%esi
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
11c8c7: ff 05 c0 41 12 00 incl 0x1241c0
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
11c8cd: 83 3d 64 44 12 00 03 cmpl $0x3,0x124464
11c8d4: 75 1a jne 11c8f0 <realloc+0x38> <== NEVER TAKEN
if (_Thread_Dispatch_disable_level > 0)
11c8d6: a1 e4 42 12 00 mov 0x1242e4,%eax
11c8db: 85 c0 test %eax,%eax
11c8dd: 0f 85 ad 00 00 00 jne 11c990 <realloc+0xd8> <== NEVER TAKEN
return (void *) 0;
if (_ISR_Nest_level > 0)
11c8e3: 83 3d 30 48 12 00 00 cmpl $0x0,0x124830
11c8ea: 0f 85 a0 00 00 00 jne 11c990 <realloc+0xd8> <== NEVER TAKEN
}
/*
* Continue with realloc().
*/
if ( !ptr )
11c8f0: 85 db test %ebx,%ebx
11c8f2: 75 13 jne 11c907 <realloc+0x4f>
return malloc( size );
11c8f4: 83 ec 0c sub $0xc,%esp
11c8f7: 56 push %esi
11c8f8: e8 e7 ac fe ff call 1075e4 <malloc>
11c8fd: 89 c3 mov %eax,%ebx
11c8ff: 83 c4 10 add $0x10,%esp
11c902: e9 8b 00 00 00 jmp 11c992 <realloc+0xda>
if ( !size ) {
11c907: 85 f6 test %esi,%esi
11c909: 75 0e jne 11c919 <realloc+0x61> <== ALWAYS TAKEN
free( ptr );
11c90b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
11c90e: 53 push %ebx <== NOT EXECUTED
11c90f: e8 34 aa fe ff call 107348 <free> <== NOT EXECUTED
return (void *) 0;
11c914: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
11c917: eb 77 jmp 11c990 <realloc+0xd8> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
11c919: 52 push %edx
11c91a: 8d 45 e4 lea -0x1c(%ebp),%eax
11c91d: 50 push %eax
11c91e: 53 push %ebx
11c91f: ff 35 50 01 12 00 pushl 0x120150
11c925: e8 ee 00 00 00 call 11ca18 <_Protected_heap_Get_block_size>
11c92a: 83 c4 10 add $0x10,%esp
11c92d: 84 c0 test %al,%al
11c92f: 75 0d jne 11c93e <realloc+0x86>
errno = EINVAL;
11c931: e8 76 47 ff ff call 1110ac <__errno>
11c936: c7 00 16 00 00 00 movl $0x16,(%eax)
11c93c: eb 52 jmp 11c990 <realloc+0xd8>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
11c93e: 50 push %eax
11c93f: 56 push %esi
11c940: 53 push %ebx
11c941: ff 35 50 01 12 00 pushl 0x120150
11c947: e8 04 01 00 00 call 11ca50 <_Protected_heap_Resize_block>
11c94c: 83 c4 10 add $0x10,%esp
11c94f: 84 c0 test %al,%al
11c951: 75 3f jne 11c992 <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 );
11c953: 83 ec 0c sub $0xc,%esp
11c956: 56 push %esi
11c957: e8 88 ac fe ff call 1075e4 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
11c95c: ff 0d b4 41 12 00 decl 0x1241b4
if ( !new_area ) {
11c962: 83 c4 10 add $0x10,%esp
11c965: 85 c0 test %eax,%eax
11c967: 74 27 je 11c990 <realloc+0xd8>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
11c969: 8b 55 e4 mov -0x1c(%ebp),%edx
11c96c: 89 f1 mov %esi,%ecx
11c96e: 39 d6 cmp %edx,%esi
11c970: 76 02 jbe 11c974 <realloc+0xbc> <== NEVER TAKEN
11c972: 89 d1 mov %edx,%ecx
11c974: 89 c7 mov %eax,%edi
11c976: 89 de mov %ebx,%esi
11c978: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
free( ptr );
11c97a: 83 ec 0c sub $0xc,%esp
11c97d: 53 push %ebx
11c97e: 89 45 d4 mov %eax,-0x2c(%ebp)
11c981: e8 c2 a9 fe ff call 107348 <free>
return new_area;
11c986: 83 c4 10 add $0x10,%esp
11c989: 8b 45 d4 mov -0x2c(%ebp),%eax
11c98c: 89 c3 mov %eax,%ebx
11c98e: eb 02 jmp 11c992 <realloc+0xda>
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
11c990: 31 db xor %ebx,%ebx
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
11c992: 89 d8 mov %ebx,%eax
11c994: 8d 65 f4 lea -0xc(%ebp),%esp
11c997: 5b pop %ebx
11c998: 5e pop %esi
11c999: 5f pop %edi
11c99a: c9 leave
11c99b: c3 ret
00108390 <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
108390: 55 push %ebp
108391: 89 e5 mov %esp,%ebp
108393: 57 push %edi
108394: 56 push %esi
108395: 53 push %ebx
108396: 83 ec 58 sub $0x58,%esp
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
108399: ff 75 08 pushl 0x8(%ebp)
10839c: e8 fe f2 ff ff call 10769f <rtems_filesystem_dirname>
1083a1: 89 45 b4 mov %eax,-0x4c(%ebp)
if ( parentpathlen == 0 )
1083a4: 83 c4 10 add $0x10,%esp
1083a7: 85 c0 test %eax,%eax
1083a9: 8d 45 d0 lea -0x30(%ebp),%eax
1083ac: 75 15 jne 1083c3 <rmdir+0x33>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
1083ae: 51 push %ecx
1083af: 50 push %eax
1083b0: 8d 45 e4 lea -0x1c(%ebp),%eax
1083b3: 50 push %eax
1083b4: ff 75 08 pushl 0x8(%ebp)
1083b7: e8 08 01 00 00 call 1084c4 <rtems_filesystem_get_start_loc>
1083bc: 83 c4 10 add $0x10,%esp
const char *name;
rtems_filesystem_location_info_t parentloc;
rtems_filesystem_location_info_t loc;
int i;
int result;
bool free_parentloc = false;
1083bf: 31 db xor %ebx,%ebx
1083c1: eb 25 jmp 1083e8 <rmdir+0x58>
parentpathlen = rtems_filesystem_dirname ( pathname );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
1083c3: 83 ec 0c sub $0xc,%esp
1083c6: 6a 00 push $0x0
1083c8: 50 push %eax
1083c9: 6a 02 push $0x2
1083cb: ff 75 b4 pushl -0x4c(%ebp)
1083ce: ff 75 08 pushl 0x8(%ebp)
1083d1: e8 88 f2 ff ff call 10765e <rtems_filesystem_evaluate_path>
1083d6: 89 c2 mov %eax,%edx
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
1083d8: 83 c4 20 add $0x20,%esp
return -1;
1083db: 83 c8 ff or $0xffffffff,%eax
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
1083de: 85 d2 test %edx,%edx
1083e0: 0f 85 d6 00 00 00 jne 1084bc <rmdir+0x12c> <== NEVER TAKEN
return -1;
free_parentloc = true;
1083e6: b3 01 mov $0x1,%bl
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
1083e8: 8d 7d bc lea -0x44(%ebp),%edi
1083eb: 8d 75 d0 lea -0x30(%ebp),%esi
1083ee: b9 05 00 00 00 mov $0x5,%ecx
1083f3: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = pathname + parentpathlen;
1083f5: 8b 75 08 mov 0x8(%ebp),%esi
1083f8: 03 75 b4 add -0x4c(%ebp),%esi
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
1083fb: 83 c9 ff or $0xffffffff,%ecx
1083fe: 89 f7 mov %esi,%edi
108400: 31 c0 xor %eax,%eax
108402: f2 ae repnz scas %es:(%edi),%al
108404: f7 d1 not %ecx
108406: 49 dec %ecx
108407: 52 push %edx
108408: 52 push %edx
108409: 51 push %ecx
10840a: 56 push %esi
10840b: e8 ce f2 ff ff call 1076de <rtems_filesystem_prefix_separators>
108410: 01 c6 add %eax,%esi
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
108412: 83 c9 ff or $0xffffffff,%ecx
108415: 89 f7 mov %esi,%edi
108417: 31 c0 xor %eax,%eax
108419: f2 ae repnz scas %es:(%edi),%al
10841b: f7 d1 not %ecx
10841d: 49 dec %ecx
10841e: c7 04 24 00 00 00 00 movl $0x0,(%esp)
108425: 8d 7d bc lea -0x44(%ebp),%edi
108428: 57 push %edi
108429: 6a 00 push $0x0
10842b: 51 push %ecx
10842c: 56 push %esi
10842d: e8 ce f1 ff ff call 107600 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
108432: 83 c4 20 add $0x20,%esp
108435: 85 c0 test %eax,%eax
108437: 74 13 je 10844c <rmdir+0xbc>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
108439: 83 c8 ff or $0xffffffff,%eax
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
10843c: 84 db test %bl,%bl
10843e: 74 7c je 1084bc <rmdir+0x12c>
rtems_filesystem_freenode( &parentloc );
108440: 83 ec 0c sub $0xc,%esp
108443: 8d 55 d0 lea -0x30(%ebp),%edx
108446: 52 push %edx
108447: 89 45 b0 mov %eax,-0x50(%ebp)
10844a: eb 65 jmp 1084b1 <rmdir+0x121>
}
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
10844c: 83 ec 0c sub $0xc,%esp
10844f: 57 push %edi
108450: 8b 45 c8 mov -0x38(%ebp),%eax
108453: ff 50 10 call *0x10(%eax)
108456: 83 c4 10 add $0x10,%esp
108459: 48 dec %eax
10845a: 74 2f je 10848b <rmdir+0xfb>
rtems_filesystem_freenode( &loc );
10845c: 83 ec 0c sub $0xc,%esp
10845f: 57 push %edi
108460: e8 b7 f2 ff ff call 10771c <rtems_filesystem_freenode>
if ( free_parentloc )
108465: 83 c4 10 add $0x10,%esp
108468: 84 db test %bl,%bl
10846a: 74 0f je 10847b <rmdir+0xeb> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
10846c: 83 ec 0c sub $0xc,%esp
10846f: 8d 45 d0 lea -0x30(%ebp),%eax
108472: 50 push %eax
108473: e8 a4 f2 ff ff call 10771c <rtems_filesystem_freenode>
108478: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( ENOTDIR );
10847b: e8 cc 93 00 00 call 11184c <__errno>
108480: c7 00 14 00 00 00 movl $0x14,(%eax)
108486: 83 c8 ff or $0xffffffff,%eax
108489: eb 31 jmp 1084bc <rmdir+0x12c>
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
10848b: 50 push %eax
10848c: 50 push %eax
10848d: 57 push %edi
10848e: 8d 75 d0 lea -0x30(%ebp),%esi
108491: 56 push %esi
108492: 8b 45 c4 mov -0x3c(%ebp),%eax
108495: ff 50 34 call *0x34(%eax)
rtems_filesystem_freenode( &loc );
108498: 89 3c 24 mov %edi,(%esp)
10849b: 89 45 b0 mov %eax,-0x50(%ebp)
10849e: e8 79 f2 ff ff call 10771c <rtems_filesystem_freenode>
if ( free_parentloc )
1084a3: 83 c4 10 add $0x10,%esp
1084a6: 84 db test %bl,%bl
1084a8: 8b 45 b0 mov -0x50(%ebp),%eax
1084ab: 74 0f je 1084bc <rmdir+0x12c>
rtems_filesystem_freenode( &parentloc );
1084ad: 83 ec 0c sub $0xc,%esp
1084b0: 56 push %esi
1084b1: e8 66 f2 ff ff call 10771c <rtems_filesystem_freenode>
1084b6: 83 c4 10 add $0x10,%esp
1084b9: 8b 45 b0 mov -0x50(%ebp),%eax
return result;
}
1084bc: 8d 65 f4 lea -0xc(%ebp),%esp
1084bf: 5b pop %ebx
1084c0: 5e pop %esi
1084c1: 5f pop %edi
1084c2: c9 leave
1084c3: c3 ret
0010af11 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
10af11: 55 push %ebp
10af12: 89 e5 mov %esp,%ebp
10af14: 57 push %edi
10af15: 56 push %esi
10af16: 53 push %ebx
10af17: 83 ec 58 sub $0x58,%esp
10af1a: 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);
10af1d: 68 78 72 12 00 push $0x127278
10af22: e8 bd 08 00 00 call 10b7e4 <pthread_mutex_lock>
10af27: 89 45 b4 mov %eax,-0x4c(%ebp)
if (result != 0) {
10af2a: 83 c4 10 add $0x10,%esp
10af2d: 85 c0 test %eax,%eax
10af2f: 74 0e je 10af3f <rtems_aio_enqueue+0x2e><== ALWAYS TAKEN
free (req);
10af31: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10af34: 53 push %ebx <== NOT EXECUTED
10af35: e8 06 ce ff ff call 107d40 <free> <== NOT EXECUTED
10af3a: e9 bf 01 00 00 jmp 10b0fe <rtems_aio_enqueue+0x1ed><== 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);
10af3f: e8 a0 10 00 00 call 10bfe4 <pthread_self>
10af44: 57 push %edi
10af45: 8d 55 c4 lea -0x3c(%ebp),%edx
10af48: 52 push %edx
10af49: 8d 55 e0 lea -0x20(%ebp),%edx
10af4c: 52 push %edx
10af4d: 50 push %eax
10af4e: e8 95 0c 00 00 call 10bbe8 <pthread_getschedparam>
req->caller_thread = pthread_self ();
10af53: e8 8c 10 00 00 call 10bfe4 <pthread_self>
10af58: 89 43 10 mov %eax,0x10(%ebx)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
10af5b: 8b 43 14 mov 0x14(%ebx),%eax
10af5e: 8b 55 c4 mov -0x3c(%ebp),%edx
10af61: 2b 50 14 sub 0x14(%eax),%edx
10af64: 89 53 0c mov %edx,0xc(%ebx)
req->policy = policy;
10af67: 8b 55 e0 mov -0x20(%ebp),%edx
10af6a: 89 53 08 mov %edx,0x8(%ebx)
req->aiocbp->error_code = EINPROGRESS;
10af6d: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax)
req->aiocbp->return_value = 0;
10af74: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
if ((aio_request_queue.idle_threads == 0) &&
10af7b: 83 c4 10 add $0x10,%esp
10af7e: 83 3d e0 72 12 00 00 cmpl $0x0,0x1272e0
10af85: 0f 85 b7 00 00 00 jne 10b042 <rtems_aio_enqueue+0x131>
10af8b: 83 3d dc 72 12 00 04 cmpl $0x4,0x1272dc
10af92: 0f 8f aa 00 00 00 jg 10b042 <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);
10af98: 56 push %esi
10af99: 6a 01 push $0x1
10af9b: ff 30 pushl (%eax)
10af9d: 68 c0 72 12 00 push $0x1272c0
10afa2: e8 99 fb ff ff call 10ab40 <rtems_aio_search_fd>
10afa7: 89 c6 mov %eax,%esi
if (r_chain->new_fd == 1) {
10afa9: 83 c4 10 add $0x10,%esp
10afac: 83 78 18 01 cmpl $0x1,0x18(%eax)
10afb0: 8d 50 08 lea 0x8(%eax),%edx
10afb3: 8d 78 1c lea 0x1c(%eax),%edi
10afb6: 8d 40 20 lea 0x20(%eax),%eax
10afb9: 89 45 b0 mov %eax,-0x50(%ebp)
10afbc: 75 66 jne 10b024 <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);
10afbe: 51 push %ecx
10afbf: 51 push %ecx
10afc0: 53 push %ebx
10afc1: 52 push %edx
10afc2: e8 b5 1f 00 00 call 10cf7c <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
10afc7: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
pthread_mutex_init (&r_chain->mutex, NULL);
10afce: 5b pop %ebx
10afcf: 58 pop %eax
10afd0: 6a 00 push $0x0
10afd2: 57 push %edi
10afd3: e8 ec 06 00 00 call 10b6c4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10afd8: 5a pop %edx
10afd9: 59 pop %ecx
10afda: 6a 00 push $0x0
10afdc: ff 75 b0 pushl -0x50(%ebp)
10afdf: e8 a0 03 00 00 call 10b384 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
10afe4: 56 push %esi
10afe5: 68 eb ab 10 00 push $0x10abeb
10afea: 68 80 72 12 00 push $0x127280
10afef: 8d 45 e4 lea -0x1c(%ebp),%eax
10aff2: 50 push %eax
10aff3: e8 bc 09 00 00 call 10b9b4 <pthread_create>
10aff8: 89 c3 mov %eax,%ebx
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
10affa: 83 c4 20 add $0x20,%esp
10affd: 85 c0 test %eax,%eax
10afff: 74 18 je 10b019 <rtems_aio_enqueue+0x108><== ALWAYS TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
10b001: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b004: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10b009: e8 56 08 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10b00e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b011: 89 5d b4 mov %ebx,-0x4c(%ebp) <== NOT EXECUTED
10b014: e9 e8 00 00 00 jmp 10b101 <rtems_aio_enqueue+0x1f0><== NOT EXECUTED
}
++aio_request_queue.active_threads;
10b019: ff 05 dc 72 12 00 incl 0x1272dc
10b01f: e9 cd 00 00 00 jmp 10b0f1 <rtems_aio_enqueue+0x1e0>
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
10b024: 83 ec 0c sub $0xc,%esp
10b027: 57 push %edi
10b028: 89 55 ac mov %edx,-0x54(%ebp)
10b02b: e8 b4 07 00 00 call 10b7e4 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10b030: 5e pop %esi
10b031: 58 pop %eax
10b032: 53 push %ebx
10b033: 8b 55 ac mov -0x54(%ebp),%edx
10b036: 52 push %edx
10b037: e8 00 fe ff ff call 10ae3c <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10b03c: 5b pop %ebx
10b03d: ff 75 b0 pushl -0x50(%ebp)
10b040: eb 36 jmp 10b078 <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,
10b042: 51 push %ecx
10b043: 6a 00 push $0x0
10b045: ff 30 pushl (%eax)
10b047: 68 c0 72 12 00 push $0x1272c0
10b04c: e8 ef fa ff ff call 10ab40 <rtems_aio_search_fd>
10b051: 89 c6 mov %eax,%esi
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
10b053: 83 c4 10 add $0x10,%esp
10b056: 85 c0 test %eax,%eax
10b058: 74 2d je 10b087 <rtems_aio_enqueue+0x176><== ALWAYS TAKEN
{
pthread_mutex_lock (&r_chain->mutex);
10b05a: 8d 78 1c lea 0x1c(%eax),%edi <== NOT EXECUTED
10b05d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b060: 57 push %edi <== NOT EXECUTED
10b061: e8 7e 07 00 00 call 10b7e4 <pthread_mutex_lock> <== NOT EXECUTED
rtems_aio_insert_prio (&r_chain->perfd, req);
10b066: 58 pop %eax <== NOT EXECUTED
10b067: 5a pop %edx <== NOT EXECUTED
10b068: 53 push %ebx <== NOT EXECUTED
10b069: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED
10b06c: 50 push %eax <== NOT EXECUTED
10b06d: e8 ca fd ff ff call 10ae3c <rtems_aio_insert_prio> <== NOT EXECUTED
pthread_cond_signal (&r_chain->cond);
10b072: 83 c6 20 add $0x20,%esi <== NOT EXECUTED
10b075: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10b078: e8 a3 03 00 00 call 10b420 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
10b07d: 89 3c 24 mov %edi,(%esp)
10b080: e8 df 07 00 00 call 10b864 <pthread_mutex_unlock>
10b085: eb 67 jmp 10b0ee <rtems_aio_enqueue+0x1dd>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
10b087: 56 push %esi
10b088: 6a 01 push $0x1
10b08a: 8b 43 14 mov 0x14(%ebx),%eax
10b08d: ff 30 pushl (%eax)
10b08f: 68 cc 72 12 00 push $0x1272cc
10b094: e8 a7 fa ff ff call 10ab40 <rtems_aio_search_fd>
10b099: 89 c6 mov %eax,%esi
if (r_chain->new_fd == 1) {
10b09b: 83 c4 10 add $0x10,%esp
10b09e: 83 78 18 01 cmpl $0x1,0x18(%eax)
10b0a2: 8d 40 08 lea 0x8(%eax),%eax
10b0a5: 75 3e jne 10b0e5 <rtems_aio_enqueue+0x1d4>
10b0a7: 51 push %ecx
10b0a8: 51 push %ecx
10b0a9: 53 push %ebx
10b0aa: 50 push %eax
10b0ab: e8 cc 1e 00 00 call 10cf7c <_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;
10b0b0: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
pthread_mutex_init (&r_chain->mutex, NULL);
10b0b7: 58 pop %eax
10b0b8: 5a pop %edx
10b0b9: 6a 00 push $0x0
10b0bb: 8d 46 1c lea 0x1c(%esi),%eax
10b0be: 50 push %eax
10b0bf: e8 00 06 00 00 call 10b6c4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10b0c4: 5b pop %ebx
10b0c5: 5f pop %edi
10b0c6: 6a 00 push $0x0
10b0c8: 83 c6 20 add $0x20,%esi
10b0cb: 56 push %esi
10b0cc: e8 b3 02 00 00 call 10b384 <pthread_cond_init>
pthread_cond_signal (&aio_request_queue.new_req);
10b0d1: c7 04 24 7c 72 12 00 movl $0x12727c,(%esp)
10b0d8: e8 43 03 00 00 call 10b420 <pthread_cond_signal>
++aio_request_queue.idle_threads;
10b0dd: ff 05 e0 72 12 00 incl 0x1272e0
10b0e3: eb 09 jmp 10b0ee <rtems_aio_enqueue+0x1dd>
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
10b0e5: 51 push %ecx
10b0e6: 51 push %ecx
10b0e7: 53 push %ebx
10b0e8: 50 push %eax
10b0e9: e8 4e fd ff ff call 10ae3c <rtems_aio_insert_prio>
10b0ee: 83 c4 10 add $0x10,%esp
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
10b0f1: 83 ec 0c sub $0xc,%esp
10b0f4: 68 78 72 12 00 push $0x127278
10b0f9: e8 66 07 00 00 call 10b864 <pthread_mutex_unlock>
return 0;
10b0fe: 83 c4 10 add $0x10,%esp
}
10b101: 8b 45 b4 mov -0x4c(%ebp),%eax
10b104: 8d 65 f4 lea -0xc(%ebp),%esp
10b107: 5b pop %ebx
10b108: 5e pop %esi
10b109: 5f pop %edi
10b10a: c9 leave
10b10b: c3 ret
0010abeb <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
10abeb: 55 push %ebp <== NOT EXECUTED
10abec: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10abee: 57 push %edi <== NOT EXECUTED
10abef: 56 push %esi <== NOT EXECUTED
10abf0: 53 push %ebx <== NOT EXECUTED
10abf1: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED
rtems_aio_request_chain *r_chain = arg;
10abf4: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
/* 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);
10abf7: 8d 7b 1c lea 0x1c(%ebx),%edi <== NOT EXECUTED
10abfa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10abfd: 57 push %edi <== NOT EXECUTED
10abfe: e8 e1 0b 00 00 call 10b7e4 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
10ac03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ac06: 85 c0 test %eax,%eax <== NOT EXECUTED
10ac08: 0f 85 24 02 00 00 jne 10ae32 <rtems_aio_handle+0x247><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
10ac0e: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10ac11: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED
/* 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)) {
10ac14: 39 c6 cmp %eax,%esi <== NOT EXECUTED
10ac16: 0f 84 cc 00 00 00 je 10ace8 <rtems_aio_handle+0xfd> <== NOT EXECUTED
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);
10ac1c: e8 c3 13 00 00 call 10bfe4 <pthread_self> <== NOT EXECUTED
10ac21: 52 push %edx <== NOT EXECUTED
10ac22: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED
10ac25: 52 push %edx <== NOT EXECUTED
10ac26: 8d 4d e4 lea -0x1c(%ebp),%ecx <== NOT EXECUTED
10ac29: 51 push %ecx <== NOT EXECUTED
10ac2a: 50 push %eax <== NOT EXECUTED
10ac2b: e8 b8 0f 00 00 call 10bbe8 <pthread_getschedparam> <== NOT EXECUTED
param.sched_priority = req->priority;
10ac30: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED
10ac33: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED
pthread_setschedparam (pthread_self(), req->policy, ¶m);
10ac36: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED
10ac39: 89 55 b4 mov %edx,-0x4c(%ebp) <== NOT EXECUTED
10ac3c: e8 a3 13 00 00 call 10bfe4 <pthread_self> <== NOT EXECUTED
10ac41: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10ac44: 8d 4d c0 lea -0x40(%ebp),%ecx <== NOT EXECUTED
10ac47: 51 push %ecx <== NOT EXECUTED
10ac48: 8b 55 b4 mov -0x4c(%ebp),%edx <== NOT EXECUTED
10ac4b: 52 push %edx <== NOT EXECUTED
10ac4c: 50 push %eax <== NOT EXECUTED
10ac4d: e8 a2 13 00 00 call 10bff4 <pthread_setschedparam> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10ac52: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10ac55: e8 e6 22 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
10ac5a: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10ac5d: e8 02 0c 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
switch (req->aiocbp->aio_lio_opcode) {
10ac62: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED
10ac65: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ac68: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED
10ac6b: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED
10ac6e: 74 20 je 10ac90 <rtems_aio_handle+0xa5> <== NOT EXECUTED
10ac70: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
10ac73: 74 36 je 10acab <rtems_aio_handle+0xc0> <== NOT EXECUTED
10ac75: 4a dec %edx <== NOT EXECUTED
10ac76: 75 45 jne 10acbd <rtems_aio_handle+0xd2> <== NOT EXECUTED
case LIO_READ:
result = pread (req->aiocbp->aio_fildes,
10ac78: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ac7b: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
10ac7e: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED
10ac81: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED
10ac84: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
10ac87: ff 30 pushl (%eax) <== NOT EXECUTED
10ac89: e8 ea 93 00 00 call 114078 <pread> <== NOT EXECUTED
10ac8e: eb 16 jmp 10aca6 <rtems_aio_handle+0xbb> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
result = pwrite (req->aiocbp->aio_fildes,
10ac90: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ac93: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
10ac96: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED
10ac99: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED
10ac9c: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
10ac9f: ff 30 pushl (%eax) <== NOT EXECUTED
10aca1: e8 8a 94 00 00 call 114130 <pwrite> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10aca6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
10aca9: eb 0d jmp 10acb8 <rtems_aio_handle+0xcd> <== NOT EXECUTED
case LIO_SYNC:
result = fsync (req->aiocbp->aio_fildes);
10acab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10acae: ff 30 pushl (%eax) <== NOT EXECUTED
10acb0: e8 27 5c 00 00 call 1108dc <fsync> <== NOT EXECUTED
break;
10acb5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
10acb8: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED
10acbb: 75 19 jne 10acd6 <rtems_aio_handle+0xeb> <== NOT EXECUTED
req->aiocbp->return_value = -1;
10acbd: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED
10acc0: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED
req->aiocbp->error_code = errno;
10acc7: e8 70 89 00 00 call 11363c <__errno> <== NOT EXECUTED
10accc: 8b 00 mov (%eax),%eax <== NOT EXECUTED
10acce: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED
10acd1: e9 21 ff ff ff jmp 10abf7 <rtems_aio_handle+0xc> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
10acd6: 8b 56 14 mov 0x14(%esi),%edx <== NOT EXECUTED
10acd9: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED
req->aiocbp->error_code = 0;
10acdc: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED
10ace3: e9 0f ff ff ff jmp 10abf7 <rtems_aio_handle+0xc> <== NOT EXECUTED
wait for a signal on chain, this will unlock the queue.
The fd chain is already unlocked */
struct timespec timeout;
pthread_mutex_unlock (&r_chain->mutex);
10ace8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aceb: 57 push %edi <== NOT EXECUTED
10acec: e8 73 0b 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
10acf1: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED
10acf8: e8 e7 0a 00 00 call 10b7e4 <pthread_mutex_lock> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
10acfd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ad00: 39 73 08 cmp %esi,0x8(%ebx) <== NOT EXECUTED
10ad03: 0f 85 ee fe ff ff jne 10abf7 <rtems_aio_handle+0xc> <== NOT EXECUTED
{
clock_gettime (CLOCK_REALTIME, &timeout);
10ad09: 56 push %esi <== NOT EXECUTED
10ad0a: 56 push %esi <== NOT EXECUTED
10ad0b: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED
10ad0e: 50 push %eax <== NOT EXECUTED
10ad0f: 6a 01 push $0x1 <== NOT EXECUTED
10ad11: e8 5e 05 00 00 call 10b274 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
10ad16: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED
timeout.tv_nsec = 0;
10ad1a: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
result = pthread_cond_timedwait (&r_chain->cond,
10ad21: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED
10ad24: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10ad27: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED
10ad2a: 52 push %edx <== NOT EXECUTED
10ad2b: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10ad30: 56 push %esi <== NOT EXECUTED
10ad31: e8 5a 07 00 00 call 10b490 <pthread_cond_timedwait><== NOT EXECUTED
&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) {
10ad36: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ad39: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED
10ad3c: 0f 85 b5 fe ff ff jne 10abf7 <rtems_aio_handle+0xc> <== NOT EXECUTED
10ad42: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ad45: 53 push %ebx <== NOT EXECUTED
10ad46: e8 f5 21 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
10ad4b: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10ad4e: e8 71 08 00 00 call 10b5c4 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
10ad53: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10ad56: e8 75 05 00 00 call 10b2d0 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
10ad5b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10ad5e: e8 dd cf ff ff call 107d40 <free> <== NOT EXECUTED
/* 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)) {
10ad63: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ad66: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED
10ad6d: 72 12 00
10ad70: 0f 85 a7 00 00 00 jne 10ae1d <rtems_aio_handle+0x232><== NOT EXECUTED
++aio_request_queue.idle_threads;
10ad76: ff 05 e0 72 12 00 incl 0x1272e0 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
10ad7c: 53 push %ebx <== NOT EXECUTED
10ad7d: 53 push %ebx <== NOT EXECUTED
10ad7e: 8d 4d dc lea -0x24(%ebp),%ecx <== NOT EXECUTED
10ad81: 51 push %ecx <== NOT EXECUTED
10ad82: 6a 01 push $0x1 <== NOT EXECUTED
10ad84: e8 eb 04 00 00 call 10b274 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
10ad89: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED
timeout.tv_nsec = 0;
10ad8d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
result = pthread_cond_timedwait (&aio_request_queue.new_req,
10ad94: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10ad97: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED
10ad9a: 50 push %eax <== NOT EXECUTED
10ad9b: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10ada0: 68 7c 72 12 00 push $0x12727c <== NOT EXECUTED
10ada5: e8 e6 06 00 00 call 10b490 <pthread_cond_timedwait><== NOT EXECUTED
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
10adaa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10adad: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED
10adb0: 75 12 jne 10adc4 <rtems_aio_handle+0x1d9><== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
10adb2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10adb5: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10adba: e8 a5 0a 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return NULL;
10adbf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10adc2: eb 6e jmp 10ae32 <rtems_aio_handle+0x247><== NOT EXECUTED
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
--aio_request_queue.idle_threads;
10adc4: ff 0d e0 72 12 00 decl 0x1272e0 <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10adca: 8b 35 cc 72 12 00 mov 0x1272cc,%esi <== NOT EXECUTED
10add0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10add3: 56 push %esi <== NOT EXECUTED
10add4: e8 67 21 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED
/* Otherwise move this chain to the working chain and
start the loop all over again */
--aio_request_queue.idle_threads;
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
10add9: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10addc: 6a 01 push $0x1 <== NOT EXECUTED
10adde: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED
10ade1: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED
10ade6: e8 55 fd ff ff call 10ab40 <rtems_aio_search_fd> <== NOT EXECUTED
10adeb: 89 c3 mov %eax,%ebx <== NOT EXECUTED
((rtems_aio_request_chain *)node)->fildes,
1);
r_chain->new_fd = 0;
10aded: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
10adf4: 5a pop %edx <== NOT EXECUTED
10adf5: 59 pop %ecx <== NOT EXECUTED
10adf6: 6a 00 push $0x0 <== NOT EXECUTED
10adf8: 8d 40 1c lea 0x1c(%eax),%eax <== NOT EXECUTED
10adfb: 50 push %eax <== NOT EXECUTED
10adfc: e8 c3 08 00 00 call 10b6c4 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
10ae01: 5f pop %edi <== NOT EXECUTED
10ae02: 58 pop %eax <== NOT EXECUTED
10ae03: 6a 00 push $0x0 <== NOT EXECUTED
10ae05: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED
10ae08: 50 push %eax <== NOT EXECUTED
10ae09: e8 76 05 00 00 call 10b384 <pthread_cond_init> <== NOT EXECUTED
r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd;
10ae0e: 8d 7b 08 lea 0x8(%ebx),%edi <== NOT EXECUTED
10ae11: 83 c6 08 add $0x8,%esi <== NOT EXECUTED
10ae14: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED
10ae19: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
10ae1b: eb 0d jmp 10ae2a <rtems_aio_handle+0x23f><== NOT EXECUTED
}
else
/* 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);
10ae1d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ae20: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10ae25: e8 3a 0a 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
10ae2a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ae2d: e9 c5 fd ff ff jmp 10abf7 <rtems_aio_handle+0xc> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae32: 31 c0 xor %eax,%eax <== NOT EXECUTED
10ae34: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10ae37: 5b pop %ebx <== NOT EXECUTED
10ae38: 5e pop %esi <== NOT EXECUTED
10ae39: 5f pop %edi <== NOT EXECUTED
10ae3a: c9 leave <== NOT EXECUTED
10ae3b: c3 ret <== NOT EXECUTED
0010aa44 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
10aa44: 55 push %ebp
10aa45: 89 e5 mov %esp,%ebp
10aa47: 53 push %ebx
10aa48: 83 ec 10 sub $0x10,%esp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
10aa4b: 68 80 72 12 00 push $0x127280
10aa50: e8 13 0f 00 00 call 10b968 <pthread_attr_init>
10aa55: 89 c3 mov %eax,%ebx
if (result != 0)
10aa57: 83 c4 10 add $0x10,%esp
10aa5a: 85 c0 test %eax,%eax
10aa5c: 0f 85 d7 00 00 00 jne 10ab39 <rtems_aio_init+0xf5> <== NEVER TAKEN
return result;
result =
10aa62: 51 push %ecx
10aa63: 51 push %ecx
10aa64: 6a 00 push $0x0
10aa66: 68 80 72 12 00 push $0x127280
10aa6b: e8 20 0f 00 00 call 10b990 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
10aa70: 83 c4 10 add $0x10,%esp
10aa73: 85 c0 test %eax,%eax
10aa75: 74 10 je 10aa87 <rtems_aio_init+0x43> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
10aa77: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa7a: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED
10aa7f: e8 c4 0e 00 00 call 10b948 <pthread_attr_destroy> <== NOT EXECUTED
10aa84: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
10aa87: 52 push %edx
10aa88: 52 push %edx
10aa89: 6a 00 push $0x0
10aa8b: 68 78 72 12 00 push $0x127278
10aa90: e8 2f 0c 00 00 call 10b6c4 <pthread_mutex_init>
if (result != 0)
10aa95: 83 c4 10 add $0x10,%esp
10aa98: 85 c0 test %eax,%eax
10aa9a: 74 10 je 10aaac <rtems_aio_init+0x68> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
10aa9c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa9f: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED
10aaa4: e8 9f 0e 00 00 call 10b948 <pthread_attr_destroy> <== NOT EXECUTED
10aaa9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
10aaac: 50 push %eax
10aaad: 50 push %eax
10aaae: 6a 00 push $0x0
10aab0: 68 7c 72 12 00 push $0x12727c
10aab5: e8 ca 08 00 00 call 10b384 <pthread_cond_init>
10aaba: 89 c3 mov %eax,%ebx
if (result != 0) {
10aabc: 83 c4 10 add $0x10,%esp
10aabf: 85 c0 test %eax,%eax
10aac1: 74 1c je 10aadf <rtems_aio_init+0x9b> <== ALWAYS TAKEN
pthread_mutex_destroy (&aio_request_queue.mutex);
10aac3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aac6: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10aacb: e8 f4 0a 00 00 call 10b5c4 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
10aad0: c7 04 24 80 72 12 00 movl $0x127280,(%esp) <== NOT EXECUTED
10aad7: e8 6c 0e 00 00 call 10b948 <pthread_attr_destroy> <== NOT EXECUTED
10aadc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
10aadf: c7 05 c0 72 12 00 c4 movl $0x1272c4,0x1272c0
10aae6: 72 12 00
the_chain->permanent_null = NULL;
10aae9: c7 05 c4 72 12 00 00 movl $0x0,0x1272c4
10aaf0: 00 00 00
the_chain->last = _Chain_Head(the_chain);
10aaf3: c7 05 c8 72 12 00 c0 movl $0x1272c0,0x1272c8
10aafa: 72 12 00
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
10aafd: c7 05 cc 72 12 00 d0 movl $0x1272d0,0x1272cc
10ab04: 72 12 00
the_chain->permanent_null = NULL;
10ab07: c7 05 d0 72 12 00 00 movl $0x0,0x1272d0
10ab0e: 00 00 00
the_chain->last = _Chain_Head(the_chain);
10ab11: c7 05 d4 72 12 00 cc movl $0x1272cc,0x1272d4
10ab18: 72 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;
10ab1b: c7 05 dc 72 12 00 00 movl $0x0,0x1272dc
10ab22: 00 00 00
aio_request_queue.idle_threads = 0;
10ab25: c7 05 e0 72 12 00 00 movl $0x0,0x1272e0
10ab2c: 00 00 00
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
10ab2f: c7 05 d8 72 12 00 0b movl $0xb00b,0x1272d8
10ab36: b0 00 00
return result;
}
10ab39: 89 d8 mov %ebx,%eax
10ab3b: 8b 5d fc mov -0x4(%ebp),%ebx
10ab3e: c9 leave
10ab3f: c3 ret
0010ae3c <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
10ae3c: 55 push %ebp
10ae3d: 89 e5 mov %esp,%ebp
10ae3f: 56 push %esi
10ae40: 53 push %ebx
10ae41: 8b 4d 08 mov 0x8(%ebp),%ecx
10ae44: 8b 55 0c mov 0xc(%ebp),%edx
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae47: 8b 01 mov (%ecx),%eax
10ae49: 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)) {
10ae4c: 39 d8 cmp %ebx,%eax
10ae4e: 74 27 je 10ae77 <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;
10ae50: 8b 48 14 mov 0x14(%eax),%ecx
10ae53: 8b 49 14 mov 0x14(%ecx),%ecx
while (req->aiocbp->aio_reqprio > prio &&
10ae56: 8b 72 14 mov 0x14(%edx),%esi
10ae59: 8b 76 14 mov 0x14(%esi),%esi
10ae5c: eb 08 jmp 10ae66 <rtems_aio_insert_prio+0x2a>
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae5e: 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;
10ae60: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED
10ae63: 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 &&
10ae66: 39 ce cmp %ecx,%esi
10ae68: 7e 04 jle 10ae6e <rtems_aio_insert_prio+0x32><== ALWAYS TAKEN
10ae6a: 39 d8 cmp %ebx,%eax <== NOT EXECUTED
10ae6c: 75 f0 jne 10ae5e <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 );
10ae6e: 89 55 0c mov %edx,0xc(%ebp)
10ae71: 8b 40 04 mov 0x4(%eax),%eax
10ae74: 89 45 08 mov %eax,0x8(%ebp)
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
10ae77: 5b pop %ebx
10ae78: 5e pop %esi
10ae79: c9 leave
10ae7a: e9 fd 20 00 00 jmp 10cf7c <_Chain_Insert>
0010ae7f <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
10ae7f: 55 push %ebp <== NOT EXECUTED
10ae80: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10ae82: 56 push %esi <== NOT EXECUTED
10ae83: 53 push %ebx <== NOT EXECUTED
10ae84: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae87: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED
10ae8a: 8d 70 0c lea 0xc(%eax),%esi <== NOT EXECUTED
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
10ae8d: eb 25 jmp 10aeb4 <rtems_aio_remove_fd+0x35><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10ae8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ae92: 53 push %ebx <== NOT EXECUTED
10ae93: e8 a8 20 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
10ae98: 8b 53 14 mov 0x14(%ebx),%edx <== NOT EXECUTED
10ae9b: c7 42 30 8c 00 00 00 movl $0x8c,0x30(%edx) <== NOT EXECUTED
req->aiocbp->return_value = -1;
10aea2: c7 42 34 ff ff ff ff movl $0xffffffff,0x34(%edx) <== NOT EXECUTED
free (req);
10aea9: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10aeac: e8 8f ce ff ff call 107d40 <free> <== NOT EXECUTED
10aeb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
10aeb4: 39 f3 cmp %esi,%ebx <== NOT EXECUTED
10aeb6: 75 d7 jne 10ae8f <rtems_aio_remove_fd+0x10><== NOT EXECUTED
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
}
}
10aeb8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10aebb: 5b pop %ebx <== NOT EXECUTED
10aebc: 5e pop %esi <== NOT EXECUTED
10aebd: c9 leave <== NOT EXECUTED
10aebe: c3 ret <== NOT EXECUTED
0010aebf <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)
{
10aebf: 55 push %ebp <== NOT EXECUTED
10aec0: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10aec2: 53 push %ebx <== NOT EXECUTED
10aec3: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED
10aec6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10aec9: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aecc: 8b 18 mov (%eax),%ebx <== NOT EXECUTED
10aece: 83 c0 04 add $0x4,%eax <== 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) {
10aed1: eb 02 jmp 10aed5 <rtems_aio_remove_req+0x16><== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aed3: 8b 1b mov (%ebx),%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) {
10aed5: 39 c3 cmp %eax,%ebx <== NOT EXECUTED
10aed7: 74 2e je 10af07 <rtems_aio_remove_req+0x48><== NOT EXECUTED
10aed9: 39 53 14 cmp %edx,0x14(%ebx) <== NOT EXECUTED
10aedc: 75 f5 jne 10aed3 <rtems_aio_remove_req+0x14><== NOT EXECUTED
10aede: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aee1: 53 push %ebx <== NOT EXECUTED
10aee2: e8 59 20 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
10aee7: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED
10aeea: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) <== NOT EXECUTED
current->aiocbp->return_value = -1;
10aef1: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) <== NOT EXECUTED
free (current);
10aef8: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10aefb: e8 40 ce ff ff call 107d40 <free> <== NOT EXECUTED
}
return AIO_CANCELED;
10af00: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10af03: 31 c0 xor %eax,%eax <== NOT EXECUTED
10af05: eb 05 jmp 10af0c <rtems_aio_remove_req+0x4d><== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
10af07: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10af0c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10af0f: c9 leave <== NOT EXECUTED
10af10: c3 ret <== NOT EXECUTED
0010aaa8 <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10aaa8: 55 push %ebp
10aaa9: 89 e5 mov %esp,%ebp
10aaab: 56 push %esi
10aaac: 53 push %ebx
10aaad: 8b 5d 10 mov 0x10(%ebp),%ebx
10aab0: 8b 75 14 mov 0x14(%ebp),%esi
RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Append_with_empty_check( chain, node );
10aab3: 50 push %eax
10aab4: 50 push %eax
10aab5: ff 75 0c pushl 0xc(%ebp)
10aab8: ff 75 08 pushl 0x8(%ebp)
10aabb: e8 88 04 00 00 call 10af48 <_Chain_Append_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
10aac0: 83 c4 10 add $0x10,%esp
10aac3: 84 c0 test %al,%al
10aac5: 74 11 je 10aad8 <rtems_chain_append_with_notification+0x30><== NEVER TAKEN
sc = rtems_event_send( task, events );
10aac7: 89 75 0c mov %esi,0xc(%ebp)
10aaca: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10aacd: 8d 65 f8 lea -0x8(%ebp),%esp
10aad0: 5b pop %ebx
10aad1: 5e pop %esi
10aad2: c9 leave
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
sc = rtems_event_send( task, events );
10aad3: e9 d4 f6 ff ff jmp 10a1ac <rtems_event_send>
}
return sc;
}
10aad8: 31 c0 xor %eax,%eax
10aada: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10aadd: 5b pop %ebx <== NOT EXECUTED
10aade: 5e pop %esi <== NOT EXECUTED
10aadf: c9 leave <== NOT EXECUTED
10aae0: c3 ret <== NOT EXECUTED
0010ab20 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
10ab20: 55 push %ebp
10ab21: 89 e5 mov %esp,%ebp
10ab23: 57 push %edi
10ab24: 56 push %esi
10ab25: 53 push %ebx
10ab26: 83 ec 1c sub $0x1c,%esp
10ab29: 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(
10ab2c: 8d 75 e4 lea -0x1c(%ebp),%esi
10ab2f: eb 13 jmp 10ab44 <rtems_chain_get_with_wait+0x24>
10ab31: 56 push %esi
10ab32: ff 75 10 pushl 0x10(%ebp)
10ab35: 6a 00 push $0x0
10ab37: 57 push %edi
10ab38: e8 0f f5 ff ff call 10a04c <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
10ab3d: 83 c4 10 add $0x10,%esp
10ab40: 85 c0 test %eax,%eax
10ab42: 75 16 jne 10ab5a <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 );
10ab44: 83 ec 0c sub $0xc,%esp
10ab47: ff 75 08 pushl 0x8(%ebp)
10ab4a: e8 99 04 00 00 call 10afe8 <_Chain_Get>
10ab4f: 89 c3 mov %eax,%ebx
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10ab51: 83 c4 10 add $0x10,%esp
10ab54: 85 c0 test %eax,%eax
10ab56: 74 d9 je 10ab31 <rtems_chain_get_with_wait+0x11>
10ab58: 31 c0 xor %eax,%eax
timeout,
&out
);
}
*node_ptr = node;
10ab5a: 8b 55 14 mov 0x14(%ebp),%edx
10ab5d: 89 1a mov %ebx,(%edx)
return sc;
}
10ab5f: 8d 65 f4 lea -0xc(%ebp),%esp
10ab62: 5b pop %ebx
10ab63: 5e pop %esi
10ab64: 5f pop %edi
10ab65: c9 leave
10ab66: c3 ret
0010ab68 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10ab68: 55 push %ebp
10ab69: 89 e5 mov %esp,%ebp
10ab6b: 56 push %esi
10ab6c: 53 push %ebx
10ab6d: 8b 5d 10 mov 0x10(%ebp),%ebx
10ab70: 8b 75 14 mov 0x14(%ebp),%esi
RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Prepend_with_empty_check( chain, node );
10ab73: 50 push %eax
10ab74: 50 push %eax
10ab75: ff 75 0c pushl 0xc(%ebp)
10ab78: ff 75 08 pushl 0x8(%ebp)
10ab7b: e8 ac 04 00 00 call 10b02c <_Chain_Prepend_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
10ab80: 83 c4 10 add $0x10,%esp
10ab83: 84 c0 test %al,%al
10ab85: 74 11 je 10ab98 <rtems_chain_prepend_with_notification+0x30><== NEVER TAKEN
sc = rtems_event_send( task, events );
10ab87: 89 75 0c mov %esi,0xc(%ebp)
10ab8a: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10ab8d: 8d 65 f8 lea -0x8(%ebp),%esp
10ab90: 5b pop %ebx
10ab91: 5e pop %esi
10ab92: c9 leave
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
sc = rtems_event_send( task, events );
10ab93: e9 14 f6 ff ff jmp 10a1ac <rtems_event_send>
}
return sc;
}
10ab98: 31 c0 xor %eax,%eax
10ab9a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10ab9d: 5b pop %ebx <== NOT EXECUTED
10ab9e: 5e pop %esi <== NOT EXECUTED
10ab9f: c9 leave <== NOT EXECUTED
10aba0: c3 ret <== NOT EXECUTED
001076a8 <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
1076a8: 55 push %ebp
1076a9: 89 e5 mov %esp,%ebp
1076ab: 57 push %edi
1076ac: 56 push %esi
1076ad: 53 push %ebx
1076ae: 83 ec 6c sub $0x6c,%esp
1076b1: 8b 7d 08 mov 0x8(%ebp),%edi
Timestamp_Control uptime, total, ran;
#else
uint32_t total_units = 0;
#endif
if ( !print )
1076b4: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
1076b8: 0f 84 44 01 00 00 je 107802 <rtems_cpu_usage_report_with_plugin+0x15a><== 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__
_TOD_Get_uptime( &uptime );
1076be: 83 ec 0c sub $0xc,%esp
1076c1: 8d 5d d8 lea -0x28(%ebp),%ebx
1076c4: 53 push %ebx
1076c5: e8 6e 4b 00 00 call 10c238 <_TOD_Get_uptime>
_Timestamp_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total );
1076ca: 83 c4 0c add $0xc,%esp
1076cd: 8d 75 d0 lea -0x30(%ebp),%esi
1076d0: 56 push %esi
1076d1: 53 push %ebx
1076d2: 68 a8 06 13 00 push $0x1306a8
1076d7: e8 2c 6b 00 00 call 10e208 <_Timespec_Subtract>
}
}
}
#endif
(*print)(
1076dc: 5b pop %ebx
1076dd: 5e pop %esi
1076de: 68 35 0b 12 00 push $0x120b35
1076e3: 57 push %edi
1076e4: ff 55 0c call *0xc(%ebp)
1076e7: 83 c4 10 add $0x10,%esp
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
1076ea: bb 01 00 00 00 mov $0x1,%ebx
#if defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
1076ef: 8b 04 9d e0 00 13 00 mov 0x1300e0(,%ebx,4),%eax
1076f6: 8b 70 04 mov 0x4(%eax),%esi
if ( information ) {
1076f9: 85 f6 test %esi,%esi
1076fb: 0f 84 db 00 00 00 je 1077dc <rtems_cpu_usage_report_with_plugin+0x134><== NEVER TAKEN
107701: c7 45 a4 01 00 00 00 movl $0x1,-0x5c(%ebp)
107708: 89 5d 94 mov %ebx,-0x6c(%ebp)
10770b: e9 bc 00 00 00 jmp 1077cc <rtems_cpu_usage_report_with_plugin+0x124>
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
107710: 8b 46 1c mov 0x1c(%esi),%eax
107713: 8b 4d a4 mov -0x5c(%ebp),%ecx
107716: 8b 14 88 mov (%eax,%ecx,4),%edx
if ( !the_thread )
107719: 85 d2 test %edx,%edx
10771b: 0f 84 a8 00 00 00 je 1077c9 <rtems_cpu_usage_report_with_plugin+0x121><== NEVER TAKEN
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
107721: 51 push %ecx
107722: 8d 5d b3 lea -0x4d(%ebp),%ebx
107725: 53 push %ebx
107726: 6a 0d push $0xd
107728: ff 72 08 pushl 0x8(%edx)
10772b: 89 55 a0 mov %edx,-0x60(%ebp)
10772e: e8 95 39 00 00 call 10b0c8 <rtems_object_get_name>
(*print)(
107733: 53 push %ebx
107734: 8b 55 a0 mov -0x60(%ebp),%edx
107737: ff 72 08 pushl 0x8(%edx)
10773a: 68 a7 0c 12 00 push $0x120ca7
10773f: 57 push %edi
107740: 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;
107743: 8b 55 a0 mov -0x60(%ebp),%edx
107746: 8b 8a 84 00 00 00 mov 0x84(%edx),%ecx
10774c: 8b 9a 88 00 00 00 mov 0x88(%edx),%ebx
107752: 89 4d c8 mov %ecx,-0x38(%ebp)
107755: 89 5d cc mov %ebx,-0x34(%ebp)
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
107758: 83 c4 20 add $0x20,%esp
10775b: a1 98 06 13 00 mov 0x130698,%eax
107760: 8b 5a 08 mov 0x8(%edx),%ebx
107763: 39 58 08 cmp %ebx,0x8(%eax)
107766: 75 28 jne 107790 <rtems_cpu_usage_report_with_plugin+0xe8>
Timestamp_Control used;
_Timestamp_Subtract(
107768: 50 push %eax
107769: 8d 45 c0 lea -0x40(%ebp),%eax
10776c: 50 push %eax
10776d: 8d 55 d8 lea -0x28(%ebp),%edx
107770: 52 push %edx
107771: 68 bc 01 13 00 push $0x1301bc
107776: 89 45 a0 mov %eax,-0x60(%ebp)
107779: e8 8a 6a 00 00 call 10e208 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch, &uptime, &used
);
_Timestamp_Add_to( &ran, &used );
10777e: 59 pop %ecx
10777f: 5b pop %ebx
107780: 8b 45 a0 mov -0x60(%ebp),%eax
107783: 50 push %eax
107784: 8d 45 c8 lea -0x38(%ebp),%eax
107787: 50 push %eax
107788: e8 8f 69 00 00 call 10e11c <_Timespec_Add_to>
10778d: 83 c4 10 add $0x10,%esp
};
_Timestamp_Divide( &ran, &total, &ival, &fval );
107790: 8d 4d e0 lea -0x20(%ebp),%ecx
107793: 51 push %ecx
107794: 8d 5d e4 lea -0x1c(%ebp),%ebx
107797: 53 push %ebx
107798: 8d 45 d0 lea -0x30(%ebp),%eax
10779b: 50 push %eax
10779c: 8d 4d c8 lea -0x38(%ebp),%ecx
10779f: 51 push %ecx
1077a0: e8 a7 69 00 00 call 10e14c <_Timespec_Divide>
/*
* Print the information
*/
(*print)( context,
1077a5: 58 pop %eax
1077a6: 5a pop %edx
1077a7: ff 75 e0 pushl -0x20(%ebp)
1077aa: ff 75 e4 pushl -0x1c(%ebp)
1077ad: 8b 45 cc mov -0x34(%ebp),%eax
1077b0: b9 e8 03 00 00 mov $0x3e8,%ecx
1077b5: 31 d2 xor %edx,%edx
1077b7: f7 f1 div %ecx
1077b9: 50 push %eax
1077ba: ff 75 c8 pushl -0x38(%ebp)
1077bd: 68 ba 0c 12 00 push $0x120cba
1077c2: 57 push %edi
1077c3: ff 55 0c call *0xc(%ebp)
1077c6: 83 c4 20 add $0x20,%esp
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
1077c9: ff 45 a4 incl -0x5c(%ebp)
1077cc: 0f b7 46 10 movzwl 0x10(%esi),%eax
1077d0: 39 45 a4 cmp %eax,-0x5c(%ebp)
1077d3: 0f 86 37 ff ff ff jbe 107710 <rtems_cpu_usage_report_with_plugin+0x68>
1077d9: 8b 5d 94 mov -0x6c(%ebp),%ebx
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
1077dc: 43 inc %ebx
1077dd: 83 fb 04 cmp $0x4,%ebx
1077e0: 0f 85 09 ff ff ff jne 1076ef <rtems_cpu_usage_report_with_plugin+0x47>
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
1077e6: 8b 45 d4 mov -0x2c(%ebp),%eax
1077e9: b9 e8 03 00 00 mov $0x3e8,%ecx
1077ee: 31 d2 xor %edx,%edx
1077f0: f7 f1 div %ecx
1077f2: 50 push %eax
1077f3: ff 75 d0 pushl -0x30(%ebp)
1077f6: 68 d2 0c 12 00 push $0x120cd2
1077fb: 57 push %edi
1077fc: ff 55 0c call *0xc(%ebp)
1077ff: 83 c4 10 add $0x10,%esp
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
107802: 8d 65 f4 lea -0xc(%ebp),%esp
107805: 5b pop %ebx
107806: 5e pop %esi
107807: 5f pop %edi
107808: c9 leave
107809: c3 ret
0011102c <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
11102c: 55 push %ebp
11102d: 89 e5 mov %esp,%ebp
11102f: 53 push %ebx
111030: 83 ec 04 sub $0x4,%esp
111033: 8b 55 08 mov 0x8(%ebp),%edx
if (sc == RTEMS_SUCCESSFUL) {
return 0;
111036: 31 c0 xor %eax,%eax
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
111038: 85 d2 test %edx,%edx
11103a: 74 1b je 111057 <rtems_deviceio_errno+0x2b>
return 0;
} else {
int eno = EINVAL;
11103c: bb 16 00 00 00 mov $0x16,%ebx
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
111041: 83 fa 1c cmp $0x1c,%edx
111044: 77 07 ja 11104d <rtems_deviceio_errno+0x21><== NEVER TAKEN
eno = status_code_to_errno [sc];
111046: 8b 1c 95 b8 ed 11 00 mov 0x11edb8(,%edx,4),%ebx
}
errno = eno;
11104d: e8 5a 00 00 00 call 1110ac <__errno>
111052: 89 18 mov %ebx,(%eax)
return -1;
111054: 83 c8 ff or $0xffffffff,%eax
}
}
111057: 5a pop %edx
111058: 5b pop %ebx
111059: c9 leave
11105a: c3 ret
0010e327 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
10e327: 55 push %ebp
10e328: 89 e5 mov %esp,%ebp
10e32a: 83 ec 18 sub $0x18,%esp
10e32d: 8b 45 08 mov 0x8(%ebp),%eax
find_arg fa = {
10e330: 89 45 f0 mov %eax,-0x10(%ebp)
10e333: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
10e33a: 85 c0 test %eax,%eax
10e33c: 74 13 je 10e351 <rtems_filesystem_get_mount_handler+0x2a><== NEVER TAKEN
rtems_filesystem_iterate( find_handler, &fa );
10e33e: 50 push %eax
10e33f: 50 push %eax
10e340: 8d 45 f0 lea -0x10(%ebp),%eax
10e343: 50 push %eax
10e344: 68 50 e2 10 00 push $0x10e250
10e349: e8 62 ff ff ff call 10e2b0 <rtems_filesystem_iterate>
10e34e: 83 c4 10 add $0x10,%esp
}
return fa.mount_h;
}
10e351: 8b 45 f4 mov -0xc(%ebp),%eax
10e354: c9 leave
10e355: c3 ret
001070fc <rtems_filesystem_initialize>:
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
1070fc: 55 push %ebp
1070fd: 89 e5 mov %esp,%ebp
1070ff: 57 push %edi
107100: 56 push %esi
107101: 53 push %ebx
107102: 83 ec 2c sub $0x2c,%esp
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
107105: a1 50 20 12 00 mov 0x122050,%eax
10710a: c7 40 2c 12 00 00 00 movl $0x12,0x2c(%eax)
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
107111: 83 3d 80 ce 11 00 00 cmpl $0x0,0x11ce80
107118: 75 0a jne 107124 <rtems_filesystem_initialize+0x28><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0001 );
10711a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10711d: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED
107122: eb 28 jmp 10714c <rtems_filesystem_initialize+0x50><== NOT EXECUTED
mt = &rtems_filesystem_mount_table[0];
107124: a1 4c 01 12 00 mov 0x12014c,%eax
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
107129: 83 ec 0c sub $0xc,%esp
10712c: 6a 00 push $0x0
10712e: ff 70 04 pushl 0x4(%eax)
107131: ff 30 pushl (%eax)
107133: ff 70 0c pushl 0xc(%eax)
107136: ff 70 08 pushl 0x8(%eax)
107139: e8 77 06 00 00 call 1077b5 <mount>
if ( status == -1 )
10713e: 83 c4 20 add $0x20,%esp
107141: 40 inc %eax
107142: 75 0d jne 107151 <rtems_filesystem_initialize+0x55><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0002 );
107144: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107147: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED
10714c: e8 db 35 00 00 call 10a72c <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_filesystem_link_counts = 0;
107151: a1 50 20 12 00 mov 0x122050,%eax
107156: 66 c7 40 30 00 00 movw $0x0,0x30(%eax)
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
10715c: 83 ec 0c sub $0xc,%esp
10715f: 6a 00 push $0x0
107161: 8d 5d d4 lea -0x2c(%ebp),%ebx
107164: 53 push %ebx
107165: 6a 00 push $0x0
107167: 6a 01 push $0x1
107169: 68 d4 e5 11 00 push $0x11e5d4
10716e: e8 03 01 00 00 call 107276 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
107173: 8b 3d 50 20 12 00 mov 0x122050,%edi
107179: 83 c7 18 add $0x18,%edi
10717c: b9 05 00 00 00 mov $0x5,%ecx
107181: 89 de mov %ebx,%esi
107183: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
107185: 83 c4 14 add $0x14,%esp
107188: 6a 00 push $0x0
10718a: 53 push %ebx
10718b: 6a 00 push $0x0
10718d: 6a 01 push $0x1
10718f: 68 d4 e5 11 00 push $0x11e5d4
107194: e8 dd 00 00 00 call 107276 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
107199: 8b 3d 50 20 12 00 mov 0x122050,%edi
10719f: 83 c7 04 add $0x4,%edi
1071a2: b9 05 00 00 00 mov $0x5,%ecx
1071a7: 89 de mov %ebx,%esi
1071a9: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
1071ab: 83 c4 18 add $0x18,%esp
1071ae: 68 ff 01 00 00 push $0x1ff
1071b3: 68 d6 e5 11 00 push $0x11e5d6
1071b8: e8 c3 04 00 00 call 107680 <mkdir>
if ( status != 0 )
1071bd: 83 c4 10 add $0x10,%esp
1071c0: 85 c0 test %eax,%eax
1071c2: 74 0d je 1071d1 <rtems_filesystem_initialize+0xd5><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0003 );
1071c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1071c7: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED
1071cc: e9 7b ff ff ff jmp 10714c <rtems_filesystem_initialize+0x50><== NOT EXECUTED
* it will be mounted onto is created. Moreover, if it is going to
* use a device, then it is REALLY unfair to attempt this
* before device drivers are initialized. So we return via a base
* filesystem image and nothing auto-mounted at this point.
*/
}
1071d1: 8d 65 f4 lea -0xc(%ebp),%esp
1071d4: 5b pop %ebx
1071d5: 5e pop %esi
1071d6: 5f pop %edi
1071d7: c9 leave
1071d8: c3 ret
0010e2b0 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
10e2b0: 55 push %ebp
10e2b1: 89 e5 mov %esp,%ebp
10e2b3: 57 push %edi
10e2b4: 56 push %esi
10e2b5: 53 push %ebx
10e2b6: 83 ec 1c sub $0x1c,%esp
10e2b9: 8b 75 08 mov 0x8(%ebp),%esi
10e2bc: 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;
10e2bf: 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];
10e2c1: bb 60 ce 11 00 mov $0x11ce60,%ebx
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
10e2c6: eb 0c jmp 10e2d4 <rtems_filesystem_iterate+0x24>
stop = (*routine)( table_entry, routine_arg );
10e2c8: 51 push %ecx
10e2c9: 51 push %ecx
10e2ca: 57 push %edi
10e2cb: 53 push %ebx
10e2cc: ff d6 call *%esi
++table_entry;
10e2ce: 83 c3 08 add $0x8,%ebx
10e2d1: 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 ) {
10e2d4: 83 3b 00 cmpl $0x0,(%ebx)
10e2d7: 74 06 je 10e2df <rtems_filesystem_iterate+0x2f>
10e2d9: 84 c0 test %al,%al
10e2db: 74 eb je 10e2c8 <rtems_filesystem_iterate+0x18>
10e2dd: eb 40 jmp 10e31f <rtems_filesystem_iterate+0x6f>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
10e2df: 84 c0 test %al,%al
10e2e1: 75 3c jne 10e31f <rtems_filesystem_iterate+0x6f>
rtems_libio_lock();
10e2e3: 88 45 e4 mov %al,-0x1c(%ebp)
10e2e6: e8 95 ff ff ff call 10e280 <rtems_libio_lock>
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
10e2eb: 8b 1d 74 20 12 00 mov 0x122074,%ebx
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
10e2f1: 8a 55 e4 mov -0x1c(%ebp),%dl
10e2f4: eb 10 jmp 10e306 <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 );
10e2f6: 52 push %edx
10e2f7: 52 push %edx
10e2f8: 57 push %edi
10e2f9: 8d 43 08 lea 0x8(%ebx),%eax
10e2fc: 50 push %eax
10e2fd: ff d6 call *%esi
10e2ff: 88 c2 mov %al,%dl
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
10e301: 8b 1b mov (%ebx),%ebx
10e303: 83 c4 10 add $0x10,%esp
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
10e306: 81 fb 78 20 12 00 cmp $0x122078,%ebx
10e30c: 74 04 je 10e312 <rtems_filesystem_iterate+0x62>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
10e30e: 84 d2 test %dl,%dl
10e310: 74 e4 je 10e2f6 <rtems_filesystem_iterate+0x46><== ALWAYS TAKEN
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
10e312: 88 55 e4 mov %dl,-0x1c(%ebp)
10e315: e8 80 ff ff ff call 10e29a <rtems_libio_unlock>
10e31a: 8a 55 e4 mov -0x1c(%ebp),%dl
10e31d: 88 d0 mov %dl,%al
}
return stop;
}
10e31f: 8d 65 f4 lea -0xc(%ebp),%esp
10e322: 5b pop %ebx
10e323: 5e pop %esi
10e324: 5f pop %edi
10e325: c9 leave
10e326: c3 ret
0010776d <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
10776d: 55 push %ebp
10776e: 89 e5 mov %esp,%ebp
107770: 57 push %edi
107771: 56 push %esi
107772: 53 push %ebx
107773: 83 ec 1c sub $0x1c,%esp
107776: 8b 7d 08 mov 0x8(%ebp),%edi
107779: 8b 75 0c mov 0xc(%ebp),%esi
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
10777c: e8 bc ff ff ff call 10773d <rtems_libio_lock>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
107781: 8b 1d 34 1f 12 00 mov 0x121f34,%ebx
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
rtems_chain_node *node = NULL;
bool stop = false;
107787: 31 c0 xor %eax,%eax
rtems_libio_lock();
for (
107789: eb 0b jmp 107796 <rtems_filesystem_mount_iterate+0x29>
node = rtems_chain_next( node )
) {
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
10778b: 50 push %eax
10778c: 50 push %eax
10778d: 56 push %esi
10778e: 53 push %ebx
10778f: ff d7 call *%edi
}
rtems_libio_unlock();
return stop;
}
107791: 8b 1b mov (%ebx),%ebx
107793: 83 c4 10 add $0x10,%esp
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
107796: 81 fb 38 1f 12 00 cmp $0x121f38,%ebx
10779c: 74 04 je 1077a2 <rtems_filesystem_mount_iterate+0x35>
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
10779e: 84 c0 test %al,%al
1077a0: 74 e9 je 10778b <rtems_filesystem_mount_iterate+0x1e><== ALWAYS TAKEN
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
1077a2: 88 45 e4 mov %al,-0x1c(%ebp)
1077a5: e8 ad ff ff ff call 107757 <rtems_libio_unlock>
return stop;
}
1077aa: 8a 45 e4 mov -0x1c(%ebp),%al
1077ad: 8d 65 f4 lea -0xc(%ebp),%esp
1077b0: 5b pop %ebx
1077b1: 5e pop %esi
1077b2: 5f pop %edi
1077b3: c9 leave
1077b4: c3 ret
001072f6 <rtems_filesystem_prefix_separators>:
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
1072f6: 55 push %ebp
1072f7: 89 e5 mov %esp,%ebp
1072f9: 57 push %edi
1072fa: 56 push %esi
1072fb: 53 push %ebx
1072fc: 83 ec 0c sub $0xc,%esp
1072ff: 8b 7d 08 mov 0x8(%ebp),%edi
107302: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
107305: 31 db xor %ebx,%ebx
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
107307: eb 01 jmp 10730a <rtems_filesystem_prefix_separators+0x14>
{
pathname++;
pathnamelen--;
stripped++;
107309: 43 inc %ebx
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
10730a: 8a 04 1f mov (%edi,%ebx,1),%al
10730d: 39 de cmp %ebx,%esi
10730f: 74 17 je 107328 <rtems_filesystem_prefix_separators+0x32><== NEVER TAKEN
107311: 84 c0 test %al,%al
107313: 74 13 je 107328 <rtems_filesystem_prefix_separators+0x32><== NEVER TAKEN
107315: 83 ec 0c sub $0xc,%esp
107318: 0f be c0 movsbl %al,%eax
10731b: 50 push %eax
10731c: e8 df 0c 00 00 call 108000 <rtems_filesystem_is_separator>
107321: 83 c4 10 add $0x10,%esp
107324: 85 c0 test %eax,%eax
107326: 75 e1 jne 107309 <rtems_filesystem_prefix_separators+0x13>
pathname++;
pathnamelen--;
stripped++;
}
return stripped;
}
107328: 89 d8 mov %ebx,%eax
10732a: 8d 65 f4 lea -0xc(%ebp),%esp
10732d: 5b pop %ebx
10732e: 5e pop %esi
10732f: 5f pop %edi
107330: c9 leave
107331: c3 ret
00107c17 <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
107c17: 55 push %ebp
107c18: 89 e5 mov %esp,%ebp
107c1a: 53 push %ebx
107c1b: 83 ec 0c sub $0xc,%esp
107c1e: 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 );
107c21: 53 push %ebx
107c22: 6a 00 push $0x0
107c24: e8 6b 34 00 00 call 10b094 <rtems_task_variable_delete>
if ( status == RTEMS_SUCCESSFUL ) {
107c29: 83 c4 10 add $0x10,%esp
107c2c: 85 c0 test %eax,%eax
107c2e: 75 11 jne 107c41 <rtems_gxx_key_delete+0x2a><== NEVER TAKEN
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
107c30: 85 db test %ebx,%ebx
107c32: 74 0d je 107c41 <rtems_gxx_key_delete+0x2a><== NEVER TAKEN
107c34: 83 ec 0c sub $0xc,%esp
107c37: ff 33 pushl (%ebx)
107c39: e8 4a fe ff ff call 107a88 <free>
107c3e: 83 c4 10 add $0x10,%esp
return 0;
}
key = NULL;
return 0;
}
107c41: 31 c0 xor %eax,%eax
107c43: 8b 5d fc mov -0x4(%ebp),%ebx
107c46: c9 leave
107c47: c3 ret
00107b74 <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))
{
107b74: 55 push %ebp
107b75: 89 e5 mov %esp,%ebp
107b77: 56 push %esi
107b78: 53 push %ebx
107b79: 83 ec 10 sub $0x10,%esp
107b7c: 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 ) {
107b7f: 8b 03 mov (%ebx),%eax
107b81: 85 c0 test %eax,%eax
107b83: 75 3f jne 107bc4 <rtems_gxx_once+0x50>
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
107b85: 52 push %edx
107b86: 8d 45 f4 lea -0xc(%ebp),%eax
107b89: 50 push %eax
107b8a: 68 00 01 00 00 push $0x100
107b8f: 68 00 01 00 00 push $0x100
107b94: e8 e7 32 00 00 call 10ae80 <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
107b99: 8b 33 mov (%ebx),%esi
107b9b: 83 c4 10 add $0x10,%esp
107b9e: 85 f6 test %esi,%esi
107ba0: 75 06 jne 107ba8 <rtems_gxx_once+0x34> <== NEVER TAKEN
*(volatile __gthread_once_t *)once = 1;
107ba2: c7 03 01 00 00 00 movl $0x1,(%ebx)
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
107ba8: 50 push %eax
107ba9: 8d 45 f4 lea -0xc(%ebp),%eax
107bac: 50 push %eax
107bad: 68 00 01 00 00 push $0x100
107bb2: ff 75 f4 pushl -0xc(%ebp)
107bb5: e8 c6 32 00 00 call 10ae80 <rtems_task_mode>
if ( o == 0 )
107bba: 83 c4 10 add $0x10,%esp
107bbd: 85 f6 test %esi,%esi
107bbf: 75 03 jne 107bc4 <rtems_gxx_once+0x50> <== NEVER TAKEN
(*func)();
107bc1: ff 55 0c call *0xc(%ebp)
}
return 0;
}
107bc4: 31 c0 xor %eax,%eax
107bc6: 8d 65 f8 lea -0x8(%ebp),%esp
107bc9: 5b pop %ebx
107bca: 5e pop %esi
107bcb: c9 leave
107bcc: c3 ret
00107ca0 <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
107ca0: 55 push %ebp
107ca1: 89 e5 mov %esp,%ebp
107ca3: 53 push %ebx
107ca4: 83 ec 08 sub $0x8,%esp
107ca7: 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 );
107caa: ff 73 04 pushl 0x4(%ebx)
107cad: 53 push %ebx
107cae: 6a 00 push $0x0
107cb0: e8 4b 33 00 00 call 10b000 <rtems_task_variable_add>
107cb5: 89 c2 mov %eax,%edx
if ( status == RTEMS_SUCCESSFUL ) {
107cb7: 83 c4 10 add $0x10,%esp
/* now let's set the proper value */
key->val = (void *)ptr;
return 0;
}
return -1;
107cba: 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 ) {
107cbd: 85 d2 test %edx,%edx
107cbf: 75 07 jne 107cc8 <rtems_gxx_setspecific+0x28><== NEVER TAKEN
/* now let's set the proper value */
key->val = (void *)ptr;
107cc1: 8b 45 0c mov 0xc(%ebp),%eax
107cc4: 89 03 mov %eax,(%ebx)
return 0;
107cc6: 31 c0 xor %eax,%eax
}
return -1;
}
107cc8: 8b 5d fc mov -0x4(%ebp),%ebx
107ccb: c9 leave
107ccc: c3 ret
0010a930 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
10a930: 55 push %ebp
10a931: 89 e5 mov %esp,%ebp
10a933: 83 ec 08 sub $0x8,%esp
if (
10a936: 83 3d 70 ad 12 00 03 cmpl $0x3,0x12ad70
10a93d: 75 0d jne 10a94c <rtems_heap_allocate_aligned_with_boundary+0x1c><== NEVER TAKEN
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
10a93f: e8 34 f1 ff ff call 109a78 <malloc_is_system_state_OK>
10a944: 88 c2 mov %al,%dl
) {
return NULL;
10a946: 31 c0 xor %eax,%eax
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
10a948: 84 d2 test %dl,%dl
10a94a: 74 1c je 10a968 <rtems_heap_allocate_aligned_with_boundary+0x38>
) {
return NULL;
}
malloc_deferred_frees_process();
10a94c: e8 65 f1 ff ff call 109ab6 <malloc_deferred_frees_process>
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
10a951: ff 75 10 pushl 0x10(%ebp)
10a954: ff 75 0c pushl 0xc(%ebp)
10a957: ff 75 08 pushl 0x8(%ebp)
10a95a: ff 35 50 61 12 00 pushl 0x126150
10a960: e8 e3 43 00 00 call 10ed48 <_Protected_heap_Allocate_aligned_with_boundary>
10a965: 83 c4 10 add $0x10,%esp
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
10a968: c9 leave
10a969: c3 ret
00107022 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
107022: 55 push %ebp
107023: 89 e5 mov %esp,%ebp
107025: 57 push %edi
107026: 56 push %esi
107027: 53 push %ebx
107028: 83 ec 48 sub $0x48,%esp
10702b: 8b 75 08 mov 0x8(%ebp),%esi
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
10702e: 31 c0 xor %eax,%eax
107030: 83 c9 ff or $0xffffffff,%ecx
107033: 89 f7 mov %esi,%edi
107035: f2 ae repnz scas %es:(%edi),%al
107037: f7 d1 not %ecx
107039: 49 dec %ecx
10703a: 6a 01 push $0x1
10703c: 8d 55 d4 lea -0x2c(%ebp),%edx
10703f: 52 push %edx
107040: 6a 00 push $0x0
107042: 51 push %ecx
107043: 56 push %esi
107044: 89 55 c4 mov %edx,-0x3c(%ebp)
107047: e8 2a 02 00 00 call 107276 <rtems_filesystem_evaluate_path>
10704c: 89 c7 mov %eax,%edi
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
10704e: 8b 5d d4 mov -0x2c(%ebp),%ebx
node_type = (*loc.ops->node_type_h)( &loc );
107051: 83 c4 14 add $0x14,%esp
107054: 8b 55 c4 mov -0x3c(%ebp),%edx
107057: 52 push %edx
107058: 8b 45 e0 mov -0x20(%ebp),%eax
10705b: ff 50 10 call *0x10(%eax)
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
10705e: 83 c4 10 add $0x10,%esp
107061: 83 f8 02 cmp $0x2,%eax
107064: 8b 55 c4 mov -0x3c(%ebp),%edx
107067: 75 07 jne 107070 <rtems_io_lookup_name+0x4e>
107069: 85 ff test %edi,%edi
10706b: 0f 95 c0 setne %al
10706e: 74 16 je 107086 <rtems_io_lookup_name+0x64><== ALWAYS TAKEN
rtems_filesystem_freenode( &loc );
107070: 83 ec 0c sub $0xc,%esp
107073: 8d 45 d4 lea -0x2c(%ebp),%eax
107076: 50 push %eax
107077: e8 b8 02 00 00 call 107334 <rtems_filesystem_freenode>
return RTEMS_UNSATISFIED;
10707c: 83 c4 10 add $0x10,%esp
10707f: b8 0d 00 00 00 mov $0xd,%eax
107084: eb 32 jmp 1070b8 <rtems_io_lookup_name+0x96>
}
device_info->device_name = (char *) name;
107086: 8b 4d 0c mov 0xc(%ebp),%ecx
107089: 89 31 mov %esi,(%ecx)
device_info->device_name_length = strlen( name );
10708b: 83 c9 ff or $0xffffffff,%ecx
10708e: 89 f7 mov %esi,%edi
107090: f2 ae repnz scas %es:(%edi),%al
107092: f7 d1 not %ecx
107094: 49 dec %ecx
107095: 8b 45 0c mov 0xc(%ebp),%eax
107098: 89 48 04 mov %ecx,0x4(%eax)
device_info->major = the_jnode->info.device.major;
10709b: 8b 43 50 mov 0x50(%ebx),%eax
10709e: 8b 4d 0c mov 0xc(%ebp),%ecx
1070a1: 89 41 08 mov %eax,0x8(%ecx)
device_info->minor = the_jnode->info.device.minor;
1070a4: 8b 43 54 mov 0x54(%ebx),%eax
1070a7: 89 41 0c mov %eax,0xc(%ecx)
rtems_filesystem_freenode( &loc );
1070aa: 83 ec 0c sub $0xc,%esp
1070ad: 52 push %edx
1070ae: e8 81 02 00 00 call 107334 <rtems_filesystem_freenode>
return RTEMS_SUCCESSFUL;
1070b3: 83 c4 10 add $0x10,%esp
1070b6: 31 c0 xor %eax,%eax
}
1070b8: 8d 65 f4 lea -0xc(%ebp),%esp
1070bb: 5b pop %ebx
1070bc: 5e pop %esi
1070bd: 5f pop %edi
1070be: c9 leave
1070bf: c3 ret
0010b718 <rtems_io_register_driver>:
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
10b718: 55 push %ebp
10b719: 89 e5 mov %esp,%ebp
10b71b: 57 push %edi
10b71c: 56 push %esi
10b71d: 53 push %ebx
10b71e: 83 ec 0c sub $0xc,%esp
10b721: 8b 5d 08 mov 0x8(%ebp),%ebx
10b724: 8b 75 0c mov 0xc(%ebp),%esi
10b727: 8b 45 10 mov 0x10(%ebp),%eax
rtems_device_major_number major_limit = _IO_Number_of_drivers;
10b72a: 8b 15 20 7d 12 00 mov 0x127d20,%edx
if ( rtems_interrupt_is_in_progress() )
10b730: 83 3d e8 78 12 00 00 cmpl $0x0,0x1278e8
10b737: 0f 85 cc 00 00 00 jne 10b809 <rtems_io_register_driver+0xf1><== NEVER TAKEN
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
10b73d: 85 c0 test %eax,%eax
10b73f: 0f 84 cb 00 00 00 je 10b810 <rtems_io_register_driver+0xf8>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
10b745: 89 10 mov %edx,(%eax)
if ( driver_table == NULL )
10b747: 85 f6 test %esi,%esi
10b749: 0f 84 c1 00 00 00 je 10b810 <rtems_io_register_driver+0xf8>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10b74f: 83 3e 00 cmpl $0x0,(%esi)
10b752: 0f 85 cc 00 00 00 jne 10b824 <rtems_io_register_driver+0x10c>
10b758: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10b75c: 0f 85 c2 00 00 00 jne 10b824 <rtems_io_register_driver+0x10c>
10b762: e9 a9 00 00 00 jmp 10b810 <rtems_io_register_driver+0xf8>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b767: 8b 15 9c 73 12 00 mov 0x12739c,%edx
10b76d: 42 inc %edx
10b76e: 89 15 9c 73 12 00 mov %edx,0x12739c
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
10b774: 85 db test %ebx,%ebx
10b776: 75 32 jne 10b7aa <rtems_io_register_driver+0x92>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
10b778: 8b 0d 20 7d 12 00 mov 0x127d20,%ecx
10b77e: 8b 15 24 7d 12 00 mov 0x127d24,%edx
10b784: eb 15 jmp 10b79b <rtems_io_register_driver+0x83>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10b786: 83 3a 00 cmpl $0x0,(%edx)
10b789: 0f 85 9f 00 00 00 jne 10b82e <rtems_io_register_driver+0x116>
10b78f: 83 7a 04 00 cmpl $0x0,0x4(%edx)
10b793: 0f 85 95 00 00 00 jne 10b82e <rtems_io_register_driver+0x116>
10b799: eb 04 jmp 10b79f <rtems_io_register_driver+0x87>
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
10b79b: 39 cb cmp %ecx,%ebx
10b79d: 72 e7 jb 10b786 <rtems_io_register_driver+0x6e>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10b79f: 89 18 mov %ebx,(%eax)
if ( m != n )
10b7a1: 39 cb cmp %ecx,%ebx
10b7a3: 75 30 jne 10b7d5 <rtems_io_register_driver+0xbd>
10b7a5: e9 8d 00 00 00 jmp 10b837 <rtems_io_register_driver+0x11f>
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
10b7aa: 6b d3 18 imul $0x18,%ebx,%edx
10b7ad: 03 15 24 7d 12 00 add 0x127d24,%edx
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10b7b3: 31 c9 xor %ecx,%ecx
10b7b5: 83 3a 00 cmpl $0x0,(%edx)
10b7b8: 75 09 jne 10b7c3 <rtems_io_register_driver+0xab>
10b7ba: 31 c9 xor %ecx,%ecx
10b7bc: 83 7a 04 00 cmpl $0x0,0x4(%edx)
10b7c0: 0f 94 c1 sete %cl
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
10b7c3: 85 c9 test %ecx,%ecx
10b7c5: 75 0c jne 10b7d3 <rtems_io_register_driver+0xbb>
_Thread_Enable_dispatch();
10b7c7: e8 2a 18 00 00 call 10cff6 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10b7cc: b8 0c 00 00 00 mov $0xc,%eax
10b7d1: eb 49 jmp 10b81c <rtems_io_register_driver+0x104>
}
*registered_major = major;
10b7d3: 89 18 mov %ebx,(%eax)
}
_IO_Driver_address_table [major] = *driver_table;
10b7d5: 6b c3 18 imul $0x18,%ebx,%eax
10b7d8: 03 05 24 7d 12 00 add 0x127d24,%eax
10b7de: b9 06 00 00 00 mov $0x6,%ecx
10b7e3: 89 c7 mov %eax,%edi
10b7e5: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Thread_Enable_dispatch();
10b7e7: e8 0a 18 00 00 call 10cff6 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
10b7ec: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp)
10b7f3: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp)
10b7fa: 89 5d 08 mov %ebx,0x8(%ebp)
}
10b7fd: 83 c4 0c add $0xc,%esp
10b800: 5b pop %ebx
10b801: 5e pop %esi
10b802: 5f pop %edi
10b803: c9 leave
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
10b804: e9 a3 70 00 00 jmp 1128ac <rtems_io_initialize>
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
10b809: b8 12 00 00 00 mov $0x12,%eax
10b80e: eb 0c jmp 10b81c <rtems_io_register_driver+0x104>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
10b810: b8 09 00 00 00 mov $0x9,%eax
10b815: eb 05 jmp 10b81c <rtems_io_register_driver+0x104>
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
10b817: b8 0a 00 00 00 mov $0xa,%eax
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
10b81c: 83 c4 0c add $0xc,%esp
10b81f: 5b pop %ebx
10b820: 5e pop %esi
10b821: 5f pop %edi
10b822: c9 leave
10b823: c3 ret
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
10b824: 39 d3 cmp %edx,%ebx
10b826: 0f 82 3b ff ff ff jb 10b767 <rtems_io_register_driver+0x4f>
10b82c: eb e9 jmp 10b817 <rtems_io_register_driver+0xff>
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
10b82e: 43 inc %ebx
10b82f: 83 c2 18 add $0x18,%edx
10b832: e9 64 ff ff ff jmp 10b79b <rtems_io_register_driver+0x83>
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
10b837: e8 ba 17 00 00 call 10cff6 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
10b83c: b8 05 00 00 00 mov $0x5,%eax
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
return sc;
10b841: eb d9 jmp 10b81c <rtems_io_register_driver+0x104>
0010c744 <rtems_iterate_over_all_threads>:
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
{
10c744: 55 push %ebp
10c745: 89 e5 mov %esp,%ebp
10c747: 57 push %edi
10c748: 56 push %esi
10c749: 53 push %ebx
10c74a: 83 ec 0c sub $0xc,%esp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10c74d: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10c751: 74 3d je 10c790 <rtems_iterate_over_all_threads+0x4c><== NEVER TAKEN
10c753: bb 01 00 00 00 mov $0x1,%ebx
#if defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
10c758: 8b 04 9d e0 00 13 00 mov 0x1300e0(,%ebx,4),%eax
10c75f: 8b 78 04 mov 0x4(%eax),%edi
if ( !information )
10c762: be 01 00 00 00 mov $0x1,%esi
10c767: 85 ff test %edi,%edi
10c769: 75 17 jne 10c782 <rtems_iterate_over_all_threads+0x3e>
10c76b: eb 1d jmp 10c78a <rtems_iterate_over_all_threads+0x46>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
10c76d: 8b 47 1c mov 0x1c(%edi),%eax
10c770: 8b 04 b0 mov (%eax,%esi,4),%eax
if ( !the_thread )
10c773: 85 c0 test %eax,%eax
10c775: 74 0a je 10c781 <rtems_iterate_over_all_threads+0x3d><== NEVER TAKEN
continue;
(*routine)(the_thread);
10c777: 83 ec 0c sub $0xc,%esp
10c77a: 50 push %eax
10c77b: ff 55 08 call *0x8(%ebp)
10c77e: 83 c4 10 add $0x10,%esp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10c781: 46 inc %esi
10c782: 0f b7 47 10 movzwl 0x10(%edi),%eax
10c786: 39 c6 cmp %eax,%esi
10c788: 76 e3 jbe 10c76d <rtems_iterate_over_all_threads+0x29>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
10c78a: 43 inc %ebx
10c78b: 83 fb 04 cmp $0x4,%ebx
10c78e: 75 c8 jne 10c758 <rtems_iterate_over_all_threads+0x14>
(*routine)(the_thread);
}
}
}
10c790: 8d 65 f4 lea -0xc(%ebp),%esp
10c793: 5b pop %ebx
10c794: 5e pop %esi
10c795: 5f pop %edi
10c796: c9 leave
10c797: c3 ret
0010e184 <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
10e184: 55 push %ebp
10e185: 89 e5 mov %esp,%ebp
10e187: 53 push %ebx
10e188: 83 ec 04 sub $0x4,%esp
10e18b: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_libio_lock();
10e18e: e8 d5 fe ff ff call 10e068 <rtems_libio_lock>
if (iop->sem)
10e193: 8b 43 2c mov 0x2c(%ebx),%eax
10e196: 85 c0 test %eax,%eax
10e198: 74 0c je 10e1a6 <rtems_libio_free+0x22> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
10e19a: 83 ec 0c sub $0xc,%esp
10e19d: 50 push %eax
10e19e: e8 31 bf ff ff call 10a0d4 <rtems_semaphore_delete>
10e1a3: 83 c4 10 add $0x10,%esp
iop->flags &= ~LIBIO_FLAGS_OPEN;
10e1a6: 81 63 14 ff fe ff ff andl $0xfffffeff,0x14(%ebx)
iop->data1 = rtems_libio_iop_freelist;
10e1ad: a1 9c 41 12 00 mov 0x12419c,%eax
10e1b2: 89 43 34 mov %eax,0x34(%ebx)
rtems_libio_iop_freelist = iop;
10e1b5: 89 1d 9c 41 12 00 mov %ebx,0x12419c
rtems_libio_unlock();
}
10e1bb: 8b 5d fc mov -0x4(%ebp),%ebx
10e1be: c9 leave
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
rtems_libio_unlock();
10e1bf: e9 be fe ff ff jmp 10e082 <rtems_libio_unlock>
00107434 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
107434: 55 push %ebp
107435: 89 e5 mov %esp,%ebp
107437: 53 push %ebx
107438: 83 ec 04 sub $0x4,%esp
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
10743b: 8b 1d 44 01 12 00 mov 0x120144,%ebx
107441: 85 db test %ebx,%ebx
107443: 74 3e je 107483 <rtems_libio_init+0x4f> <== NEVER TAKEN
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
107445: 50 push %eax
107446: 50 push %eax
107447: 6a 38 push $0x38
107449: 53 push %ebx
10744a: e8 8d fd ff ff call 1071dc <calloc>
10744f: a3 98 41 12 00 mov %eax,0x124198
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
107454: 83 c4 10 add $0x10,%esp
107457: 85 c0 test %eax,%eax
107459: 75 07 jne 107462 <rtems_libio_init+0x2e>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
10745b: 83 ec 0c sub $0xc,%esp
10745e: 6a 1a push $0x1a
107460: eb 44 jmp 1074a6 <rtems_libio_init+0x72>
iop = rtems_libio_iop_freelist = rtems_libio_iops;
107462: a3 9c 41 12 00 mov %eax,0x12419c
107467: 89 c2 mov %eax,%edx
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
107469: 31 c9 xor %ecx,%ecx
10746b: eb 03 jmp 107470 <rtems_libio_init+0x3c>
iop->data1 = iop + 1;
10746d: 89 52 fc mov %edx,-0x4(%edx)
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
107470: 41 inc %ecx
107471: 83 c2 38 add $0x38,%edx
107474: 39 d9 cmp %ebx,%ecx
107476: 72 f5 jb 10746d <rtems_libio_init+0x39>
iop->data1 = iop + 1;
iop->data1 = NULL;
107478: 6b db 38 imul $0x38,%ebx,%ebx
10747b: c7 44 18 fc 00 00 00 movl $0x0,-0x4(%eax,%ebx,1)
107482: 00
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
107483: 83 ec 0c sub $0xc,%esp
107486: 68 a0 41 12 00 push $0x1241a0
10748b: 6a 00 push $0x0
10748d: 6a 54 push $0x54
10748f: 6a 01 push $0x1
107491: 68 4f 49 42 4c push $0x4c42494f
107496: e8 a1 2a 00 00 call 109f3c <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
10749b: 83 c4 20 add $0x20,%esp
10749e: 85 c0 test %eax,%eax
1074a0: 74 09 je 1074ab <rtems_libio_init+0x77> <== ALWAYS TAKEN
rtems_fatal_error_occurred( rc );
1074a2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1074a5: 50 push %eax <== NOT EXECUTED
1074a6: e8 81 32 00 00 call 10a72c <rtems_fatal_error_occurred>
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
1074ab: a1 40 01 12 00 mov 0x120140,%eax
1074b0: 85 c0 test %eax,%eax
1074b2: 74 06 je 1074ba <rtems_libio_init+0x86> <== NEVER TAKEN
(* rtems_fs_init_helper)();
}
1074b4: 8b 5d fc mov -0x4(%ebp),%ebx
1074b7: c9 leave
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
(* rtems_fs_init_helper)();
1074b8: ff e0 jmp *%eax
}
1074ba: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
1074bd: c9 leave <== NOT EXECUTED
1074be: c3 ret <== NOT EXECUTED
0010860d <rtems_libio_set_private_env>:
rtems_status_code rtems_libio_set_private_env(void)
{
10860d: 55 push %ebp
10860e: 89 e5 mov %esp,%ebp
108610: 57 push %edi
108611: 56 push %esi
108612: 53 push %ebx
108613: 83 ec 3c sub $0x3c,%esp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id task_id = rtems_task_self();
108616: e8 49 27 00 00 call 10ad64 <rtems_task_self>
10861b: 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);
10861d: 83 ec 0c sub $0xc,%esp
108620: 6a 00 push $0x0
108622: 8d 45 d4 lea -0x2c(%ebp),%eax
108625: 50 push %eax
108626: 6a 00 push $0x0
108628: 6a 01 push $0x1
10862a: 68 5c ee 11 00 push $0x11ee5c
10862f: e8 66 f0 ff ff call 10769a <rtems_filesystem_evaluate_path>
108634: 89 c2 mov %eax,%edx
if (rv != 0)
108636: 83 c4 20 add $0x20,%esp
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
108639: 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)
10863e: 85 d2 test %edx,%edx
108640: 0f 85 c0 00 00 00 jne 108706 <rtems_libio_set_private_env+0xf9><== NEVER TAKEN
goto error_0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, ¤t_loc, 0);
108646: 83 ec 0c sub $0xc,%esp
108649: 6a 00 push $0x0
10864b: 8d 45 c0 lea -0x40(%ebp),%eax
10864e: 50 push %eax
10864f: 6a 00 push $0x0
108651: 6a 01 push $0x1
108653: 68 5c ee 11 00 push $0x11ee5c
108658: e8 3d f0 ff ff call 10769a <rtems_filesystem_evaluate_path>
if (rv != 0)
10865d: 83 c4 20 add $0x20,%esp
108660: 85 c0 test %eax,%eax
108662: 0f 85 8a 00 00 00 jne 1086f2 <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
108668: a1 3c 30 12 00 mov 0x12303c,%eax
/*
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
10866d: 3d c8 51 12 00 cmp $0x1251c8,%eax
108672: 74 04 je 108678 <rtems_libio_set_private_env+0x6b>
rtems_current_user_env == &rtems_global_user_env
|| rtems_current_user_env->task_id != task_id
108674: 39 18 cmp %ebx,(%eax)
108676: 74 32 je 1086aa <rtems_libio_set_private_env+0x9d>
) {
new_env = malloc(sizeof(rtems_user_env_t));
108678: 83 ec 0c sub $0xc,%esp
10867b: 6a 48 push $0x48
10867d: e8 8a f5 ff ff call 107c0c <malloc>
108682: 89 c6 mov %eax,%esi
if (new_env == NULL)
108684: 83 c4 10 add $0x10,%esp
108687: 85 c0 test %eax,%eax
108689: 74 58 je 1086e3 <rtems_libio_set_private_env+0xd6>
#ifdef HAVE_USERENV_REFCNT
new_env->refcnt = 1;
#endif
sc = rtems_task_variable_add(
10868b: 50 push %eax
10868c: 68 d0 85 10 00 push $0x1085d0
108691: 68 3c 30 12 00 push $0x12303c
108696: 6a 00 push $0x0
108698: e8 3b 27 00 00 call 10add8 <rtems_task_variable_add>
RTEMS_SELF,
(void*)&rtems_current_user_env,
(void(*)(void *))free_user_env
);
if (sc != RTEMS_SUCCESSFUL)
10869d: 83 c4 10 add $0x10,%esp
1086a0: 85 c0 test %eax,%eax
1086a2: 75 33 jne 1086d7 <rtems_libio_set_private_env+0xca>
goto error_3;
rtems_current_user_env = new_env;
1086a4: 89 35 3c 30 12 00 mov %esi,0x12303c
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
1086aa: a1 3c 30 12 00 mov 0x12303c,%eax
1086af: be c8 51 12 00 mov $0x1251c8,%esi
1086b4: b9 12 00 00 00 mov $0x12,%ecx
1086b9: 89 c7 mov %eax,%edi
1086bb: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_current_user_env->task_id = task_id;
1086bd: 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;
1086bf: 8d 78 18 lea 0x18(%eax),%edi
1086c2: 8d 75 d4 lea -0x2c(%ebp),%esi
1086c5: b1 05 mov $0x5,%cl
1086c7: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_filesystem_current = current_loc;
1086c9: 8d 78 04 lea 0x4(%eax),%edi
1086cc: 8d 75 c0 lea -0x40(%ebp),%esi
1086cf: b1 05 mov $0x5,%cl
1086d1: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return RTEMS_SUCCESSFUL;
1086d3: 31 c0 xor %eax,%eax
1086d5: eb 2f jmp 108706 <rtems_libio_set_private_env+0xf9>
error_3:
free(new_env);
1086d7: 83 ec 0c sub $0xc,%esp
1086da: 56 push %esi
1086db: e8 8c f0 ff ff call 10776c <free>
1086e0: 83 c4 10 add $0x10,%esp
error_2:
rtems_filesystem_freenode(¤t_loc);
1086e3: 83 ec 0c sub $0xc,%esp
1086e6: 8d 45 c0 lea -0x40(%ebp),%eax
1086e9: 50 push %eax
1086ea: e8 69 f0 ff ff call 107758 <rtems_filesystem_freenode>
1086ef: 83 c4 10 add $0x10,%esp
error_1:
rtems_filesystem_freenode(&root_loc);
1086f2: 83 ec 0c sub $0xc,%esp
1086f5: 8d 45 d4 lea -0x2c(%ebp),%eax
1086f8: 50 push %eax
1086f9: e8 5a f0 ff ff call 107758 <rtems_filesystem_freenode>
1086fe: 83 c4 10 add $0x10,%esp
error_0:
return RTEMS_NO_MEMORY;
108701: b8 1a 00 00 00 mov $0x1a,%eax
}
108706: 8d 65 f4 lea -0xc(%ebp),%esp
108709: 5b pop %ebx
10870a: 5e pop %esi
10870b: 5f pop %edi
10870c: c9 leave
10870d: c3 ret
0010870e <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)
{
10870e: 55 push %ebp
10870f: 89 e5 mov %esp,%ebp
108711: 56 push %esi
108712: 53 push %ebx
108713: 83 ec 20 sub $0x20,%esp
108716: 8b 75 08 mov 0x8(%ebp),%esi
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
108719: e8 46 26 00 00 call 10ad64 <rtems_task_self>
10871e: 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;
108720: 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 )
108722: 39 de cmp %ebx,%esi
108724: 74 3c je 108762 <rtems_libio_share_private_env+0x54><== NEVER TAKEN
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
108726: 52 push %edx
task_id,
(void*)&rtems_current_user_env,
(void*)&shared_user_env );
108727: 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(
10872a: 50 push %eax
10872b: 68 3c 30 12 00 push $0x12303c
108730: 56 push %esi
108731: e8 36 27 00 00 call 10ae6c <rtems_task_variable_get>
(void*)&shared_user_env );
/*
* If it was not successful, return the error code
*/
if (sc != RTEMS_SUCCESSFUL)
108736: 83 c4 10 add $0x10,%esp
108739: 85 c0 test %eax,%eax
10873b: 75 25 jne 108762 <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) {
10873d: 8b 15 3c 30 12 00 mov 0x12303c,%edx
108743: 39 1a cmp %ebx,(%edx)
108745: 75 12 jne 108759 <rtems_libio_share_private_env+0x4b>
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
108747: 83 ec 0c sub $0xc,%esp
10874a: 52 push %edx
10874b: 89 45 e4 mov %eax,-0x1c(%ebp)
10874e: e8 7d fe ff ff call 1085d0 <free_user_env>
108753: 83 c4 10 add $0x10,%esp
108756: 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;
108759: 8b 55 f4 mov -0xc(%ebp),%edx
10875c: 89 15 3c 30 12 00 mov %edx,0x12303c
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
108762: 8d 65 f8 lea -0x8(%ebp),%esp
108765: 5b pop %ebx
108766: 5e pop %esi
108767: c9 leave
108768: c3 ret
0010e0cd <rtems_libio_to_fcntl_flags>:
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
10e0cd: 55 push %ebp
10e0ce: 89 e5 mov %esp,%ebp
10e0d0: 8b 55 08 mov 0x8(%ebp),%edx
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
10e0d3: 89 d1 mov %edx,%ecx
10e0d5: 83 e1 06 and $0x6,%ecx
fcntl_flags |= O_RDWR;
10e0d8: 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 ) {
10e0dd: 83 f9 06 cmp $0x6,%ecx
10e0e0: 74 0f je 10e0f1 <rtems_libio_to_fcntl_flags+0x24>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
fcntl_flags |= O_RDONLY;
10e0e2: 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) {
10e0e4: f6 c2 02 test $0x2,%dl
10e0e7: 75 08 jne 10e0f1 <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;
10e0e9: 31 c0 xor %eax,%eax
10e0eb: f6 c2 04 test $0x4,%dl <== NOT EXECUTED
10e0ee: 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 ) {
10e0f1: f6 c2 01 test $0x1,%dl
10e0f4: 74 03 je 10e0f9 <rtems_libio_to_fcntl_flags+0x2c>
fcntl_flags |= O_NONBLOCK;
10e0f6: 80 cc 40 or $0x40,%ah
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
10e0f9: f6 c6 02 test $0x2,%dh
10e0fc: 74 03 je 10e101 <rtems_libio_to_fcntl_flags+0x34>
fcntl_flags |= O_APPEND;
10e0fe: 83 c8 08 or $0x8,%eax
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
10e101: 80 e6 04 and $0x4,%dh
10e104: 74 03 je 10e109 <rtems_libio_to_fcntl_flags+0x3c>
fcntl_flags |= O_CREAT;
10e106: 80 cc 02 or $0x2,%ah
}
return fcntl_flags;
}
10e109: c9 leave
10e10a: c3 ret
00109d7c <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
109d7c: 55 push %ebp
109d7d: 89 e5 mov %esp,%ebp
109d7f: 83 ec 1c sub $0x1c,%esp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
109d82: 8d 45 f4 lea -0xc(%ebp),%eax
109d85: 50 push %eax
109d86: ff 75 08 pushl 0x8(%ebp)
109d89: ff 35 50 61 12 00 pushl 0x126150
109d8f: e8 5c 50 00 00 call 10edf0 <_Protected_heap_Get_block_size>
109d94: 83 c4 10 add $0x10,%esp
109d97: 84 c0 test %al,%al
109d99: 74 11 je 109dac <rtems_malloc_statistics_at_free+0x30><== NEVER TAKEN
MSBUMP(lifetime_freed, size);
109d9b: 8b 45 f4 mov -0xc(%ebp),%eax
109d9e: 31 d2 xor %edx,%edx
109da0: 01 05 e0 aa 12 00 add %eax,0x12aae0
109da6: 11 15 e4 aa 12 00 adc %edx,0x12aae4
}
}
109dac: c9 leave
109dad: c3 ret
00109dae <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
109dae: 55 push %ebp
109daf: 89 e5 mov %esp,%ebp
109db1: 83 ec 18 sub $0x18,%esp
109db4: 8b 45 08 mov 0x8(%ebp),%eax
uintptr_t actual_size = 0;
109db7: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
uint32_t current_depth;
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
109dbe: 85 c0 test %eax,%eax
109dc0: 74 43 je 109e05 <rtems_malloc_statistics_at_malloc+0x57><== NEVER TAKEN
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
109dc2: 52 push %edx
109dc3: 8d 55 f4 lea -0xc(%ebp),%edx
109dc6: 52 push %edx
109dc7: 50 push %eax
109dc8: ff 35 50 61 12 00 pushl 0x126150
109dce: e8 1d 50 00 00 call 10edf0 <_Protected_heap_Get_block_size>
MSBUMP(lifetime_allocated, actual_size);
109dd3: 8b 45 f4 mov -0xc(%ebp),%eax
109dd6: 31 d2 xor %edx,%edx
109dd8: 03 05 d8 aa 12 00 add 0x12aad8,%eax
109dde: 13 15 dc aa 12 00 adc 0x12aadc,%edx
109de4: a3 d8 aa 12 00 mov %eax,0x12aad8
109de9: 89 15 dc aa 12 00 mov %edx,0x12aadc
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
109def: 2b 05 e0 aa 12 00 sub 0x12aae0,%eax
if (current_depth > s->max_depth)
109df5: 83 c4 10 add $0x10,%esp
109df8: 3b 05 d4 aa 12 00 cmp 0x12aad4,%eax
109dfe: 76 05 jbe 109e05 <rtems_malloc_statistics_at_malloc+0x57>
s->max_depth = current_depth;
109e00: a3 d4 aa 12 00 mov %eax,0x12aad4
}
109e05: c9 leave
109e06: c3 ret
00111948 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
111948: 55 push %ebp
111949: 89 e5 mov %esp,%ebp
11194b: 57 push %edi
11194c: 56 push %esi
11194d: 53 push %ebx
11194e: 83 ec 0c sub $0xc,%esp
111951: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
111954: be 16 00 00 00 mov $0x16,%esi
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
111959: 85 db test %ebx,%ebx
11195b: 74 55 je 1119b2 <rtems_memalign+0x6a>
return EINVAL;
*pointer = NULL;
11195d: 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()) &&
111963: 83 3d 1c 75 12 00 03 cmpl $0x3,0x12751c
11196a: 75 09 jne 111975 <rtems_memalign+0x2d> <== NEVER TAKEN
!malloc_is_system_state_OK() )
11196c: e8 97 68 ff ff call 108208 <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()) &&
111971: 84 c0 test %al,%al
111973: 74 3d je 1119b2 <rtems_memalign+0x6a> <== NEVER TAKEN
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
111975: e8 cc 68 ff ff call 108246 <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
11197a: 6a 00 push $0x0
11197c: ff 75 0c pushl 0xc(%ebp)
11197f: ff 75 10 pushl 0x10(%ebp)
111982: ff 35 50 31 12 00 pushl 0x123150
111988: e8 93 b0 ff ff call 10ca20 <_Protected_heap_Allocate_aligned_with_boundary>
11198d: 89 c7 mov %eax,%edi
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
11198f: 83 c4 10 add $0x10,%esp
return ENOMEM;
111992: be 0c 00 00 00 mov $0xc,%esi
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
111997: 85 c0 test %eax,%eax
111999: 74 17 je 1119b2 <rtems_memalign+0x6a>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
11199b: a1 30 56 12 00 mov 0x125630,%eax
1119a0: 85 c0 test %eax,%eax
1119a2: 74 0a je 1119ae <rtems_memalign+0x66>
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
1119a4: 83 ec 0c sub $0xc,%esp
1119a7: 53 push %ebx
1119a8: ff 50 04 call *0x4(%eax)
1119ab: 83 c4 10 add $0x10,%esp
*pointer = return_this;
1119ae: 89 3b mov %edi,(%ebx)
return 0;
1119b0: 31 f6 xor %esi,%esi
}
1119b2: 89 f0 mov %esi,%eax
1119b4: 8d 65 f4 lea -0xc(%ebp),%esp
1119b7: 5b pop %ebx
1119b8: 5e pop %esi
1119b9: 5f pop %edi
1119ba: c9 leave
1119bb: c3 ret
00110254 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
110254: 55 push %ebp
110255: 89 e5 mov %esp,%ebp
110257: 57 push %edi
110258: 56 push %esi
110259: 53 push %ebx
11025a: 83 ec 78 sub $0x78,%esp
int success = 0;
char *dup_path = strdup(path);
11025d: ff 75 08 pushl 0x8(%ebp)
110260: e8 8f 33 00 00 call 1135f4 <strdup>
110265: 89 c3 mov %eax,%ebx
if (dup_path != NULL) {
110267: 83 c4 10 add $0x10,%esp
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
11026a: 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) {
11026d: 85 db test %ebx,%ebx
11026f: 0f 84 1e 01 00 00 je 110393 <rtems_mkdir+0x13f> <== NEVER TAKEN
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
110275: 31 c0 xor %eax,%eax
110277: 80 3b 2f cmpb $0x2f,(%ebx)
11027a: 0f 94 c0 sete %al
11027d: 8d 3c 03 lea (%ebx,%eax,1),%edi
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
110280: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
110287: b8 01 00 00 00 mov $0x1,%eax
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
11028c: 8a 0f mov (%edi),%cl
last = 1;
11028e: 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')
110293: 84 c9 test %cl,%cl
110295: 74 0b je 1102a2 <rtems_mkdir+0x4e>
last = 1;
else if (p[0] != '/')
110297: 80 f9 2f cmp $0x2f,%cl
11029a: 0f 85 c8 00 00 00 jne 110368 <rtems_mkdir+0x114>
1102a0: 30 d2 xor %dl,%dl
continue;
*p = '\0';
1102a2: c6 07 00 movb $0x0,(%edi)
if (!last && p[1] == '\0')
1102a5: be 01 00 00 00 mov $0x1,%esi
1102aa: 85 d2 test %edx,%edx
1102ac: 75 0b jne 1102b9 <rtems_mkdir+0x65>
1102ae: 31 d2 xor %edx,%edx
1102b0: 80 7f 01 00 cmpb $0x0,0x1(%edi)
1102b4: 0f 94 c2 sete %dl
1102b7: 89 d6 mov %edx,%esi
last = 1;
if (first) {
1102b9: 85 c0 test %eax,%eax
1102bb: 74 1a je 1102d7 <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);
1102bd: 83 ec 0c sub $0xc,%esp
1102c0: 6a 00 push $0x0
1102c2: e8 75 01 00 00 call 11043c <umask>
1102c7: 89 45 94 mov %eax,-0x6c(%ebp)
numask = oumask & ~(S_IWUSR | S_IXUSR);
1102ca: 24 3f and $0x3f,%al
(void)umask(numask);
1102cc: 89 04 24 mov %eax,(%esp)
1102cf: e8 68 01 00 00 call 11043c <umask>
1102d4: 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) {
1102d7: b8 ff 01 00 00 mov $0x1ff,%eax
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
1102dc: 85 f6 test %esi,%esi
1102de: 74 11 je 1102f1 <rtems_mkdir+0x9d>
(void)umask(oumask);
1102e0: 83 ec 0c sub $0xc,%esp
1102e3: ff 75 94 pushl -0x6c(%ebp)
1102e6: e8 51 01 00 00 call 11043c <umask>
1102eb: 83 c4 10 add $0x10,%esp
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
1102ee: 8b 45 0c mov 0xc(%ebp),%eax
1102f1: 52 push %edx
1102f2: 52 push %edx
1102f3: 50 push %eax
1102f4: 53 push %ebx
1102f5: e8 ee 83 ff ff call 1086e8 <mkdir>
1102fa: 83 c4 10 add $0x10,%esp
1102fd: 85 c0 test %eax,%eax
1102ff: 79 5e jns 11035f <rtems_mkdir+0x10b>
if (errno == EEXIST || errno == EISDIR) {
110301: e8 1a 26 00 00 call 112920 <__errno>
110306: 83 38 11 cmpl $0x11,(%eax)
110309: 74 0a je 110315 <rtems_mkdir+0xc1>
11030b: e8 10 26 00 00 call 112920 <__errno>
110310: 83 38 15 cmpl $0x15,(%eax)
110313: 75 59 jne 11036e <rtems_mkdir+0x11a> <== ALWAYS TAKEN
if (stat(path, &sb) < 0) {
110315: 50 push %eax
110316: 50 push %eax
110317: 8d 45 a0 lea -0x60(%ebp),%eax
11031a: 50 push %eax
11031b: 53 push %ebx
11031c: e8 8b 00 00 00 call 1103ac <stat>
110321: 83 c4 10 add $0x10,%esp
110324: 85 c0 test %eax,%eax
110326: 78 46 js 11036e <rtems_mkdir+0x11a> <== NEVER TAKEN
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
110328: 8b 45 ac mov -0x54(%ebp),%eax
11032b: 25 00 f0 00 00 and $0xf000,%eax
110330: 3d 00 40 00 00 cmp $0x4000,%eax
110335: 74 22 je 110359 <rtems_mkdir+0x105>
if (last)
110337: 85 f6 test %esi,%esi
110339: 74 0f je 11034a <rtems_mkdir+0xf6>
errno = EEXIST;
11033b: e8 e0 25 00 00 call 112920 <__errno>
110340: c7 00 11 00 00 00 movl $0x11,(%eax)
else
errno = ENOTDIR;
retval = 0;
110346: 31 ff xor %edi,%edi
110348: eb 38 jmp 110382 <rtems_mkdir+0x12e>
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
errno = EEXIST;
else
errno = ENOTDIR;
11034a: e8 d1 25 00 00 call 112920 <__errno>
11034f: c7 00 14 00 00 00 movl $0x14,(%eax)
retval = 0;
110355: 31 ff xor %edi,%edi
110357: eb 1b jmp 110374 <rtems_mkdir+0x120>
break;
}
if (last)
110359: 85 f6 test %esi,%esi
11035b: 75 3e jne 11039b <rtems_mkdir+0x147>
11035d: eb 04 jmp 110363 <rtems_mkdir+0x10f>
} else {
retval = 0;
break;
}
}
if (!last)
11035f: 85 f6 test %esi,%esi
110361: 75 3f jne 1103a2 <rtems_mkdir+0x14e>
*p = '/';
110363: c6 07 2f movb $0x2f,(%edi)
110366: 31 c0 xor %eax,%eax
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
110368: 47 inc %edi
110369: e9 1e ff ff ff jmp 11028c <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;
11036e: 31 ff xor %edi,%edi
}
}
if (!last)
*p = '/';
}
if (!first && !last)
110370: 85 f6 test %esi,%esi
110372: 75 0e jne 110382 <rtems_mkdir+0x12e> <== ALWAYS TAKEN
(void)umask(oumask);
110374: 83 ec 0c sub $0xc,%esp
110377: ff 75 94 pushl -0x6c(%ebp)
11037a: e8 bd 00 00 00 call 11043c <umask>
11037f: 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);
110382: 83 ec 0c sub $0xc,%esp
110385: 53 push %ebx
110386: e8 01 7e ff ff call 10818c <free>
}
return success != 0 ? 0 : -1;
11038b: 83 c4 10 add $0x10,%esp
11038e: 83 ff 01 cmp $0x1,%edi
110391: 19 c0 sbb %eax,%eax
}
110393: 8d 65 f4 lea -0xc(%ebp),%esp
110396: 5b pop %ebx
110397: 5e pop %esi
110398: 5f pop %edi
110399: c9 leave
11039a: c3 ret
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
retval = 2;
11039b: bf 02 00 00 00 mov $0x2,%edi
1103a0: eb e0 jmp 110382 <rtems_mkdir+0x12e>
} else {
retval = 0;
break;
}
}
if (!last)
1103a2: bf 01 00 00 00 mov $0x1,%edi
1103a7: eb d9 jmp 110382 <rtems_mkdir+0x12e>
001147e8 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
1147e8: 55 push %ebp
1147e9: 89 e5 mov %esp,%ebp
1147eb: 57 push %edi
1147ec: 56 push %esi
1147ed: 53 push %ebx
1147ee: 83 ec 1c sub $0x1c,%esp
1147f1: 8b 75 0c mov 0xc(%ebp),%esi
1147f4: 8b 55 10 mov 0x10(%ebp),%edx
1147f7: 8b 7d 14 mov 0x14(%ebp),%edi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
1147fa: b8 03 00 00 00 mov $0x3,%eax
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
1147ff: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
114803: 0f 84 ce 00 00 00 je 1148d7 <rtems_partition_create+0xef>
return RTEMS_INVALID_NAME;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
114809: b0 09 mov $0x9,%al
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
11480b: 85 f6 test %esi,%esi
11480d: 0f 84 c4 00 00 00 je 1148d7 <rtems_partition_create+0xef>
return RTEMS_INVALID_ADDRESS;
if ( !id )
114813: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp)
114817: 0f 84 ba 00 00 00 je 1148d7 <rtems_partition_create+0xef><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
11481d: 85 ff test %edi,%edi
11481f: 0f 84 ad 00 00 00 je 1148d2 <rtems_partition_create+0xea>
114825: 85 d2 test %edx,%edx
114827: 0f 84 a5 00 00 00 je 1148d2 <rtems_partition_create+0xea>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
11482d: b0 08 mov $0x8,%al
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
11482f: 39 fa cmp %edi,%edx
114831: 0f 82 a0 00 00 00 jb 1148d7 <rtems_partition_create+0xef>
114837: f7 c7 03 00 00 00 test $0x3,%edi
11483d: 0f 85 94 00 00 00 jne 1148d7 <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;
114843: 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 ) )
114845: f7 c6 03 00 00 00 test $0x3,%esi
11484b: 0f 85 86 00 00 00 jne 1148d7 <rtems_partition_create+0xef>
114851: a1 b8 d6 13 00 mov 0x13d6b8,%eax
114856: 40 inc %eax
114857: a3 b8 d6 13 00 mov %eax,0x13d6b8
* 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 );
11485c: 83 ec 0c sub $0xc,%esp
11485f: 68 44 d5 13 00 push $0x13d544
114864: 89 55 e4 mov %edx,-0x1c(%ebp)
114867: e8 20 3e 00 00 call 11868c <_Objects_Allocate>
11486c: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
11486e: 83 c4 10 add $0x10,%esp
114871: 85 c0 test %eax,%eax
114873: 8b 55 e4 mov -0x1c(%ebp),%edx
114876: 75 0c jne 114884 <rtems_partition_create+0x9c>
_Thread_Enable_dispatch();
114878: e8 59 4a 00 00 call 1192d6 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
11487d: b8 05 00 00 00 mov $0x5,%eax
114882: eb 53 jmp 1148d7 <rtems_partition_create+0xef>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
114884: 89 70 10 mov %esi,0x10(%eax)
the_partition->length = length;
114887: 89 50 14 mov %edx,0x14(%eax)
the_partition->buffer_size = buffer_size;
11488a: 89 78 18 mov %edi,0x18(%eax)
the_partition->attribute_set = attribute_set;
11488d: 8b 45 18 mov 0x18(%ebp),%eax
114890: 89 43 1c mov %eax,0x1c(%ebx)
the_partition->number_of_used_blocks = 0;
114893: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
_Chain_Initialize( &the_partition->Memory, starting_address,
11489a: 57 push %edi
11489b: 89 d0 mov %edx,%eax
11489d: 31 d2 xor %edx,%edx
11489f: f7 f7 div %edi
1148a1: 50 push %eax
1148a2: 56 push %esi
1148a3: 8d 43 24 lea 0x24(%ebx),%eax
1148a6: 50 push %eax
1148a7: e8 80 2a 00 00 call 11732c <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
1148ac: 8b 43 08 mov 0x8(%ebx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
1148af: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1148b2: 8b 15 60 d5 13 00 mov 0x13d560,%edx
1148b8: 89 1c 8a mov %ebx,(%edx,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1148bb: 8b 55 08 mov 0x8(%ebp),%edx
1148be: 89 53 0c mov %edx,0xc(%ebx)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
1148c1: 8b 55 1c mov 0x1c(%ebp),%edx
1148c4: 89 02 mov %eax,(%edx)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
1148c6: e8 0b 4a 00 00 call 1192d6 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1148cb: 83 c4 10 add $0x10,%esp
1148ce: 31 c0 xor %eax,%eax
1148d0: eb 05 jmp 1148d7 <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;
1148d2: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1148d7: 8d 65 f4 lea -0xc(%ebp),%esp
1148da: 5b pop %ebx
1148db: 5e pop %esi
1148dc: 5f pop %edi
1148dd: c9 leave
1148de: c3 ret
0010b03d <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
10b03d: 55 push %ebp
10b03e: 89 e5 mov %esp,%ebp
10b040: 57 push %edi
10b041: 56 push %esi
10b042: 53 push %ebx
10b043: 83 ec 30 sub $0x30,%esp
10b046: 8b 75 08 mov 0x8(%ebp),%esi
10b049: 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 );
10b04c: 8d 45 e4 lea -0x1c(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
10b04f: 50 push %eax
10b050: 56 push %esi
10b051: 68 14 73 12 00 push $0x127314
10b056: e8 3d 1e 00 00 call 10ce98 <_Objects_Get>
10b05b: 89 c7 mov %eax,%edi
switch ( location ) {
10b05d: 83 c4 10 add $0x10,%esp
10b060: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b064: 0f 85 3b 01 00 00 jne 10b1a5 <rtems_rate_monotonic_period+0x168><== NEVER TAKEN
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
10b06a: a1 58 79 12 00 mov 0x127958,%eax
10b06f: 39 47 40 cmp %eax,0x40(%edi)
10b072: 74 0f je 10b083 <rtems_rate_monotonic_period+0x46>
_Thread_Enable_dispatch();
10b074: e8 fd 25 00 00 call 10d676 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
10b079: be 17 00 00 00 mov $0x17,%esi
10b07e: e9 27 01 00 00 jmp 10b1aa <rtems_rate_monotonic_period+0x16d>
}
if ( length == RTEMS_PERIOD_STATUS ) {
10b083: 85 db test %ebx,%ebx
10b085: 75 1b jne 10b0a2 <rtems_rate_monotonic_period+0x65>
switch ( the_period->state ) {
10b087: 8b 47 38 mov 0x38(%edi),%eax
10b08a: 31 f6 xor %esi,%esi
10b08c: 83 f8 04 cmp $0x4,%eax
10b08f: 77 07 ja 10b098 <rtems_rate_monotonic_period+0x5b><== NEVER TAKEN
10b091: 8b 34 85 00 0d 12 00 mov 0x120d00(,%eax,4),%esi
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
10b098: e8 d9 25 00 00 call 10d676 <_Thread_Enable_dispatch>
return( return_value );
10b09d: e9 08 01 00 00 jmp 10b1aa <rtems_rate_monotonic_period+0x16d>
}
_ISR_Disable( level );
10b0a2: 9c pushf
10b0a3: fa cli
10b0a4: 8f 45 d4 popl -0x2c(%ebp)
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
10b0a7: 8b 47 38 mov 0x38(%edi),%eax
10b0aa: 85 c0 test %eax,%eax
10b0ac: 75 4c jne 10b0fa <rtems_rate_monotonic_period+0xbd>
_ISR_Enable( level );
10b0ae: ff 75 d4 pushl -0x2c(%ebp)
10b0b1: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10b0b2: 83 ec 0c sub $0xc,%esp
10b0b5: 57 push %edi
10b0b6: e8 3f fe ff ff call 10aefa <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10b0bb: 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;
10b0c2: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
the_watchdog->routine = routine;
10b0c9: c7 47 2c b4 b3 10 00 movl $0x10b3b4,0x2c(%edi)
the_watchdog->id = id;
10b0d0: 89 77 30 mov %esi,0x30(%edi)
the_watchdog->user_data = user_data;
10b0d3: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10b0da: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b0dd: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b0e0: 58 pop %eax
10b0e1: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b0e2: 83 c7 10 add $0x10,%edi
10b0e5: 57 push %edi
10b0e6: 68 d0 74 12 00 push $0x1274d0
10b0eb: e8 ec 34 00 00 call 10e5dc <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b0f0: e8 81 25 00 00 call 10d676 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b0f5: 83 c4 10 add $0x10,%esp
10b0f8: eb 65 jmp 10b15f <rtems_rate_monotonic_period+0x122>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
10b0fa: 83 f8 02 cmp $0x2,%eax
10b0fd: 75 64 jne 10b163 <rtems_rate_monotonic_period+0x126>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10b0ff: 83 ec 0c sub $0xc,%esp
10b102: 57 push %edi
10b103: e8 5a fe ff ff call 10af62 <_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;
10b108: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi)
the_period->next_length = length;
10b10f: 89 5f 3c mov %ebx,0x3c(%edi)
_ISR_Enable( level );
10b112: ff 75 d4 pushl -0x2c(%ebp)
10b115: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10b116: a1 58 79 12 00 mov 0x127958,%eax
10b11b: 8b 57 08 mov 0x8(%edi),%edx
10b11e: 89 50 20 mov %edx,0x20(%eax)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b121: 5b pop %ebx
10b122: 5e pop %esi
10b123: 68 00 40 00 00 push $0x4000
10b128: 50 push %eax
10b129: e8 42 2d 00 00 call 10de70 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10b12e: 9c pushf
10b12f: fa cli
10b130: 5a pop %edx
local_state = the_period->state;
10b131: 8b 47 38 mov 0x38(%edi),%eax
the_period->state = RATE_MONOTONIC_ACTIVE;
10b134: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
_ISR_Enable( level );
10b13b: 52 push %edx
10b13c: 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 )
10b13d: 83 c4 10 add $0x10,%esp
10b140: 83 f8 03 cmp $0x3,%eax
10b143: 75 15 jne 10b15a <rtems_rate_monotonic_period+0x11d>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b145: 51 push %ecx
10b146: 51 push %ecx
10b147: 68 00 40 00 00 push $0x4000
10b14c: ff 35 58 79 12 00 pushl 0x127958
10b152: e8 ad 21 00 00 call 10d304 <_Thread_Clear_state>
10b157: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
10b15a: e8 17 25 00 00 call 10d676 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b15f: 31 f6 xor %esi,%esi
10b161: eb 47 jmp 10b1aa <rtems_rate_monotonic_period+0x16d>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b163: be 04 00 00 00 mov $0x4,%esi
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
10b168: 83 f8 04 cmp $0x4,%eax
10b16b: 75 3d jne 10b1aa <rtems_rate_monotonic_period+0x16d><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10b16d: 83 ec 0c sub $0xc,%esp
10b170: 57 push %edi
10b171: e8 ec fd ff ff call 10af62 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10b176: ff 75 d4 pushl -0x2c(%ebp)
10b179: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10b17a: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
the_period->next_length = length;
10b181: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b184: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b187: 58 pop %eax
10b188: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b189: 83 c7 10 add $0x10,%edi
10b18c: 57 push %edi
10b18d: 68 d0 74 12 00 push $0x1274d0
10b192: e8 45 34 00 00 call 10e5dc <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b197: e8 da 24 00 00 call 10d676 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
10b19c: 83 c4 10 add $0x10,%esp
10b19f: 66 be 06 00 mov $0x6,%si
10b1a3: eb 05 jmp 10b1aa <rtems_rate_monotonic_period+0x16d>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b1a5: be 04 00 00 00 mov $0x4,%esi
}
10b1aa: 89 f0 mov %esi,%eax
10b1ac: 8d 65 f4 lea -0xc(%ebp),%esp
10b1af: 5b pop %ebx
10b1b0: 5e pop %esi
10b1b1: 5f pop %edi
10b1b2: c9 leave
10b1b3: c3 ret
0010b1b4 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10b1b4: 55 push %ebp
10b1b5: 89 e5 mov %esp,%ebp
10b1b7: 57 push %edi
10b1b8: 56 push %esi
10b1b9: 53 push %ebx
10b1ba: 83 ec 7c sub $0x7c,%esp
10b1bd: 8b 5d 08 mov 0x8(%ebp),%ebx
10b1c0: 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 )
10b1c3: 85 ff test %edi,%edi
10b1c5: 0f 84 2b 01 00 00 je 10b2f6 <rtems_rate_monotonic_report_statistics_with_plugin+0x142><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10b1cb: 52 push %edx
10b1cc: 52 push %edx
10b1cd: 68 14 0d 12 00 push $0x120d14
10b1d2: 53 push %ebx
10b1d3: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
10b1d5: 5e pop %esi
10b1d6: 58 pop %eax
10b1d7: 68 32 0d 12 00 push $0x120d32
10b1dc: 53 push %ebx
10b1dd: ff d7 call *%edi
(*print)( context, "--- Wall times are in seconds ---\n" );
10b1df: 5a pop %edx
10b1e0: 59 pop %ecx
10b1e1: 68 54 0d 12 00 push $0x120d54
10b1e6: 53 push %ebx
10b1e7: ff d7 call *%edi
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
10b1e9: 5e pop %esi
10b1ea: 58 pop %eax
10b1eb: 68 77 0d 12 00 push $0x120d77
10b1f0: 53 push %ebx
10b1f1: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10b1f3: 5a pop %edx
10b1f4: 59 pop %ecx
10b1f5: 68 c2 0d 12 00 push $0x120dc2
10b1fa: 53 push %ebx
10b1fb: 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 ;
10b1fd: 8b 35 1c 73 12 00 mov 0x12731c,%esi
10b203: 83 c4 10 add $0x10,%esp
10b206: e9 df 00 00 00 jmp 10b2ea <rtems_rate_monotonic_report_statistics_with_plugin+0x136>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10b20b: 50 push %eax
10b20c: 50 push %eax
10b20d: 8d 45 88 lea -0x78(%ebp),%eax
10b210: 50 push %eax
10b211: 56 push %esi
10b212: e8 39 56 00 00 call 110850 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10b217: 83 c4 10 add $0x10,%esp
10b21a: 85 c0 test %eax,%eax
10b21c: 0f 85 c7 00 00 00 jne 10b2e9 <rtems_rate_monotonic_report_statistics_with_plugin+0x135>
continue;
/* If the above passed, so should this but check it anyway */
status = rtems_rate_monotonic_get_status( id, &the_status );
10b222: 51 push %ecx
10b223: 51 push %ecx
10b224: 8d 55 c0 lea -0x40(%ebp),%edx
10b227: 52 push %edx
10b228: 56 push %esi
10b229: e8 c6 56 00 00 call 1108f4 <rtems_rate_monotonic_get_status>
#if defined(RTEMS_DEBUG)
if ( status != RTEMS_SUCCESSFUL )
continue;
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
10b22e: 83 c4 0c add $0xc,%esp
10b231: 8d 45 e3 lea -0x1d(%ebp),%eax
10b234: 50 push %eax
10b235: 6a 05 push $0x5
10b237: ff 75 c0 pushl -0x40(%ebp)
10b23a: e8 01 02 00 00 call 10b440 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10b23f: 58 pop %eax
10b240: 5a pop %edx
10b241: ff 75 8c pushl -0x74(%ebp)
10b244: ff 75 88 pushl -0x78(%ebp)
10b247: 8d 55 e3 lea -0x1d(%ebp),%edx
10b24a: 52 push %edx
10b24b: 56 push %esi
10b24c: 68 0e 0e 12 00 push $0x120e0e
10b251: 53 push %ebx
10b252: ff d7 call *%edi
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10b254: 8b 45 88 mov -0x78(%ebp),%eax
10b257: 83 c4 20 add $0x20,%esp
10b25a: 85 c0 test %eax,%eax
10b25c: 75 0f jne 10b26d <rtems_rate_monotonic_report_statistics_with_plugin+0xb9>
(*print)( context, "\n" );
10b25e: 51 push %ecx
10b25f: 51 push %ecx
10b260: 68 88 10 12 00 push $0x121088
10b265: 53 push %ebx
10b266: ff d7 call *%edi
continue;
10b268: 83 c4 10 add $0x10,%esp
10b26b: eb 7c jmp 10b2e9 <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 );
10b26d: 52 push %edx
10b26e: 8d 55 d8 lea -0x28(%ebp),%edx
10b271: 52 push %edx
10b272: 50 push %eax
10b273: 8d 45 a0 lea -0x60(%ebp),%eax
10b276: 50 push %eax
10b277: e8 34 30 00 00 call 10e2b0 <_Timespec_Divide_by_integer>
(*print)( context,
10b27c: 8b 45 dc mov -0x24(%ebp),%eax
10b27f: b9 e8 03 00 00 mov $0x3e8,%ecx
10b284: 99 cltd
10b285: f7 f9 idiv %ecx
10b287: 50 push %eax
10b288: ff 75 d8 pushl -0x28(%ebp)
10b28b: 8b 45 9c mov -0x64(%ebp),%eax
10b28e: 99 cltd
10b28f: f7 f9 idiv %ecx
10b291: 50 push %eax
10b292: ff 75 98 pushl -0x68(%ebp)
10b295: 8b 45 94 mov -0x6c(%ebp),%eax
10b298: 99 cltd
10b299: f7 f9 idiv %ecx
10b29b: 50 push %eax
10b29c: ff 75 90 pushl -0x70(%ebp)
10b29f: 68 25 0e 12 00 push $0x120e25
10b2a4: 53 push %ebx
10b2a5: 89 4d 84 mov %ecx,-0x7c(%ebp)
10b2a8: 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);
10b2aa: 83 c4 2c add $0x2c,%esp
10b2ad: 8d 55 d8 lea -0x28(%ebp),%edx
10b2b0: 52 push %edx
10b2b1: 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;
10b2b4: 8d 45 b8 lea -0x48(%ebp),%eax
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
10b2b7: 50 push %eax
10b2b8: e8 f3 2f 00 00 call 10e2b0 <_Timespec_Divide_by_integer>
(*print)( context,
10b2bd: 8b 45 dc mov -0x24(%ebp),%eax
10b2c0: 8b 4d 84 mov -0x7c(%ebp),%ecx
10b2c3: 99 cltd
10b2c4: f7 f9 idiv %ecx
10b2c6: 50 push %eax
10b2c7: ff 75 d8 pushl -0x28(%ebp)
10b2ca: 8b 45 b4 mov -0x4c(%ebp),%eax
10b2cd: 99 cltd
10b2ce: f7 f9 idiv %ecx
10b2d0: 50 push %eax
10b2d1: ff 75 b0 pushl -0x50(%ebp)
10b2d4: 8b 45 ac mov -0x54(%ebp),%eax
10b2d7: 99 cltd
10b2d8: f7 f9 idiv %ecx
10b2da: 50 push %eax
10b2db: ff 75 a8 pushl -0x58(%ebp)
10b2de: 68 44 0e 12 00 push $0x120e44
10b2e3: 53 push %ebx
10b2e4: ff d7 call *%edi
10b2e6: 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++ ) {
10b2e9: 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 ;
10b2ea: 3b 35 20 73 12 00 cmp 0x127320,%esi
10b2f0: 0f 86 15 ff ff ff jbe 10b20b <rtems_rate_monotonic_report_statistics_with_plugin+0x57>
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
10b2f6: 8d 65 f4 lea -0xc(%ebp),%esp
10b2f9: 5b pop %ebx
10b2fa: 5e pop %esi
10b2fb: 5f pop %edi
10b2fc: c9 leave
10b2fd: c3 ret
00115b48 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
115b48: 55 push %ebp
115b49: 89 e5 mov %esp,%ebp
115b4b: 53 push %ebx
115b4c: 83 ec 14 sub $0x14,%esp
115b4f: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
115b52: 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 )
115b57: 85 db test %ebx,%ebx
115b59: 74 6d je 115bc8 <rtems_signal_send+0x80>
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
115b5b: 50 push %eax
115b5c: 50 push %eax
115b5d: 8d 45 f4 lea -0xc(%ebp),%eax
115b60: 50 push %eax
115b61: ff 75 08 pushl 0x8(%ebp)
115b64: e8 8f 37 00 00 call 1192f8 <_Thread_Get>
switch ( location ) {
115b69: 83 c4 10 add $0x10,%esp
115b6c: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
115b70: 75 51 jne 115bc3 <rtems_signal_send+0x7b>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
115b72: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
115b78: 83 7a 0c 00 cmpl $0x0,0xc(%edx)
115b7c: 74 39 je 115bb7 <rtems_signal_send+0x6f>
if ( asr->is_enabled ) {
115b7e: 80 7a 08 00 cmpb $0x0,0x8(%edx)
115b82: 74 22 je 115ba6 <rtems_signal_send+0x5e>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115b84: 9c pushf
115b85: fa cli
115b86: 59 pop %ecx
*signal_set |= signals;
115b87: 09 5a 14 or %ebx,0x14(%edx)
_ISR_Enable( _level );
115b8a: 51 push %ecx
115b8b: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
115b8c: 83 3d 0c dc 13 00 00 cmpl $0x0,0x13dc0c
115b93: 74 19 je 115bae <rtems_signal_send+0x66>
115b95: 3b 05 10 dc 13 00 cmp 0x13dc10,%eax
115b9b: 75 11 jne 115bae <rtems_signal_send+0x66><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
115b9d: c6 05 1c dc 13 00 01 movb $0x1,0x13dc1c
115ba4: eb 08 jmp 115bae <rtems_signal_send+0x66>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115ba6: 9c pushf
115ba7: fa cli
115ba8: 58 pop %eax
*signal_set |= signals;
115ba9: 09 5a 18 or %ebx,0x18(%edx)
_ISR_Enable( _level );
115bac: 50 push %eax
115bad: 9d popf
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
115bae: e8 23 37 00 00 call 1192d6 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115bb3: 31 c0 xor %eax,%eax
115bb5: eb 11 jmp 115bc8 <rtems_signal_send+0x80>
}
_Thread_Enable_dispatch();
115bb7: e8 1a 37 00 00 call 1192d6 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
115bbc: b8 0b 00 00 00 mov $0xb,%eax
115bc1: eb 05 jmp 115bc8 <rtems_signal_send+0x80>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115bc3: b8 04 00 00 00 mov $0x4,%eax
}
115bc8: 8b 5d fc mov -0x4(%ebp),%ebx
115bcb: c9 leave
115bcc: c3 ret
001072c4 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
1072c4: 55 push %ebp
1072c5: 89 e5 mov %esp,%ebp
1072c7: 57 push %edi
1072c8: 56 push %esi
1072c9: 8b 45 08 mov 0x8(%ebp),%eax
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
1072cc: 83 78 08 00 cmpl $0x0,0x8(%eax)
1072d0: 74 15 je 1072e7 <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;
1072d2: 8b b8 c8 00 00 00 mov 0xc8(%eax),%edi
1072d8: 83 c7 08 add $0x8,%edi
1072db: be c8 71 12 00 mov $0x1271c8,%esi
1072e0: b9 04 00 00 00 mov $0x4,%ecx
1072e5: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
1072e7: 5e pop %esi
1072e8: 5f pop %edi
1072e9: c9 leave
1072ea: c3 ret
0010729d <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
10729d: 55 push %ebp
10729e: 89 e5 mov %esp,%ebp
1072a0: 57 push %edi
1072a1: 8b 7d 0c mov 0xc(%ebp),%edi
Stack_check_Initialize();
1072a4: e8 8a ff ff ff call 107233 <Stack_check_Initialize>
if (the_thread)
1072a9: 85 ff test %edi,%edi
1072ab: 74 12 je 1072bf <rtems_stack_checker_create_extension+0x22><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
1072ad: 8b 8f c4 00 00 00 mov 0xc4(%edi),%ecx
1072b3: 8b 97 c8 00 00 00 mov 0xc8(%edi),%edx
1072b9: b0 a5 mov $0xa5,%al
1072bb: 89 d7 mov %edx,%edi
1072bd: f3 aa rep stos %al,%es:(%edi)
return true;
}
1072bf: b0 01 mov $0x1,%al
1072c1: 5f pop %edi
1072c2: c9 leave
1072c3: c3 ret
001073f8 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
1073f8: 55 push %ebp
1073f9: 89 e5 mov %esp,%ebp
1073fb: 53 push %ebx
1073fc: 83 ec 04 sub $0x4,%esp
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
1073ff: a1 e8 78 12 00 mov 0x1278e8,%eax
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
107404: 8b 90 c8 00 00 00 mov 0xc8(%eax),%edx
return false;
10740a: 31 db xor %ebx,%ebx
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
10740c: 39 d5 cmp %edx,%ebp
10740e: 72 0e jb 10741e <rtems_stack_checker_is_blown+0x26><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
107410: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax
107416: 8d 04 02 lea (%edx,%eax,1),%eax
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
107419: 39 c5 cmp %eax,%ebp
10741b: 0f 96 c3 setbe %bl
{
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
bool sp_ok;
bool pattern_ok = true;
10741e: b0 01 mov $0x1,%al
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
107420: 83 3d b8 6e 12 00 00 cmpl $0x0,0x126eb8
107427: 74 19 je 107442 <rtems_stack_checker_is_blown+0x4a><== NEVER TAKEN
pattern_ok = (!memcmp(
(void *) Stack_check_Get_pattern_area(the_stack)->pattern,
107429: 83 c2 08 add $0x8,%edx
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
pattern_ok = (!memcmp(
10742c: 51 push %ecx
10742d: 6a 10 push $0x10
10742f: 68 c8 71 12 00 push $0x1271c8
107434: 52 push %edx
107435: e8 ce ca 00 00 call 113f08 <memcmp>
10743a: 83 c4 10 add $0x10,%esp
10743d: 85 c0 test %eax,%eax
10743f: 0f 94 c0 sete %al
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
107442: 84 db test %bl,%bl
107444: 74 04 je 10744a <rtems_stack_checker_is_blown+0x52><== NEVER TAKEN
107446: 84 c0 test %al,%al
107448: 75 11 jne 10745b <rtems_stack_checker_is_blown+0x63><== ALWAYS TAKEN
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
10744a: 52 push %edx <== NOT EXECUTED
10744b: 52 push %edx <== NOT EXECUTED
10744c: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
10744f: 50 push %eax <== NOT EXECUTED
107450: ff 35 e8 78 12 00 pushl 0x1278e8 <== NOT EXECUTED
107456: e8 90 fe ff ff call 1072eb <Stack_check_report_blown_task><== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
10745b: 31 c0 xor %eax,%eax
10745d: 8b 5d fc mov -0x4(%ebp),%ebx
107460: c9 leave
107461: c3 ret
001074c7 <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
1074c7: 55 push %ebp <== NOT EXECUTED
1074c8: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1074ca: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
1074cd: 68 2c 8c 10 00 push $0x108c2c <== NOT EXECUTED
1074d2: 6a 00 push $0x0 <== NOT EXECUTED
1074d4: e8 89 ff ff ff call 107462 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
1074d9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1074dc: c9 leave <== NOT EXECUTED
1074dd: c3 ret <== NOT EXECUTED
00107462 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
107462: 55 push %ebp <== NOT EXECUTED
107463: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107465: 56 push %esi <== NOT EXECUTED
107466: 53 push %ebx <== NOT EXECUTED
107467: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
10746a: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
if ( !print )
10746d: 85 db test %ebx,%ebx <== NOT EXECUTED
10746f: 74 4f je 1074c0 <rtems_stack_checker_report_usage_with_plugin+0x5e><== NOT EXECUTED
return;
print_context = context;
107471: 89 35 b0 6e 12 00 mov %esi,0x126eb0 <== NOT EXECUTED
print_handler = print;
107477: 89 1d b4 6e 12 00 mov %ebx,0x126eb4 <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
10747d: 51 push %ecx <== NOT EXECUTED
10747e: 51 push %ecx <== NOT EXECUTED
10747f: 68 c7 0d 12 00 push $0x120dc7 <== NOT EXECUTED
107484: 56 push %esi <== NOT EXECUTED
107485: ff d3 call *%ebx <== NOT EXECUTED
(*print)( context,
107487: 58 pop %eax <== NOT EXECUTED
107488: 5a pop %edx <== NOT EXECUTED
107489: 68 de 0d 12 00 push $0x120dde <== NOT EXECUTED
10748e: 56 push %esi <== NOT EXECUTED
10748f: 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 );
107491: c7 04 24 18 71 10 00 movl $0x107118,(%esp) <== NOT EXECUTED
107498: e8 b3 63 00 00 call 10d850 <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);
10749d: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED
1074a4: e8 6f fc ff ff call 107118 <Stack_check_Dump_threads_usage><== NOT EXECUTED
#endif
print_context = NULL;
1074a9: c7 05 b0 6e 12 00 00 movl $0x0,0x126eb0 <== NOT EXECUTED
1074b0: 00 00 00
print_handler = NULL;
1074b3: c7 05 b4 6e 12 00 00 movl $0x0,0x126eb4 <== NOT EXECUTED
1074ba: 00 00 00
1074bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1074c0: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
1074c3: 5b pop %ebx <== NOT EXECUTED
1074c4: 5e pop %esi <== NOT EXECUTED
1074c5: c9 leave <== NOT EXECUTED
1074c6: c3 ret <== NOT EXECUTED
0010739f <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
10739f: 55 push %ebp
1073a0: 89 e5 mov %esp,%ebp
1073a2: 53 push %ebx
1073a3: 83 ec 14 sub $0x14,%esp
1073a6: 8b 5d 08 mov 0x8(%ebp),%ebx
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = (void *) Stack_check_Get_pattern_area(the_stack)->pattern;
1073a9: 8b 83 c8 00 00 00 mov 0xc8(%ebx),%eax
1073af: 8d 48 08 lea 0x8(%eax),%ecx
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
1073b2: 31 d2 xor %edx,%edx
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
1073b4: 39 c5 cmp %eax,%ebp
1073b6: 72 0b jb 1073c3 <rtems_stack_checker_switch_extension+0x24><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
1073b8: 03 83 c4 00 00 00 add 0xc4(%ebx),%eax
}
/*
* rtems_stack_checker_switch_extension
*/
void rtems_stack_checker_switch_extension(
1073be: 39 c5 cmp %eax,%ebp
1073c0: 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,
1073c3: 50 push %eax
1073c4: 6a 10 push $0x10
1073c6: 68 c8 71 12 00 push $0x1271c8
1073cb: 51 push %ecx
1073cc: 88 55 f4 mov %dl,-0xc(%ebp)
1073cf: e8 34 cb 00 00 call 113f08 <memcmp>
1073d4: 83 c4 10 add $0x10,%esp
1073d7: 85 c0 test %eax,%eax
1073d9: 0f 94 c0 sete %al
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
1073dc: 8a 55 f4 mov -0xc(%ebp),%dl
1073df: 84 d2 test %dl,%dl
1073e1: 74 04 je 1073e7 <rtems_stack_checker_switch_extension+0x48><== NEVER TAKEN
1073e3: 84 c0 test %al,%al
1073e5: 75 0c jne 1073f3 <rtems_stack_checker_switch_extension+0x54><== ALWAYS TAKEN
Stack_check_report_blown_task( running, pattern_ok );
1073e7: 52 push %edx <== NOT EXECUTED
1073e8: 52 push %edx <== NOT EXECUTED
1073e9: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
1073ec: 50 push %eax <== NOT EXECUTED
1073ed: 53 push %ebx <== NOT EXECUTED
1073ee: e8 f8 fe ff ff call 1072eb <Stack_check_report_blown_task><== NOT EXECUTED
}
}
1073f3: 8b 5d fc mov -0x4(%ebp),%ebx
1073f6: c9 leave
1073f7: c3 ret
0010ef00 <rtems_string_to_double>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10ef00: 55 push %ebp
10ef01: 89 e5 mov %esp,%ebp
10ef03: 57 push %edi
10ef04: 56 push %esi
10ef05: 53 push %ebx
10ef06: 83 ec 2c sub $0x2c,%esp
10ef09: 8b 75 08 mov 0x8(%ebp),%esi
10ef0c: 8b 5d 0c mov 0xc(%ebp),%ebx
10ef0f: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10ef12: b8 09 00 00 00 mov $0x9,%eax
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10ef17: 85 db test %ebx,%ebx
10ef19: 74 6e je 10ef89 <rtems_string_to_double+0x89>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10ef1b: e8 f8 2a 00 00 call 111a18 <__errno>
10ef20: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10ef26: c7 03 00 00 00 00 movl $0x0,(%ebx)
10ef2c: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
10ef33: 50 push %eax
10ef34: 50 push %eax
10ef35: 8d 45 e4 lea -0x1c(%ebp),%eax
10ef38: 50 push %eax
10ef39: 56 push %esi
10ef3a: e8 85 55 00 00 call 1144c4 <strtod>
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
10ef3f: 83 c4 10 add $0x10,%esp
10ef42: 85 ff test %edi,%edi
10ef44: 74 05 je 10ef4b <rtems_string_to_double+0x4b>
*endptr = end;
10ef46: 8b 45 e4 mov -0x1c(%ebp),%eax
10ef49: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10ef4b: b8 0b 00 00 00 mov $0xb,%eax
/* If the user wants the end pointer back, then return it. */
if ( endptr )
*endptr = end;
/* nothing was converted */
if ( end == s )
10ef50: 39 75 e4 cmp %esi,-0x1c(%ebp)
10ef53: 74 2e je 10ef83 <rtems_string_to_double+0x83>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10ef55: dd 05 f0 33 12 00 fldl 0x1233f0
10ef5b: d9 c9 fxch %st(1)
10ef5d: dd e1 fucom %st(1)
10ef5f: df e0 fnstsw %ax
10ef61: dd d9 fstp %st(1)
10ef63: 9e sahf
10ef64: 76 17 jbe 10ef7d <rtems_string_to_double+0x7d>
10ef66: dd 5d c8 fstpl -0x38(%ebp)
10ef69: e8 aa 2a 00 00 call 111a18 <__errno>
10ef6e: 89 c2 mov %eax,%edx
return RTEMS_INVALID_NUMBER;
10ef70: b8 0a 00 00 00 mov $0xa,%eax
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10ef75: 83 3a 22 cmpl $0x22,(%edx)
10ef78: dd 45 c8 fldl -0x38(%ebp)
10ef7b: 74 0a je 10ef87 <rtems_string_to_double+0x87><== ALWAYS TAKEN
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
10ef7d: dd 1b fstpl (%ebx)
#endif
return RTEMS_SUCCESSFUL;
10ef7f: 31 c0 xor %eax,%eax
10ef81: eb 06 jmp 10ef89 <rtems_string_to_double+0x89>
10ef83: dd d8 fstp %st(0)
10ef85: eb 02 jmp 10ef89 <rtems_string_to_double+0x89>
10ef87: dd d8 fstp %st(0)
}
10ef89: 8d 65 f4 lea -0xc(%ebp),%esp
10ef8c: 5b pop %ebx
10ef8d: 5e pop %esi
10ef8e: 5f pop %edi
10ef8f: c9 leave
10ef90: c3 ret
0010ef94 <rtems_string_to_float>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10ef94: 55 push %ebp
10ef95: 89 e5 mov %esp,%ebp
10ef97: 57 push %edi
10ef98: 56 push %esi
10ef99: 53 push %ebx
10ef9a: 83 ec 2c sub $0x2c,%esp
10ef9d: 8b 75 08 mov 0x8(%ebp),%esi
10efa0: 8b 5d 0c mov 0xc(%ebp),%ebx
10efa3: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10efa6: b8 09 00 00 00 mov $0x9,%eax
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10efab: 85 db test %ebx,%ebx
10efad: 74 67 je 10f016 <rtems_string_to_float+0x82><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
errno = 0;
10efaf: e8 64 2a 00 00 call 111a18 <__errno>
10efb4: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10efba: c7 03 00 00 00 00 movl $0x0,(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
10efc0: 50 push %eax
10efc1: 50 push %eax
10efc2: 8d 45 e4 lea -0x1c(%ebp),%eax
10efc5: 50 push %eax
10efc6: 56 push %esi
10efc7: e8 14 55 00 00 call 1144e0 <strtof>
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
10efcc: 83 c4 10 add $0x10,%esp
10efcf: 85 ff test %edi,%edi
10efd1: 74 05 je 10efd8 <rtems_string_to_float+0x44>
*endptr = end;
10efd3: 8b 45 e4 mov -0x1c(%ebp),%eax
10efd6: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10efd8: b8 0b 00 00 00 mov $0xb,%eax
/* If the user wants the end pointer back, then return it. */
if ( endptr )
*endptr = end;
/* nothing was converted */
if ( end == s )
10efdd: 39 75 e4 cmp %esi,-0x1c(%ebp)
10efe0: 74 2e je 10f010 <rtems_string_to_float+0x7c><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10efe2: d9 05 f8 33 12 00 flds 0x1233f8
10efe8: d9 c9 fxch %st(1)
10efea: dd e1 fucom %st(1)
10efec: df e0 fnstsw %ax
10efee: dd d9 fstp %st(1)
10eff0: 9e sahf
10eff1: 76 17 jbe 10f00a <rtems_string_to_float+0x76><== NEVER TAKEN
10eff3: d9 5d c8 fstps -0x38(%ebp)
10eff6: e8 1d 2a 00 00 call 111a18 <__errno>
10effb: 89 c2 mov %eax,%edx
return RTEMS_INVALID_NUMBER;
10effd: b8 0a 00 00 00 mov $0xa,%eax
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10f002: 83 3a 22 cmpl $0x22,(%edx)
10f005: d9 45 c8 flds -0x38(%ebp)
10f008: 74 0a je 10f014 <rtems_string_to_float+0x80><== ALWAYS TAKEN
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
10f00a: d9 1b fstps (%ebx)
#endif
return RTEMS_SUCCESSFUL;
10f00c: 31 c0 xor %eax,%eax
10f00e: eb 06 jmp 10f016 <rtems_string_to_float+0x82>
10f010: dd d8 fstp %st(0)
10f012: eb 02 jmp 10f016 <rtems_string_to_float+0x82>
10f014: dd d8 fstp %st(0)
}
10f016: 8d 65 f4 lea -0xc(%ebp),%esp
10f019: 5b pop %ebx
10f01a: 5e pop %esi
10f01b: 5f pop %edi
10f01c: c9 leave
10f01d: c3 ret
0010f0a0 <rtems_string_to_long_long>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10f0a0: 55 push %ebp
10f0a1: 89 e5 mov %esp,%ebp
10f0a3: 57 push %edi
10f0a4: 56 push %esi
10f0a5: 53 push %ebx
10f0a6: 83 ec 2c sub $0x2c,%esp
10f0a9: 8b 5d 0c mov 0xc(%ebp),%ebx
10f0ac: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f0af: b9 09 00 00 00 mov $0x9,%ecx
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10f0b4: 85 db test %ebx,%ebx
10f0b6: 74 76 je 10f12e <rtems_string_to_long_long+0x8e>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f0b8: e8 5b 29 00 00 call 111a18 <__errno>
10f0bd: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f0c3: c7 03 00 00 00 00 movl $0x0,(%ebx)
10f0c9: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
10f0d0: 50 push %eax
10f0d1: ff 75 14 pushl 0x14(%ebp)
10f0d4: 8d 45 e4 lea -0x1c(%ebp),%eax
10f0d7: 50 push %eax
10f0d8: ff 75 08 pushl 0x8(%ebp)
10f0db: e8 e0 55 00 00 call 1146c0 <strtoll>
10f0e0: 89 c6 mov %eax,%esi
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
10f0e2: 83 c4 10 add $0x10,%esp
10f0e5: 85 ff test %edi,%edi
10f0e7: 74 05 je 10f0ee <rtems_string_to_long_long+0x4e>
*endptr = end;
10f0e9: 8b 45 e4 mov -0x1c(%ebp),%eax
10f0ec: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10f0ee: b9 0b 00 00 00 mov $0xb,%ecx
/* If the user wants the end pointer back, then return it. */
if ( endptr )
*endptr = end;
/* nothing was converted */
if ( end == s )
10f0f3: 8b 45 08 mov 0x8(%ebp),%eax
10f0f6: 39 45 e4 cmp %eax,-0x1c(%ebp)
10f0f9: 74 33 je 10f12e <rtems_string_to_long_long+0x8e>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10f0fb: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
10f101: 75 05 jne 10f108 <rtems_string_to_long_long+0x68>
10f103: 83 fe ff cmp $0xffffffff,%esi
10f106: 74 0a je 10f112 <rtems_string_to_long_long+0x72><== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MIN
/* there was an underflow */
if ( (result == STRING_TO_MIN) && (errno == ERANGE))
10f108: 8d 82 00 00 00 80 lea -0x80000000(%edx),%eax
10f10e: 09 f0 or %esi,%eax
10f110: 75 15 jne 10f127 <rtems_string_to_long_long+0x87>
10f112: 89 55 d4 mov %edx,-0x2c(%ebp)
10f115: e8 fe 28 00 00 call 111a18 <__errno>
return RTEMS_INVALID_NUMBER;
10f11a: b9 0a 00 00 00 mov $0xa,%ecx
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MIN
/* there was an underflow */
if ( (result == STRING_TO_MIN) && (errno == ERANGE))
10f11f: 83 38 22 cmpl $0x22,(%eax)
10f122: 8b 55 d4 mov -0x2c(%ebp),%edx
10f125: 74 07 je 10f12e <rtems_string_to_long_long+0x8e>
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
10f127: 89 33 mov %esi,(%ebx)
10f129: 89 53 04 mov %edx,0x4(%ebx)
#endif
return RTEMS_SUCCESSFUL;
10f12c: 31 c9 xor %ecx,%ecx
}
10f12e: 89 c8 mov %ecx,%eax
10f130: 8d 65 f4 lea -0xc(%ebp),%esp
10f133: 5b pop %ebx
10f134: 5e pop %esi
10f135: 5f pop %edi
10f136: c9 leave
10f137: c3 ret
0010f1c0 <rtems_string_to_pointer>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10f1c0: 55 push %ebp
10f1c1: 89 e5 mov %esp,%ebp
10f1c3: 57 push %edi
10f1c4: 56 push %esi
10f1c5: 53 push %ebx
10f1c6: 83 ec 2c sub $0x2c,%esp
10f1c9: 8b 7d 08 mov 0x8(%ebp),%edi
10f1cc: 8b 5d 0c mov 0xc(%ebp),%ebx
10f1cf: 8b 55 10 mov 0x10(%ebp),%edx
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f1d2: b8 09 00 00 00 mov $0x9,%eax
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10f1d7: 85 db test %ebx,%ebx
10f1d9: 74 56 je 10f231 <rtems_string_to_pointer+0x71>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f1db: 89 55 d4 mov %edx,-0x2c(%ebp)
10f1de: e8 35 28 00 00 call 111a18 <__errno>
10f1e3: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f1e9: c7 03 00 00 00 00 movl $0x0,(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
10f1ef: 50 push %eax
10f1f0: 6a 10 push $0x10
10f1f2: 8d 45 e4 lea -0x1c(%ebp),%eax
10f1f5: 50 push %eax
10f1f6: 57 push %edi
10f1f7: e8 70 59 00 00 call 114b6c <strtoul>
10f1fc: 89 c6 mov %eax,%esi
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
10f1fe: 83 c4 10 add $0x10,%esp
10f201: 8b 55 d4 mov -0x2c(%ebp),%edx
10f204: 85 d2 test %edx,%edx
10f206: 74 05 je 10f20d <rtems_string_to_pointer+0x4d>
*endptr = end;
10f208: 8b 45 e4 mov -0x1c(%ebp),%eax
10f20b: 89 02 mov %eax,(%edx)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10f20d: b8 0b 00 00 00 mov $0xb,%eax
/* If the user wants the end pointer back, then return it. */
if ( endptr )
*endptr = end;
/* nothing was converted */
if ( end == s )
10f212: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f215: 74 1a je 10f231 <rtems_string_to_pointer+0x71>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10f217: 83 fe ff cmp $0xffffffff,%esi
10f21a: 75 11 jne 10f22d <rtems_string_to_pointer+0x6d><== ALWAYS TAKEN
10f21c: e8 f7 27 00 00 call 111a18 <__errno> <== NOT EXECUTED
10f221: 89 c2 mov %eax,%edx <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
10f223: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10f228: 83 3a 22 cmpl $0x22,(%edx) <== NOT EXECUTED
10f22b: 74 04 je 10f231 <rtems_string_to_pointer+0x71><== NOT EXECUTED
if ( (result == STRING_TO_MIN) && (errno == ERANGE))
return RTEMS_INVALID_NUMBER;
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
10f22d: 89 33 mov %esi,(%ebx)
#else
*n = (STRING_TO_TYPE) result;
#endif
return RTEMS_SUCCESSFUL;
10f22f: 31 c0 xor %eax,%eax
}
10f231: 8d 65 f4 lea -0xc(%ebp),%esp
10f234: 5b pop %ebx
10f235: 5e pop %esi
10f236: 5f pop %edi
10f237: c9 leave
10f238: c3 ret
0010f298 <rtems_string_to_unsigned_int>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10f298: 55 push %ebp
10f299: 89 e5 mov %esp,%ebp
10f29b: 57 push %edi
10f29c: 56 push %esi
10f29d: 53 push %ebx
10f29e: 83 ec 2c sub $0x2c,%esp
10f2a1: 8b 7d 08 mov 0x8(%ebp),%edi
10f2a4: 8b 5d 0c mov 0xc(%ebp),%ebx
10f2a7: 8b 55 10 mov 0x10(%ebp),%edx
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f2aa: b8 09 00 00 00 mov $0x9,%eax
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10f2af: 85 db test %ebx,%ebx
10f2b1: 74 57 je 10f30a <rtems_string_to_unsigned_int+0x72>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f2b3: 89 55 d4 mov %edx,-0x2c(%ebp)
10f2b6: e8 5d 27 00 00 call 111a18 <__errno>
10f2bb: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f2c1: c7 03 00 00 00 00 movl $0x0,(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
10f2c7: 50 push %eax
10f2c8: ff 75 14 pushl 0x14(%ebp)
10f2cb: 8d 45 e4 lea -0x1c(%ebp),%eax
10f2ce: 50 push %eax
10f2cf: 57 push %edi
10f2d0: e8 97 58 00 00 call 114b6c <strtoul>
10f2d5: 89 c6 mov %eax,%esi
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
10f2d7: 83 c4 10 add $0x10,%esp
10f2da: 8b 55 d4 mov -0x2c(%ebp),%edx
10f2dd: 85 d2 test %edx,%edx
10f2df: 74 05 je 10f2e6 <rtems_string_to_unsigned_int+0x4e>
*endptr = end;
10f2e1: 8b 45 e4 mov -0x1c(%ebp),%eax
10f2e4: 89 02 mov %eax,(%edx)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10f2e6: b8 0b 00 00 00 mov $0xb,%eax
/* If the user wants the end pointer back, then return it. */
if ( endptr )
*endptr = end;
/* nothing was converted */
if ( end == s )
10f2eb: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f2ee: 74 1a je 10f30a <rtems_string_to_unsigned_int+0x72>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10f2f0: 83 fe ff cmp $0xffffffff,%esi
10f2f3: 75 11 jne 10f306 <rtems_string_to_unsigned_int+0x6e>
10f2f5: e8 1e 27 00 00 call 111a18 <__errno>
10f2fa: 89 c2 mov %eax,%edx
return RTEMS_INVALID_NUMBER;
10f2fc: b8 0a 00 00 00 mov $0xa,%eax
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10f301: 83 3a 22 cmpl $0x22,(%edx)
10f304: 74 04 je 10f30a <rtems_string_to_unsigned_int+0x72><== ALWAYS TAKEN
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
10f306: 89 33 mov %esi,(%ebx)
#endif
return RTEMS_SUCCESSFUL;
10f308: 31 c0 xor %eax,%eax
}
10f30a: 8d 65 f4 lea -0xc(%ebp),%esp
10f30d: 5b pop %ebx
10f30e: 5e pop %esi
10f30f: 5f pop %edi
10f310: c9 leave
10f311: c3 ret
0010f3a0 <rtems_string_to_unsigned_long>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10f3a0: 55 push %ebp
10f3a1: 89 e5 mov %esp,%ebp
10f3a3: 57 push %edi
10f3a4: 56 push %esi
10f3a5: 53 push %ebx
10f3a6: 83 ec 2c sub $0x2c,%esp
10f3a9: 8b 7d 08 mov 0x8(%ebp),%edi
10f3ac: 8b 5d 0c mov 0xc(%ebp),%ebx
10f3af: 8b 55 10 mov 0x10(%ebp),%edx
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f3b2: b8 09 00 00 00 mov $0x9,%eax
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10f3b7: 85 db test %ebx,%ebx
10f3b9: 74 57 je 10f412 <rtems_string_to_unsigned_long+0x72>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f3bb: 89 55 d4 mov %edx,-0x2c(%ebp)
10f3be: e8 55 26 00 00 call 111a18 <__errno>
10f3c3: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f3c9: c7 03 00 00 00 00 movl $0x0,(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
10f3cf: 50 push %eax
10f3d0: ff 75 14 pushl 0x14(%ebp)
10f3d3: 8d 45 e4 lea -0x1c(%ebp),%eax
10f3d6: 50 push %eax
10f3d7: 57 push %edi
10f3d8: e8 8f 57 00 00 call 114b6c <strtoul>
10f3dd: 89 c6 mov %eax,%esi
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
10f3df: 83 c4 10 add $0x10,%esp
10f3e2: 8b 55 d4 mov -0x2c(%ebp),%edx
10f3e5: 85 d2 test %edx,%edx
10f3e7: 74 05 je 10f3ee <rtems_string_to_unsigned_long+0x4e>
*endptr = end;
10f3e9: 8b 45 e4 mov -0x1c(%ebp),%eax
10f3ec: 89 02 mov %eax,(%edx)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10f3ee: b8 0b 00 00 00 mov $0xb,%eax
/* If the user wants the end pointer back, then return it. */
if ( endptr )
*endptr = end;
/* nothing was converted */
if ( end == s )
10f3f3: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f3f6: 74 1a je 10f412 <rtems_string_to_unsigned_long+0x72>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10f3f8: 83 fe ff cmp $0xffffffff,%esi
10f3fb: 75 11 jne 10f40e <rtems_string_to_unsigned_long+0x6e>
10f3fd: e8 16 26 00 00 call 111a18 <__errno>
10f402: 89 c2 mov %eax,%edx
return RTEMS_INVALID_NUMBER;
10f404: b8 0a 00 00 00 mov $0xa,%eax
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10f409: 83 3a 22 cmpl $0x22,(%edx)
10f40c: 74 04 je 10f412 <rtems_string_to_unsigned_long+0x72><== ALWAYS TAKEN
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
10f40e: 89 33 mov %esi,(%ebx)
#endif
return RTEMS_SUCCESSFUL;
10f410: 31 c0 xor %eax,%eax
}
10f412: 8d 65 f4 lea -0xc(%ebp),%esp
10f415: 5b pop %ebx
10f416: 5e pop %esi
10f417: 5f pop %edi
10f418: c9 leave
10f419: c3 ret
0010f314 <rtems_string_to_unsigned_long_long>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10f314: 55 push %ebp
10f315: 89 e5 mov %esp,%ebp
10f317: 57 push %edi
10f318: 56 push %esi
10f319: 53 push %ebx
10f31a: 83 ec 2c sub $0x2c,%esp
10f31d: 8b 5d 0c mov 0xc(%ebp),%ebx
10f320: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f323: b8 09 00 00 00 mov $0x9,%eax
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10f328: 85 db test %ebx,%ebx
10f32a: 74 6b je 10f397 <rtems_string_to_unsigned_long_long+0x83>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f32c: e8 e7 26 00 00 call 111a18 <__errno>
10f331: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f337: c7 03 00 00 00 00 movl $0x0,(%ebx)
10f33d: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
10f344: 50 push %eax
10f345: ff 75 14 pushl 0x14(%ebp)
10f348: 8d 45 e4 lea -0x1c(%ebp),%eax
10f34b: 50 push %eax
10f34c: ff 75 08 pushl 0x8(%ebp)
10f34f: e8 34 58 00 00 call 114b88 <strtoull>
10f354: 89 c6 mov %eax,%esi
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
10f356: 83 c4 10 add $0x10,%esp
10f359: 85 ff test %edi,%edi
10f35b: 74 05 je 10f362 <rtems_string_to_unsigned_long_long+0x4e>
*endptr = end;
10f35d: 8b 45 e4 mov -0x1c(%ebp),%eax
10f360: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10f362: b8 0b 00 00 00 mov $0xb,%eax
/* If the user wants the end pointer back, then return it. */
if ( endptr )
*endptr = end;
/* nothing was converted */
if ( end == s )
10f367: 8b 4d 08 mov 0x8(%ebp),%ecx
10f36a: 39 4d e4 cmp %ecx,-0x1c(%ebp)
10f36d: 74 28 je 10f397 <rtems_string_to_unsigned_long_long+0x83>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10f36f: 83 fa ff cmp $0xffffffff,%edx
10f372: 75 1c jne 10f390 <rtems_string_to_unsigned_long_long+0x7c>
10f374: 83 fe ff cmp $0xffffffff,%esi
10f377: 75 17 jne 10f390 <rtems_string_to_unsigned_long_long+0x7c><== NEVER TAKEN
10f379: 89 55 d4 mov %edx,-0x2c(%ebp)
10f37c: e8 97 26 00 00 call 111a18 <__errno>
10f381: 89 c1 mov %eax,%ecx
return RTEMS_INVALID_NUMBER;
10f383: b8 0a 00 00 00 mov $0xa,%eax
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10f388: 83 39 22 cmpl $0x22,(%ecx)
10f38b: 8b 55 d4 mov -0x2c(%ebp),%edx
10f38e: 74 07 je 10f397 <rtems_string_to_unsigned_long_long+0x83><== ALWAYS TAKEN
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
10f390: 89 33 mov %esi,(%ebx)
10f392: 89 53 04 mov %edx,0x4(%ebx)
#endif
return RTEMS_SUCCESSFUL;
10f395: 31 c0 xor %eax,%eax
}
10f397: 8d 65 f4 lea -0xc(%ebp),%esp
10f39a: 5b pop %ebx
10f39b: 5e pop %esi
10f39c: 5f pop %edi
10f39d: c9 leave
10f39e: c3 ret
0010708c <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
10708c: 55 push %ebp
10708d: 89 e5 mov %esp,%ebp
10708f: 57 push %edi
107090: 56 push %esi
107091: 53 push %ebx
107092: 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(
107098: 31 c0 xor %eax,%eax
10709a: 83 c9 ff or $0xffffffff,%ecx
10709d: 8b 7d 08 mov 0x8(%ebp),%edi
1070a0: f2 ae repnz scas %es:(%edi),%al
1070a2: f7 d1 not %ecx
1070a4: 49 dec %ecx
1070a5: 6a 00 push $0x0
1070a7: 8d 45 d0 lea -0x30(%ebp),%eax
1070aa: 50 push %eax
1070ab: 6a 00 push $0x0
1070ad: 51 push %ecx
1070ae: ff 75 08 pushl 0x8(%ebp)
1070b1: e8 d4 09 00 00 call 107a8a <rtems_filesystem_evaluate_path>
1070b6: 89 85 54 fe ff ff mov %eax,-0x1ac(%ebp)
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
1070bc: 83 c4 20 add $0x20,%esp
1070bf: 85 c0 test %eax,%eax
1070c1: 0f 85 d9 01 00 00 jne 1072a0 <rtems_tarfs_load+0x214>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
1070c7: 8b 45 dc mov -0x24(%ebp),%eax
1070ca: 31 f6 xor %esi,%esi
1070cc: 3d 24 3c 12 00 cmp $0x123c24,%eax
1070d1: 74 1b je 1070ee <rtems_tarfs_load+0x62>
1070d3: 3d 1c 46 12 00 cmp $0x12461c,%eax
1070d8: 0f 85 c2 01 00 00 jne 1072a0 <rtems_tarfs_load+0x214><== ALWAYS TAKEN
1070de: 8b b5 54 fe ff ff mov -0x1ac(%ebp),%esi <== NOT EXECUTED
1070e4: eb 08 jmp 1070ee <rtems_tarfs_load+0x62> <== NOT EXECUTED
1070e6: 8b b5 50 fe ff ff mov -0x1b0(%ebp),%esi
1070ec: eb 18 jmp 107106 <rtems_tarfs_load+0x7a>
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
1070ee: 8d 45 bc lea -0x44(%ebp),%eax
1070f1: 89 85 34 fe ff ff mov %eax,-0x1cc(%ebp)
1070f7: 8d 55 d0 lea -0x30(%ebp),%edx
1070fa: 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);
107100: 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)
107106: 8d 86 00 02 00 00 lea 0x200(%esi),%eax
10710c: 89 85 50 fe ff ff mov %eax,-0x1b0(%ebp)
107112: 8b 55 10 mov 0x10(%ebp),%edx
107115: 39 d0 cmp %edx,%eax
107117: 0f 87 8d 01 00 00 ja 1072aa <rtems_tarfs_load+0x21e><== NEVER TAKEN
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
10711d: 03 75 0c add 0xc(%ebp),%esi
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
107120: 8d 86 01 01 00 00 lea 0x101(%esi),%eax
107126: 52 push %edx
107127: 6a 05 push $0x5
107129: 68 6c 3c 12 00 push $0x123c6c
10712e: 50 push %eax
10712f: e8 58 e5 00 00 call 11568c <strncmp>
107134: 83 c4 10 add $0x10,%esp
107137: 85 c0 test %eax,%eax
107139: 0f 85 6b 01 00 00 jne 1072aa <rtems_tarfs_load+0x21e>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
10713f: 50 push %eax
107140: 6a 63 push $0x63
107142: 56 push %esi
107143: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax
107149: 50 push %eax
10714a: e8 cd e5 00 00 call 11571c <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
10714f: c6 45 bb 00 movb $0x0,-0x45(%ebp)
linkflag = hdr_ptr[156];
107153: 8a 96 9c 00 00 00 mov 0x9c(%esi),%dl
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
107159: 59 pop %ecx
10715a: 5f pop %edi
10715b: 6a 08 push $0x8
10715d: 8d 46 64 lea 0x64(%esi),%eax
107160: 50 push %eax
107161: 88 95 44 fe ff ff mov %dl,-0x1bc(%ebp)
107167: e8 64 6d 00 00 call 10ded0 <_rtems_octal2ulong>
10716c: 89 85 48 fe ff ff mov %eax,-0x1b8(%ebp)
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
107172: 5f pop %edi
107173: 58 pop %eax
107174: 6a 0c push $0xc
107176: 8d 46 7c lea 0x7c(%esi),%eax
107179: 50 push %eax
10717a: e8 51 6d 00 00 call 10ded0 <_rtems_octal2ulong>
10717f: 89 85 4c fe ff ff mov %eax,-0x1b4(%ebp)
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
107185: 5a pop %edx
107186: 59 pop %ecx
107187: 6a 08 push $0x8
107189: 8d 86 94 00 00 00 lea 0x94(%esi),%eax
10718f: 50 push %eax
107190: e8 3b 6d 00 00 call 10ded0 <_rtems_octal2ulong>
107195: 89 c7 mov %eax,%edi
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
107197: 89 34 24 mov %esi,(%esp)
10719a: e8 5f 6d 00 00 call 10defe <_rtems_tar_header_checksum>
10719f: 83 c4 10 add $0x10,%esp
1071a2: 39 f8 cmp %edi,%eax
1071a4: 8a 95 44 fe ff ff mov -0x1bc(%ebp),%dl
1071aa: 0f 85 fa 00 00 00 jne 1072aa <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) {
1071b0: 80 fa 35 cmp $0x35,%dl
1071b3: 75 57 jne 10720c <rtems_tarfs_load+0x180>
strcpy(full_filename, mountpoint);
1071b5: 50 push %eax
1071b6: 50 push %eax
1071b7: ff 75 08 pushl 0x8(%ebp)
1071ba: 53 push %ebx
1071bb: e8 64 e1 00 00 call 115324 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
1071c0: 31 c0 xor %eax,%eax
1071c2: 83 c9 ff or $0xffffffff,%ecx
1071c5: 89 df mov %ebx,%edi
1071c7: f2 ae repnz scas %es:(%edi),%al
1071c9: f7 d1 not %ecx
1071cb: 83 c4 10 add $0x10,%esp
1071ce: 80 bc 0d 56 fe ff ff cmpb $0x2f,-0x1aa(%ebp,%ecx,1)
1071d5: 2f
1071d6: 74 10 je 1071e8 <rtems_tarfs_load+0x15c><== ALWAYS TAKEN
strcat(full_filename, "/");
1071d8: 57 push %edi <== NOT EXECUTED
1071d9: 57 push %edi <== NOT EXECUTED
1071da: 68 19 fb 11 00 push $0x11fb19 <== NOT EXECUTED
1071df: 53 push %ebx <== NOT EXECUTED
1071e0: e8 8b df 00 00 call 115170 <strcat> <== NOT EXECUTED
1071e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
strcat(full_filename, filename);
1071e8: 56 push %esi
1071e9: 56 push %esi
1071ea: 8d 95 58 ff ff ff lea -0xa8(%ebp),%edx
1071f0: 52 push %edx
1071f1: 53 push %ebx
1071f2: e8 79 df 00 00 call 115170 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
1071f7: 5a pop %edx
1071f8: 59 pop %ecx
1071f9: 68 ff 01 00 00 push $0x1ff
1071fe: 53 push %ebx
1071ff: e8 58 0f 00 00 call 10815c <mkdir>
107204: 83 c4 10 add $0x10,%esp
107207: e9 da fe ff ff jmp 1070e6 <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) {
10720c: 80 fa 30 cmp $0x30,%dl
10720f: 0f 85 d1 fe ff ff jne 1070e6 <rtems_tarfs_load+0x5a>
const char *name;
loc = root_loc;
107215: b9 05 00 00 00 mov $0x5,%ecx
10721a: 8b bd 34 fe ff ff mov -0x1cc(%ebp),%edi
107220: 8b b5 30 fe ff ff mov -0x1d0(%ebp),%esi
107226: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
107228: 50 push %eax
107229: 8d 45 e4 lea -0x1c(%ebp),%eax
10722c: 50 push %eax
10722d: 8d 55 bc lea -0x44(%ebp),%edx
107230: 52 push %edx
107231: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax
107237: 50 push %eax
107238: e8 bf 77 00 00 call 10e9fc <IMFS_evaluate_for_make>
10723d: 83 c4 10 add $0x10,%esp
107240: 85 c0 test %eax,%eax
107242: 75 41 jne 107285 <rtems_tarfs_load+0x1f9><== NEVER TAKEN
node = IMFS_create_node(
107244: 83 ec 0c sub $0xc,%esp
107247: 6a 00 push $0x0
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
107249: 8b 85 48 fe ff ff mov -0x1b8(%ebp),%eax
10724f: 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(
107254: 80 cc 80 or $0x80,%ah
107257: 50 push %eax
107258: ff 75 e4 pushl -0x1c(%ebp)
10725b: 6a 06 push $0x6
10725d: 8d 55 bc lea -0x44(%ebp),%edx
107260: 52 push %edx
107261: e8 89 72 00 00 call 10e4ef <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;
107266: 8b 95 4c fe ff ff mov -0x1b4(%ebp),%edx
10726c: 89 50 50 mov %edx,0x50(%eax)
10726f: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.linearfile.direct = &tar_image[offset];
107276: 8b 55 0c mov 0xc(%ebp),%edx
107279: 03 95 50 fe ff ff add -0x1b0(%ebp),%edx
10727f: 89 50 58 mov %edx,0x58(%eax)
107282: 83 c4 20 add $0x20,%esp
}
nblocks = (((file_size) + 511) & ~511) / 512;
107285: 8b 85 4c fe ff ff mov -0x1b4(%ebp),%eax
10728b: 05 ff 01 00 00 add $0x1ff,%eax
offset += 512 * nblocks;
107290: 25 00 fe ff ff and $0xfffffe00,%eax
107295: 01 85 50 fe ff ff add %eax,-0x1b0(%ebp)
10729b: e9 46 fe ff ff jmp 1070e6 <rtems_tarfs_load+0x5a>
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
return -1;
1072a0: c7 85 54 fe ff ff ff movl $0xffffffff,-0x1ac(%ebp)
1072a7: ff ff ff
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
1072aa: 8b 85 54 fe ff ff mov -0x1ac(%ebp),%eax
1072b0: 8d 65 f4 lea -0xc(%ebp),%esp
1072b3: 5b pop %ebx
1072b4: 5e pop %esi
1072b5: 5f pop %edi
1072b6: c9 leave
1072b7: c3 ret
00110cdc <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
110cdc: 55 push %ebp
110cdd: 89 e5 mov %esp,%ebp
110cdf: 57 push %edi
110ce0: 56 push %esi
110ce1: 53 push %ebx
110ce2: 83 ec 1c sub $0x1c,%esp
110ce5: 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;
110ce8: 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 )
110ced: 85 c9 test %ecx,%ecx
110cef: 0f 84 fb 00 00 00 je 110df0 <rtems_task_mode+0x114> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
110cf5: 8b 35 34 48 12 00 mov 0x124834,%esi
api = executing->API_Extensions[ THREAD_API_RTEMS ];
110cfb: 8b 9e f4 00 00 00 mov 0xf4(%esi),%ebx
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
110d01: 80 7e 74 01 cmpb $0x1,0x74(%esi)
110d05: 19 ff sbb %edi,%edi
110d07: 81 e7 00 01 00 00 and $0x100,%edi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
110d0d: 83 7e 7c 00 cmpl $0x0,0x7c(%esi)
110d11: 74 06 je 110d19 <rtems_task_mode+0x3d>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
110d13: 81 cf 00 02 00 00 or $0x200,%edi
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
110d19: 80 7b 08 01 cmpb $0x1,0x8(%ebx)
110d1d: 19 d2 sbb %edx,%edx
110d1f: 81 e2 00 04 00 00 and $0x400,%edx
old_mode |= _ISR_Get_level();
110d25: 89 55 e4 mov %edx,-0x1c(%ebp)
110d28: 89 4d e0 mov %ecx,-0x20(%ebp)
110d2b: e8 65 c5 ff ff call 10d295 <_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;
110d30: 8b 55 e4 mov -0x1c(%ebp),%edx
110d33: 09 d0 or %edx,%eax
old_mode |= _ISR_Get_level();
110d35: 09 f8 or %edi,%eax
110d37: 8b 4d e0 mov -0x20(%ebp),%ecx
110d3a: 89 01 mov %eax,(%ecx)
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
110d3c: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
110d43: 74 0b je 110d50 <rtems_task_mode+0x74>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
110d45: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp)
110d4c: 0f 94 46 74 sete 0x74(%esi)
if ( mask & RTEMS_TIMESLICE_MASK ) {
110d50: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
110d57: 74 21 je 110d7a <rtems_task_mode+0x9e>
if ( _Modes_Is_timeslice(mode_set) ) {
110d59: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
110d60: 74 11 je 110d73 <rtems_task_mode+0x97>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
110d62: c7 46 7c 01 00 00 00 movl $0x1,0x7c(%esi)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
110d69: a1 b4 42 12 00 mov 0x1242b4,%eax
110d6e: 89 46 78 mov %eax,0x78(%esi)
110d71: eb 07 jmp 110d7a <rtems_task_mode+0x9e>
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
110d73: c7 46 7c 00 00 00 00 movl $0x0,0x7c(%esi)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
110d7a: f6 45 0c 01 testb $0x1,0xc(%ebp)
110d7e: 74 0a je 110d8a <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 ) );
110d80: f6 45 08 01 testb $0x1,0x8(%ebp)
110d84: 74 03 je 110d89 <rtems_task_mode+0xad>
110d86: fa cli
110d87: eb 01 jmp 110d8a <rtems_task_mode+0xae>
110d89: fb sti
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110d8a: 31 c9 xor %ecx,%ecx
if ( mask & RTEMS_ASR_MASK ) {
110d8c: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
110d93: 74 2a je 110dbf <rtems_task_mode+0xe3>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
110d95: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp)
110d9c: 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 ) {
110d9f: 3a 43 08 cmp 0x8(%ebx),%al
110da2: 74 1b je 110dbf <rtems_task_mode+0xe3>
asr->is_enabled = is_asr_enabled;
110da4: 88 43 08 mov %al,0x8(%ebx)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
110da7: 9c pushf
110da8: fa cli
110da9: 58 pop %eax
_signals = information->signals_pending;
110daa: 8b 53 18 mov 0x18(%ebx),%edx
information->signals_pending = information->signals_posted;
110dad: 8b 4b 14 mov 0x14(%ebx),%ecx
110db0: 89 4b 18 mov %ecx,0x18(%ebx)
information->signals_posted = _signals;
110db3: 89 53 14 mov %edx,0x14(%ebx)
_ISR_Enable( _level );
110db6: 50 push %eax
110db7: 9d popf
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110db8: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
110dbc: 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;
110dbf: 31 c0 xor %eax,%eax
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
110dc1: 83 3d 64 44 12 00 03 cmpl $0x3,0x124464
110dc8: 75 26 jne 110df0 <rtems_task_mode+0x114> <== NEVER TAKEN
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
110dca: 8b 15 34 48 12 00 mov 0x124834,%edx
if ( are_signals_pending ||
110dd0: 84 c9 test %cl,%cl
110dd2: 75 0e jne 110de2 <rtems_task_mode+0x106>
110dd4: 3b 15 38 48 12 00 cmp 0x124838,%edx
110dda: 74 14 je 110df0 <rtems_task_mode+0x114>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
110ddc: 80 7a 74 00 cmpb $0x0,0x74(%edx)
110de0: 74 0e je 110df0 <rtems_task_mode+0x114> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
110de2: c6 05 40 48 12 00 01 movb $0x1,0x124840
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
110de9: e8 a6 af ff ff call 10bd94 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
110dee: 31 c0 xor %eax,%eax
}
110df0: 83 c4 1c add $0x1c,%esp
110df3: 5b pop %ebx
110df4: 5e pop %esi
110df5: 5f pop %edi
110df6: c9 leave
110df7: c3 ret
0010dd34 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10dd34: 55 push %ebp
10dd35: 89 e5 mov %esp,%ebp
10dd37: 56 push %esi
10dd38: 53 push %ebx
10dd39: 83 ec 10 sub $0x10,%esp
10dd3c: 8b 5d 0c mov 0xc(%ebp),%ebx
10dd3f: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10dd42: 85 db test %ebx,%ebx
10dd44: 74 10 je 10dd56 <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 ) );
10dd46: 0f b6 15 f4 41 12 00 movzbl 0x1241f4,%edx
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
10dd4d: b8 13 00 00 00 mov $0x13,%eax
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10dd52: 39 d3 cmp %edx,%ebx
10dd54: 77 52 ja 10dda8 <rtems_task_set_priority+0x74>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
10dd56: 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 )
10dd5b: 85 f6 test %esi,%esi
10dd5d: 74 49 je 10dda8 <rtems_task_set_priority+0x74>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10dd5f: 51 push %ecx
10dd60: 51 push %ecx
10dd61: 8d 45 f4 lea -0xc(%ebp),%eax
10dd64: 50 push %eax
10dd65: ff 75 08 pushl 0x8(%ebp)
10dd68: e8 f7 1b 00 00 call 10f964 <_Thread_Get>
switch ( location ) {
10dd6d: 83 c4 10 add $0x10,%esp
10dd70: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10dd74: 75 2d jne 10dda3 <rtems_task_set_priority+0x6f>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10dd76: 8b 50 14 mov 0x14(%eax),%edx
10dd79: 89 16 mov %edx,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10dd7b: 85 db test %ebx,%ebx
10dd7d: 74 1b je 10dd9a <rtems_task_set_priority+0x66>
the_thread->real_priority = new_priority;
10dd7f: 89 58 18 mov %ebx,0x18(%eax)
if ( the_thread->resource_count == 0 ||
10dd82: 83 78 1c 00 cmpl $0x0,0x1c(%eax)
10dd86: 74 05 je 10dd8d <rtems_task_set_priority+0x59>
10dd88: 39 58 14 cmp %ebx,0x14(%eax)
10dd8b: 76 0d jbe 10dd9a <rtems_task_set_priority+0x66><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
10dd8d: 52 push %edx
10dd8e: 6a 00 push $0x0
10dd90: 53 push %ebx
10dd91: 50 push %eax
10dd92: e8 19 17 00 00 call 10f4b0 <_Thread_Change_priority>
10dd97: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10dd9a: e8 a3 1b 00 00 call 10f942 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10dd9f: 31 c0 xor %eax,%eax
10dda1: eb 05 jmp 10dda8 <rtems_task_set_priority+0x74>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10dda3: b8 04 00 00 00 mov $0x4,%eax
}
10dda8: 8d 65 f8 lea -0x8(%ebp),%esp
10ddab: 5b pop %ebx
10ddac: 5e pop %esi
10ddad: c9 leave
10ddae: c3 ret
00108507 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
108507: 55 push %ebp
108508: 89 e5 mov %esp,%ebp
10850a: 56 push %esi
10850b: 53 push %ebx
10850c: 8b 75 08 mov 0x8(%ebp),%esi
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
10850f: 8b 06 mov (%esi),%eax
108511: 8b 58 34 mov 0x34(%eax),%ebx
rtems_status_code sc;
sc = rtems_semaphore_obtain(
108514: 51 push %ecx
108515: 6a 00 push $0x0
108517: 6a 00 push $0x0
108519: ff 35 dc 41 12 00 pushl 0x1241dc
10851f: e8 40 1c 00 00 call 10a164 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
108524: 83 c4 10 add $0x10,%esp
108527: 85 c0 test %eax,%eax
108529: 0f 85 88 00 00 00 jne 1085b7 <rtems_termios_close+0xb0><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
10852f: 8b 43 08 mov 0x8(%ebx),%eax
108532: 48 dec %eax
108533: 89 43 08 mov %eax,0x8(%ebx)
108536: 85 c0 test %eax,%eax
108538: 0f 85 3e 01 00 00 jne 10867c <rtems_termios_close+0x175>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
10853e: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
108544: c1 e0 05 shl $0x5,%eax
108547: 8b 80 98 3e 12 00 mov 0x123e98(%eax),%eax
10854d: 85 c0 test %eax,%eax
10854f: 74 08 je 108559 <rtems_termios_close+0x52>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
108551: 83 ec 0c sub $0xc,%esp
108554: 53 push %ebx
108555: ff d0 call *%eax
108557: eb 26 jmp 10857f <rtems_termios_close+0x78>
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108559: 52 push %edx
10855a: 6a 00 push $0x0
10855c: 6a 00 push $0x0
10855e: ff 73 18 pushl 0x18(%ebx)
108561: e8 fe 1b 00 00 call 10a164 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
108566: 83 c4 10 add $0x10,%esp
108569: 85 c0 test %eax,%eax
10856b: 75 4a jne 1085b7 <rtems_termios_close+0xb0><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
10856d: 89 d8 mov %ebx,%eax
10856f: e8 10 fb ff ff call 108084 <drainOutput>
rtems_semaphore_release (tty->osem);
108574: 83 ec 0c sub $0xc,%esp
108577: ff 73 18 pushl 0x18(%ebx)
10857a: e8 d1 1c 00 00 call 10a250 <rtems_semaphore_release>
10857f: 83 c4 10 add $0x10,%esp
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
108582: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
108589: 75 35 jne 1085c0 <rtems_termios_close+0xb9>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
10858b: 50 push %eax
10858c: 50 push %eax
10858d: 6a 01 push $0x1
10858f: ff b3 c4 00 00 00 pushl 0xc4(%ebx)
108595: e8 62 17 00 00 call 109cfc <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
10859a: 83 c4 10 add $0x10,%esp
10859d: 85 c0 test %eax,%eax
10859f: 75 16 jne 1085b7 <rtems_termios_close+0xb0><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
1085a1: 51 push %ecx
1085a2: 51 push %ecx
1085a3: 6a 01 push $0x1
1085a5: ff b3 c8 00 00 00 pushl 0xc8(%ebx)
1085ab: e8 4c 17 00 00 call 109cfc <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
1085b0: 83 c4 10 add $0x10,%esp
1085b3: 85 c0 test %eax,%eax
1085b5: 74 09 je 1085c0 <rtems_termios_close+0xb9><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
1085b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1085ba: 50 push %eax <== NOT EXECUTED
1085bb: e8 6c 21 00 00 call 10a72c <rtems_fatal_error_occurred><== NOT EXECUTED
}
if (tty->device.lastClose)
1085c0: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax
1085c6: 85 c0 test %eax,%eax
1085c8: 74 0d je 1085d7 <rtems_termios_close+0xd0>
(*tty->device.lastClose)(tty->major, tty->minor, arg);
1085ca: 52 push %edx
1085cb: 56 push %esi
1085cc: ff 73 10 pushl 0x10(%ebx)
1085cf: ff 73 0c pushl 0xc(%ebx)
1085d2: ff d0 call *%eax
1085d4: 83 c4 10 add $0x10,%esp
if (tty->forw == NULL) {
1085d7: 8b 13 mov (%ebx),%edx
1085d9: 85 d2 test %edx,%edx
1085db: 8b 43 04 mov 0x4(%ebx),%eax
1085de: 75 11 jne 1085f1 <rtems_termios_close+0xea>
rtems_termios_ttyTail = tty->back;
1085e0: a3 e0 41 12 00 mov %eax,0x1241e0
if ( rtems_termios_ttyTail != NULL ) {
1085e5: 85 c0 test %eax,%eax
1085e7: 74 0b je 1085f4 <rtems_termios_close+0xed>
rtems_termios_ttyTail->forw = NULL;
1085e9: c7 00 00 00 00 00 movl $0x0,(%eax)
1085ef: eb 03 jmp 1085f4 <rtems_termios_close+0xed>
}
} else {
tty->forw->back = tty->back;
1085f1: 89 42 04 mov %eax,0x4(%edx)
}
if (tty->back == NULL) {
1085f4: 8b 53 04 mov 0x4(%ebx),%edx
1085f7: 85 d2 test %edx,%edx
1085f9: 8b 03 mov (%ebx),%eax
1085fb: 75 12 jne 10860f <rtems_termios_close+0x108>
rtems_termios_ttyHead = tty->forw;
1085fd: a3 e4 41 12 00 mov %eax,0x1241e4
if ( rtems_termios_ttyHead != NULL ) {
108602: 85 c0 test %eax,%eax
108604: 74 0b je 108611 <rtems_termios_close+0x10a>
rtems_termios_ttyHead->back = NULL;
108606: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
10860d: eb 02 jmp 108611 <rtems_termios_close+0x10a>
}
} else {
tty->back->forw = tty->forw;
10860f: 89 02 mov %eax,(%edx)
}
rtems_semaphore_delete (tty->isem);
108611: 83 ec 0c sub $0xc,%esp
108614: ff 73 14 pushl 0x14(%ebx)
108617: e8 b8 1a 00 00 call 10a0d4 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
10861c: 59 pop %ecx
10861d: ff 73 18 pushl 0x18(%ebx)
108620: e8 af 1a 00 00 call 10a0d4 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
108625: 5a pop %edx
108626: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
10862c: e8 a3 1a 00 00 call 10a0d4 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
108631: 83 c4 10 add $0x10,%esp
108634: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
10863b: 74 09 je 108646 <rtems_termios_close+0x13f>
10863d: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
108644: 75 0e jne 108654 <rtems_termios_close+0x14d>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
108646: 83 ec 0c sub $0xc,%esp
108649: ff 73 68 pushl 0x68(%ebx)
10864c: e8 83 1a 00 00 call 10a0d4 <rtems_semaphore_delete>
108651: 83 c4 10 add $0x10,%esp
free (tty->rawInBuf.theBuf);
108654: 83 ec 0c sub $0xc,%esp
108657: ff 73 58 pushl 0x58(%ebx)
10865a: e8 e9 ec ff ff call 107348 <free>
free (tty->rawOutBuf.theBuf);
10865f: 58 pop %eax
108660: ff 73 7c pushl 0x7c(%ebx)
108663: e8 e0 ec ff ff call 107348 <free>
free (tty->cbuf);
108668: 5e pop %esi
108669: ff 73 1c pushl 0x1c(%ebx)
10866c: e8 d7 ec ff ff call 107348 <free>
free (tty);
108671: 89 1c 24 mov %ebx,(%esp)
108674: e8 cf ec ff ff call 107348 <free>
108679: 83 c4 10 add $0x10,%esp
}
rtems_semaphore_release (rtems_termios_ttyMutex);
10867c: 83 ec 0c sub $0xc,%esp
10867f: ff 35 dc 41 12 00 pushl 0x1241dc
108685: e8 c6 1b 00 00 call 10a250 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
10868a: 31 c0 xor %eax,%eax
10868c: 8d 65 f8 lea -0x8(%ebp),%esp
10868f: 5b pop %ebx
108690: 5e pop %esi
108691: c9 leave
108692: c3 ret
00109840 <rtems_termios_dequeue_characters>:
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
109840: 55 push %ebp
109841: 89 e5 mov %esp,%ebp
109843: 83 ec 08 sub $0x8,%esp
109846: 8b 45 08 mov 0x8(%ebp),%eax
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
109849: 8b 55 0c mov 0xc(%ebp),%edx
10984c: 01 90 90 00 00 00 add %edx,0x90(%eax)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
109852: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax)
109859: 75 1f jne 10987a <rtems_termios_dequeue_characters+0x3a>
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
10985b: 52 push %edx
10985c: 52 push %edx
10985d: 6a 02 push $0x2
10985f: ff b0 c8 00 00 00 pushl 0xc8(%eax)
109865: e8 92 04 00 00 call 109cfc <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
10986a: 83 c4 10 add $0x10,%esp
10986d: 85 c0 test %eax,%eax
10986f: 74 30 je 1098a1 <rtems_termios_dequeue_characters+0x61><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
109871: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109874: 50 push %eax <== NOT EXECUTED
109875: e8 b2 0e 00 00 call 10a72c <rtems_fatal_error_occurred><== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
10987a: 83 b8 cc 00 00 00 05 cmpl $0x5,0xcc(%eax)
109881: 75 15 jne 109898 <rtems_termios_dequeue_characters+0x58>
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
109883: 8b 15 48 3f 12 00 mov 0x123f48,%edx
109889: 85 d2 test %edx,%edx
10988b: 74 14 je 1098a1 <rtems_termios_dequeue_characters+0x61><== NEVER TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
10988d: 83 ec 0c sub $0xc,%esp
109890: 50 push %eax
109891: ff d2 call *%edx
109893: 83 c4 10 add $0x10,%esp
109896: eb 09 jmp 1098a1 <rtems_termios_dequeue_characters+0x61>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
109898: 89 45 08 mov %eax,0x8(%ebp)
}
10989b: c9 leave
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
10989c: e9 6d fd ff ff jmp 10960e <rtems_termios_refill_transmitter>
}
1098a1: 31 c0 xor %eax,%eax
1098a3: c9 leave
1098a4: c3 ret
0010931f <rtems_termios_enqueue_raw_characters>:
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len)
{
10931f: 55 push %ebp
109320: 89 e5 mov %esp,%ebp
109322: 57 push %edi
109323: 56 push %esi
109324: 53 push %ebx
109325: 83 ec 2c sub $0x2c,%esp
109328: 8b 5d 08 mov 0x8(%ebp),%ebx
10932b: 8b 7d 0c mov 0xc(%ebp),%edi
10932e: 8b 4d 10 mov 0x10(%ebp),%ecx
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
109331: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
109337: c1 e0 05 shl $0x5,%eax
10933a: 89 ca mov %ecx,%edx
10933c: 83 b8 a4 3e 12 00 00 cmpl $0x0,0x123ea4(%eax)
109343: 75 3b jne 109380 <rtems_termios_enqueue_raw_characters+0x61>
109345: 89 4d e0 mov %ecx,-0x20(%ebp)
109348: c6 45 df 00 movb $0x0,-0x21(%ebp)
10934c: 31 f6 xor %esi,%esi
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
10934e: 8d 43 30 lea 0x30(%ebx),%eax
109351: 89 45 d4 mov %eax,-0x2c(%ebp)
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
109354: 8d 53 4a lea 0x4a(%ebx),%edx
109357: 89 55 d0 mov %edx,-0x30(%ebp)
10935a: e9 26 02 00 00 jmp 109585 <rtems_termios_enqueue_raw_characters+0x266>
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
10935f: 0f be 0f movsbl (%edi),%ecx
109362: 47 inc %edi
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
109363: 56 push %esi
109364: 56 push %esi
109365: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
10936b: c1 e0 05 shl $0x5,%eax
10936e: 53 push %ebx
10936f: 51 push %ecx
109370: 89 55 cc mov %edx,-0x34(%ebp)
109373: ff 90 a4 3e 12 00 call *0x123ea4(%eax)
109379: 8b 55 cc mov -0x34(%ebp),%edx
10937c: 4a dec %edx
10937d: 83 c4 10 add $0x10,%esp
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
109380: 85 d2 test %edx,%edx
109382: 75 db jne 10935f <rtems_termios_enqueue_raw_characters+0x40>
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
109384: 31 f6 xor %esi,%esi
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
109386: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx)
10938d: 0f 85 0d 02 00 00 jne 1095a0 <rtems_termios_enqueue_raw_characters+0x281><== NEVER TAKEN
109393: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
109399: 89 d6 mov %edx,%esi
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
10939b: 85 c0 test %eax,%eax
10939d: 0f 84 fd 01 00 00 je 1095a0 <rtems_termios_enqueue_raw_characters+0x281><== NEVER TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
1093a3: 51 push %ecx
1093a4: 51 push %ecx
1093a5: ff b3 e0 00 00 00 pushl 0xe0(%ebx)
1093ab: 8d 53 30 lea 0x30(%ebx),%edx
1093ae: 52 push %edx
1093af: ff d0 call *%eax
tty->tty_rcvwakeup = 1;
1093b1: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx)
1093b8: 00 00 00
1093bb: e9 dd 01 00 00 jmp 10959d <rtems_termios_enqueue_raw_characters+0x27e>
}
return 0;
}
while (len--) {
c = *buf++;
1093c0: 8a 0f mov (%edi),%cl
1093c2: 88 4d de mov %cl,-0x22(%ebp)
1093c5: 47 inc %edi
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
1093c6: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1093cc: f6 c4 02 test $0x2,%ah
1093cf: 74 46 je 109417 <rtems_termios_enqueue_raw_characters+0xf8>
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
1093d1: 0f be c1 movsbl %cl,%eax
1093d4: 0f b6 53 4a movzbl 0x4a(%ebx),%edx
1093d8: 39 d0 cmp %edx,%eax
1093da: 75 28 jne 109404 <rtems_termios_enqueue_raw_characters+0xe5>
if (c == tty->termios.c_cc[VSTART]) {
1093dc: 0f b6 53 49 movzbl 0x49(%ebx),%edx
1093e0: 39 d0 cmp %edx,%eax
1093e2: 75 0b jne 1093ef <rtems_termios_enqueue_raw_characters+0xd0><== ALWAYS TAKEN
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
1093e4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1093ea: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED
1093ed: eb 09 jmp 1093f8 <rtems_termios_enqueue_raw_characters+0xd9><== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
1093ef: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1093f5: 83 c8 10 or $0x10,%eax
1093f8: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len)
{
1093fe: c6 45 df 01 movb $0x1,-0x21(%ebp)
109402: eb 19 jmp 10941d <rtems_termios_enqueue_raw_characters+0xfe>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
109404: 0f b6 53 49 movzbl 0x49(%ebx),%edx
109408: 39 d0 cmp %edx,%eax
10940a: 75 0b jne 109417 <rtems_termios_enqueue_raw_characters+0xf8><== ALWAYS TAKEN
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
10940c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109412: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED
109415: eb e1 jmp 1093f8 <rtems_termios_enqueue_raw_characters+0xd9><== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
109417: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
10941b: 74 51 je 10946e <rtems_termios_enqueue_raw_characters+0x14f><== ALWAYS TAKEN
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
10941d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109423: 83 e0 30 and $0x30,%eax
109426: 83 f8 20 cmp $0x20,%eax
109429: 0f 85 53 01 00 00 jne 109582 <rtems_termios_enqueue_raw_characters+0x263><== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
10942f: 9c pushf <== NOT EXECUTED
109430: fa cli <== NOT EXECUTED
109431: 8f 45 e4 popl -0x1c(%ebp) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
109434: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10943a: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
10943d: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
109443: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
10944a: 74 19 je 109465 <rtems_termios_enqueue_raw_characters+0x146><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
10944c: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
109452: 52 push %edx <== NOT EXECUTED
109453: 6a 01 push $0x1 <== NOT EXECUTED
109455: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
109458: 50 push %eax <== NOT EXECUTED
109459: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10945c: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
109462: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
109465: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED
109468: 9d popf <== NOT EXECUTED
109469: e9 14 01 00 00 jmp 109582 <rtems_termios_enqueue_raw_characters+0x263><== NOT EXECUTED
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
10946e: 8b 43 60 mov 0x60(%ebx),%eax
109471: 8b 4b 64 mov 0x64(%ebx),%ecx
109474: 40 inc %eax
109475: 31 d2 xor %edx,%edx
109477: f7 f1 div %ecx
109479: 89 55 e4 mov %edx,-0x1c(%ebp)
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
10947c: 9c pushf
10947d: fa cli
10947e: 8f 45 d8 popl -0x28(%ebp)
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
109481: 8b 53 5c mov 0x5c(%ebx),%edx
109484: 8b 43 64 mov 0x64(%ebx),%eax
% tty->rawInBuf.Size) > tty->highwater) &&
109487: 8b 4b 64 mov 0x64(%ebx),%ecx
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
10948a: 29 d0 sub %edx,%eax
10948c: 03 45 e4 add -0x1c(%ebp),%eax
% tty->rawInBuf.Size) > tty->highwater) &&
10948f: 31 d2 xor %edx,%edx
109491: f7 f1 div %ecx
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
109493: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx
109499: 0f 86 98 00 00 00 jbe 109537 <rtems_termios_enqueue_raw_characters+0x218><== ALWAYS TAKEN
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
10949f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
1094a5: a8 01 test $0x1,%al <== NOT EXECUTED
1094a7: 0f 85 8a 00 00 00 jne 109537 <rtems_termios_enqueue_raw_characters+0x218><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
1094ad: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1094b3: 83 c8 01 or $0x1,%eax <== NOT EXECUTED
1094b6: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
1094bc: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1094c2: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED
1094c7: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED
1094cc: 75 33 jne 109501 <rtems_termios_enqueue_raw_characters+0x1e2><== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
1094ce: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1094d4: a8 20 test $0x20,%al <== NOT EXECUTED
1094d6: 75 09 jne 1094e1 <rtems_termios_enqueue_raw_characters+0x1c2><== NOT EXECUTED
1094d8: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
1094df: 75 56 jne 109537 <rtems_termios_enqueue_raw_characters+0x218><== NOT EXECUTED
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
1094e1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1094e7: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
1094ea: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
1094f0: 51 push %ecx <== NOT EXECUTED
1094f1: 6a 01 push $0x1 <== NOT EXECUTED
1094f3: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED
1094f6: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1094f9: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
1094ff: eb 33 jmp 109534 <rtems_termios_enqueue_raw_characters+0x215><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
109501: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109507: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED
10950c: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED
109511: 75 24 jne 109537 <rtems_termios_enqueue_raw_characters+0x218><== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
109513: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109519: 83 c8 04 or $0x4,%eax <== NOT EXECUTED
10951c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
109522: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED
109528: 85 c0 test %eax,%eax <== NOT EXECUTED
10952a: 74 0b je 109537 <rtems_termios_enqueue_raw_characters+0x218><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
10952c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10952f: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109532: ff d0 call *%eax <== NOT EXECUTED
109534: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
109537: ff 75 d8 pushl -0x28(%ebp)
10953a: 9d popf
if (newTail == tty->rawInBuf.Head) {
10953b: 8b 43 5c mov 0x5c(%ebx),%eax
10953e: 39 45 e4 cmp %eax,-0x1c(%ebp)
109541: 75 03 jne 109546 <rtems_termios_enqueue_raw_characters+0x227><== ALWAYS TAKEN
dropped++;
109543: 46 inc %esi <== NOT EXECUTED
109544: eb 3c jmp 109582 <rtems_termios_enqueue_raw_characters+0x263><== NOT EXECUTED
} else {
tty->rawInBuf.theBuf[newTail] = c;
109546: 8b 43 58 mov 0x58(%ebx),%eax
109549: 8a 4d de mov -0x22(%ebp),%cl
10954c: 8b 55 e4 mov -0x1c(%ebp),%edx
10954f: 88 0c 10 mov %cl,(%eax,%edx,1)
tty->rawInBuf.Tail = newTail;
109552: 89 53 60 mov %edx,0x60(%ebx)
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
109555: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx)
10955c: 75 24 jne 109582 <rtems_termios_enqueue_raw_characters+0x263><== NEVER TAKEN
10955e: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax
109564: 85 c0 test %eax,%eax
109566: 74 1a je 109582 <rtems_termios_enqueue_raw_characters+0x263><== ALWAYS TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
109568: 52 push %edx <== NOT EXECUTED
109569: 52 push %edx <== NOT EXECUTED
10956a: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED
109570: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED
109573: ff d0 call *%eax <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
109575: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED
10957c: 00 00 00
10957f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109582: ff 4d e0 decl -0x20(%ebp)
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
109585: 83 7d e0 00 cmpl $0x0,-0x20(%ebp)
109589: 0f 85 31 fe ff ff jne 1093c0 <rtems_termios_enqueue_raw_characters+0xa1>
}
}
}
}
tty->rawInBufDropped += dropped;
10958f: 01 73 78 add %esi,0x78(%ebx)
rtems_semaphore_release (tty->rawInBuf.Semaphore);
109592: 83 ec 0c sub $0xc,%esp
109595: ff 73 68 pushl 0x68(%ebx)
109598: e8 b3 0c 00 00 call 10a250 <rtems_semaphore_release>
return dropped;
10959d: 83 c4 10 add $0x10,%esp
}
1095a0: 89 f0 mov %esi,%eax
1095a2: 8d 65 f4 lea -0xc(%ebp),%esp
1095a5: 5b pop %ebx
1095a6: 5e pop %esi
1095a7: 5f pop %edi
1095a8: c9 leave
1095a9: c3 ret
001086b2 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
1086b2: 55 push %ebp
1086b3: 89 e5 mov %esp,%ebp
1086b5: 57 push %edi
1086b6: 56 push %esi
1086b7: 53 push %ebx
1086b8: 83 ec 20 sub $0x20,%esp
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
1086bb: 8b 55 08 mov 0x8(%ebp),%edx
1086be: 8b 02 mov (%edx),%eax
1086c0: 8b 58 34 mov 0x34(%eax),%ebx
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
1086c3: 8b 72 08 mov 0x8(%edx),%esi
rtems_status_code sc;
args->ioctl_return = 0;
1086c6: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
1086cd: 6a 00 push $0x0
1086cf: 6a 00 push $0x0
1086d1: ff 73 18 pushl 0x18(%ebx)
1086d4: e8 8b 1a 00 00 call 10a164 <rtems_semaphore_obtain>
1086d9: 89 45 e4 mov %eax,-0x1c(%ebp)
if (sc != RTEMS_SUCCESSFUL) {
1086dc: 83 c4 10 add $0x10,%esp
1086df: 85 c0 test %eax,%eax
1086e1: 74 0b je 1086ee <rtems_termios_ioctl+0x3c><== ALWAYS TAKEN
args->ioctl_return = sc;
1086e3: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
1086e6: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED
return sc;
1086e9: e9 05 03 00 00 jmp 1089f3 <rtems_termios_ioctl+0x341><== NOT EXECUTED
}
switch (args->command) {
1086ee: 8b 55 08 mov 0x8(%ebp),%edx
1086f1: 8b 42 04 mov 0x4(%edx),%eax
1086f4: 83 f8 04 cmp $0x4,%eax
1086f7: 0f 84 4d 02 00 00 je 10894a <rtems_termios_ioctl+0x298>
1086fd: 77 10 ja 10870f <rtems_termios_ioctl+0x5d>
1086ff: 83 f8 02 cmp $0x2,%eax
108702: 74 77 je 10877b <rtems_termios_ioctl+0xc9>
108704: 0f 87 1e 02 00 00 ja 108928 <rtems_termios_ioctl+0x276>
10870a: 48 dec %eax
10870b: 75 2f jne 10873c <rtems_termios_ioctl+0x8a><== NEVER TAKEN
10870d: eb 55 jmp 108764 <rtems_termios_ioctl+0xb2>
10870f: 3d 7f 66 04 40 cmp $0x4004667f,%eax
108714: 0f 84 a5 02 00 00 je 1089bf <rtems_termios_ioctl+0x30d><== NEVER TAKEN
10871a: 77 0a ja 108726 <rtems_termios_ioctl+0x74>
10871c: 83 f8 05 cmp $0x5,%eax
10871f: 75 1b jne 10873c <rtems_termios_ioctl+0x8a>
108721: e9 0e 02 00 00 jmp 108934 <rtems_termios_ioctl+0x282>
108726: 3d 1a 74 04 40 cmp $0x4004741a,%eax
10872b: 0f 84 7e 02 00 00 je 1089af <rtems_termios_ioctl+0x2fd>
108731: 3d 1b 74 04 80 cmp $0x8004741b,%eax
108736: 0f 84 21 02 00 00 je 10895d <rtems_termios_ioctl+0x2ab><== ALWAYS TAKEN
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
10873c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
108742: c1 e0 05 shl $0x5,%eax
108745: 8b 80 ac 3e 12 00 mov 0x123eac(%eax),%eax
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
10874b: c7 45 e4 0a 00 00 00 movl $0xa,-0x1c(%ebp)
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
108752: 85 c0 test %eax,%eax
108754: 0f 84 82 02 00 00 je 1089dc <rtems_termios_ioctl+0x32a><== NEVER TAKEN
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
10875a: 52 push %edx
10875b: 52 push %edx
10875c: ff 75 08 pushl 0x8(%ebp)
10875f: e9 40 02 00 00 jmp 1089a4 <rtems_termios_ioctl+0x2f2>
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
108764: 8b 4d 08 mov 0x8(%ebp),%ecx
108767: 8b 41 08 mov 0x8(%ecx),%eax
10876a: 8d 73 30 lea 0x30(%ebx),%esi
10876d: b9 09 00 00 00 mov $0x9,%ecx
108772: 89 c7 mov %eax,%edi
108774: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
break;
108776: e9 61 02 00 00 jmp 1089dc <rtems_termios_ioctl+0x32a>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
10877b: 8b 45 08 mov 0x8(%ebp),%eax
10877e: 8b 70 08 mov 0x8(%eax),%esi
108781: 8d 7b 30 lea 0x30(%ebx),%edi
108784: b9 09 00 00 00 mov $0x9,%ecx
108789: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
10878b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108791: f6 c4 02 test $0x2,%ah
108794: 74 57 je 1087ed <rtems_termios_ioctl+0x13b>
108796: f6 43 31 04 testb $0x4,0x31(%ebx)
10879a: 75 51 jne 1087ed <rtems_termios_ioctl+0x13b><== ALWAYS TAKEN
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
10879c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1087a2: 25 ef fd ff ff and $0xfffffdef,%eax <== NOT EXECUTED
1087a7: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
1087ad: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1087b3: a8 20 test $0x20,%al <== NOT EXECUTED
1087b5: 74 36 je 1087ed <rtems_termios_ioctl+0x13b><== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
1087b7: 9c pushf <== NOT EXECUTED
1087b8: fa cli <== NOT EXECUTED
1087b9: 5e pop %esi <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
1087ba: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1087c0: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
1087c3: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
1087c9: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
1087d0: 74 19 je 1087eb <rtems_termios_ioctl+0x139><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
1087d2: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
1087d8: 57 push %edi <== NOT EXECUTED
1087d9: 6a 01 push $0x1 <== NOT EXECUTED
1087db: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
1087de: 50 push %eax <== NOT EXECUTED
1087df: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1087e2: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
1087e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
1087eb: 56 push %esi <== NOT EXECUTED
1087ec: 9d popf <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
1087ed: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1087f3: f6 c4 04 test $0x4,%ah
1087f6: 74 24 je 10881c <rtems_termios_ioctl+0x16a>
1087f8: f6 43 31 10 testb $0x10,0x31(%ebx)
1087fc: 75 1e jne 10881c <rtems_termios_ioctl+0x16a><== ALWAYS TAKEN
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
1087fe: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108804: 80 e4 fb and $0xfb,%ah <== NOT EXECUTED
108807: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
10880d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108813: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
108816: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
10881c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108822: f6 c4 01 test $0x1,%ah
108825: 74 43 je 10886a <rtems_termios_ioctl+0x1b8><== ALWAYS TAKEN
108827: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED
10882b: 78 3d js 10886a <rtems_termios_ioctl+0x1b8><== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
10882d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108833: 80 e4 fe and $0xfe,%ah <== NOT EXECUTED
108836: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
10883c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108842: a8 04 test $0x4,%al <== NOT EXECUTED
108844: 74 15 je 10885b <rtems_termios_ioctl+0x1a9><== NOT EXECUTED
108846: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED
10884c: 85 c0 test %eax,%eax <== NOT EXECUTED
10884e: 74 0b je 10885b <rtems_termios_ioctl+0x1a9><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
108850: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108853: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
108856: ff d0 call *%eax <== NOT EXECUTED
108858: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
10885b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108861: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
108864: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
10886a: 83 7b 38 00 cmpl $0x0,0x38(%ebx)
10886e: 79 0f jns 10887f <rtems_termios_ioctl+0x1cd><== ALWAYS TAKEN
tty->flow_ctrl |= FL_MDRTS;
108870: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108876: 80 cc 01 or $0x1,%ah <== NOT EXECUTED
108879: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
10887f: 8b 53 30 mov 0x30(%ebx),%edx
108882: f6 c6 10 test $0x10,%dh
108885: 74 0f je 108896 <rtems_termios_ioctl+0x1e4>
tty->flow_ctrl |= FL_MDXOF;
108887: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10888d: 80 cc 04 or $0x4,%ah
108890: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
108896: 80 e6 04 and $0x4,%dh
108899: 74 0f je 1088aa <rtems_termios_ioctl+0x1f8><== NEVER TAKEN
tty->flow_ctrl |= FL_MDXON;
10889b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1088a1: 80 cc 02 or $0x2,%ah
1088a4: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
tty->termios = *(struct termios *)args->buffer;
/* check for and process change in flow control options */
termios_set_flowctrl(tty);
if (tty->termios.c_lflag & ICANON) {
1088aa: f6 43 3c 02 testb $0x2,0x3c(%ebx)
1088ae: 75 39 jne 1088e9 <rtems_termios_ioctl+0x237>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
1088b0: 0f b6 73 46 movzbl 0x46(%ebx),%esi
rtems_clock_get_ticks_per_second() / 10;
1088b4: e8 6b 12 00 00 call 109b24 <rtems_clock_get_ticks_per_second>
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
1088b9: 0f af c6 imul %esi,%eax
rtems_clock_get_ticks_per_second() / 10;
1088bc: b9 0a 00 00 00 mov $0xa,%ecx
1088c1: 31 d2 xor %edx,%edx
1088c3: f7 f1 div %ecx
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
1088c5: 89 43 54 mov %eax,0x54(%ebx)
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
1088c8: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
1088cc: 74 15 je 1088e3 <rtems_termios_ioctl+0x231>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
1088ce: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
1088d5: 89 43 70 mov %eax,0x70(%ebx)
if (tty->termios.c_cc[VMIN])
1088d8: 80 7b 47 00 cmpb $0x0,0x47(%ebx)
1088dc: 75 19 jne 1088f7 <rtems_termios_ioctl+0x245>
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
1088de: 89 43 74 mov %eax,0x74(%ebx)
1088e1: eb 24 jmp 108907 <rtems_termios_ioctl+0x255>
} else {
if (tty->termios.c_cc[VMIN]) {
1088e3: 80 7b 47 00 cmpb $0x0,0x47(%ebx)
1088e7: 74 17 je 108900 <rtems_termios_ioctl+0x24e><== ALWAYS TAKEN
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
1088e9: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
1088f0: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx)
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
1088f7: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx)
1088fe: eb 07 jmp 108907 <rtems_termios_ioctl+0x255>
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
108900: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx)
}
}
}
if (tty->device.setAttributes)
108907: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax
10890d: 85 c0 test %eax,%eax
10890f: 0f 84 c7 00 00 00 je 1089dc <rtems_termios_ioctl+0x32a><== NEVER TAKEN
(*tty->device.setAttributes)(tty->minor, &tty->termios);
108915: 56 push %esi
108916: 56 push %esi
108917: 8d 53 30 lea 0x30(%ebx),%edx
10891a: 52 push %edx
10891b: ff 73 10 pushl 0x10(%ebx)
10891e: ff d0 call *%eax
108920: 83 c4 10 add $0x10,%esp
108923: e9 b4 00 00 00 jmp 1089dc <rtems_termios_ioctl+0x32a>
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
108928: 89 d8 mov %ebx,%eax
10892a: e8 55 f7 ff ff call 108084 <drainOutput>
break;
10892f: e9 a8 00 00 00 jmp 1089dc <rtems_termios_ioctl+0x32a>
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
108934: 8b 06 mov (%esi),%eax
108936: 8b 56 04 mov 0x4(%esi),%edx
108939: 89 83 d4 00 00 00 mov %eax,0xd4(%ebx)
10893f: 89 93 d8 00 00 00 mov %edx,0xd8(%ebx)
break;
108945: e9 92 00 00 00 jmp 1089dc <rtems_termios_ioctl+0x32a>
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
10894a: 8b 06 mov (%esi),%eax
10894c: 8b 56 04 mov 0x4(%esi),%edx
10894f: 89 83 dc 00 00 00 mov %eax,0xdc(%ebx)
108955: 89 93 e0 00 00 00 mov %edx,0xe0(%ebx)
break;
10895b: eb 7f jmp 1089dc <rtems_termios_ioctl+0x32a>
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
10895d: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
108963: c1 e0 05 shl $0x5,%eax
108966: 8b 80 98 3e 12 00 mov 0x123e98(%eax),%eax
10896c: 85 c0 test %eax,%eax
10896e: 74 0c je 10897c <rtems_termios_ioctl+0x2ca>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
108970: 83 ec 0c sub $0xc,%esp
108973: 53 push %ebx
108974: ff d0 call *%eax
108976: 89 45 e4 mov %eax,-0x1c(%ebp)
108979: 83 c4 10 add $0x10,%esp
}
tty->t_line=*(int*)(args->buffer);
10897c: 8b 55 08 mov 0x8(%ebp),%edx
10897f: 8b 42 08 mov 0x8(%edx),%eax
108982: 8b 00 mov (%eax),%eax
108984: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx)
tty->t_sc = NULL; /* ensure that no more valid data */
10898a: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx)
108991: 00 00 00
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
108994: c1 e0 05 shl $0x5,%eax
108997: 8b 80 94 3e 12 00 mov 0x123e94(%eax),%eax
10899d: 85 c0 test %eax,%eax
10899f: 74 3b je 1089dc <rtems_termios_ioctl+0x32a><== NEVER TAKEN
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
1089a1: 83 ec 0c sub $0xc,%esp
1089a4: 53 push %ebx
1089a5: ff d0 call *%eax
1089a7: 89 45 e4 mov %eax,-0x1c(%ebp)
1089aa: e9 71 ff ff ff jmp 108920 <rtems_termios_ioctl+0x26e>
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
1089af: 8b 4d 08 mov 0x8(%ebp),%ecx
1089b2: 8b 41 08 mov 0x8(%ecx),%eax
1089b5: 8b 93 cc 00 00 00 mov 0xcc(%ebx),%edx
1089bb: 89 10 mov %edx,(%eax)
break;
1089bd: eb 1d jmp 1089dc <rtems_termios_ioctl+0x32a>
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
1089bf: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED
1089c2: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED
if ( rawnc < 0 )
1089c5: 29 d0 sub %edx,%eax <== NOT EXECUTED
1089c7: 79 05 jns 1089ce <rtems_termios_ioctl+0x31c><== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
1089c9: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED
1089cc: 01 d0 add %edx,%eax <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
1089ce: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
1089d1: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED
1089d4: 03 43 20 add 0x20(%ebx),%eax <== NOT EXECUTED
1089d7: 2b 43 24 sub 0x24(%ebx),%eax <== NOT EXECUTED
1089da: 89 02 mov %eax,(%edx) <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
1089dc: 83 ec 0c sub $0xc,%esp
1089df: ff 73 18 pushl 0x18(%ebx)
1089e2: e8 69 18 00 00 call 10a250 <rtems_semaphore_release>
args->ioctl_return = sc;
1089e7: 8b 55 e4 mov -0x1c(%ebp),%edx
1089ea: 8b 45 08 mov 0x8(%ebp),%eax
1089ed: 89 50 0c mov %edx,0xc(%eax)
return sc;
1089f0: 83 c4 10 add $0x10,%esp
}
1089f3: 8b 45 e4 mov -0x1c(%ebp),%eax
1089f6: 8d 65 f4 lea -0xc(%ebp),%esp
1089f9: 5b pop %ebx
1089fa: 5e pop %esi
1089fb: 5f pop %edi
1089fc: c9 leave
1089fd: c3 ret
001080e1 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
1080e1: 55 push %ebp
1080e2: 89 e5 mov %esp,%ebp
1080e4: 57 push %edi
1080e5: 56 push %esi
1080e6: 53 push %ebx
1080e7: 83 ec 20 sub $0x20,%esp
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
1080ea: 6a 00 push $0x0
1080ec: 6a 00 push $0x0
1080ee: ff 35 dc 41 12 00 pushl 0x1241dc
1080f4: e8 6b 20 00 00 call 10a164 <rtems_semaphore_obtain>
1080f9: 89 45 e4 mov %eax,-0x1c(%ebp)
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
1080fc: 83 c4 10 add $0x10,%esp
1080ff: 85 c0 test %eax,%eax
108101: 0f 85 d3 03 00 00 jne 1084da <rtems_termios_open+0x3f9><== NEVER TAKEN
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
108107: 8b 35 e4 41 12 00 mov 0x1241e4,%esi
10810d: 89 f2 mov %esi,%edx
10810f: eb 16 jmp 108127 <rtems_termios_open+0x46>
if ((tty->major == major) && (tty->minor == minor))
108111: 8b 45 08 mov 0x8(%ebp),%eax
108114: 39 42 0c cmp %eax,0xc(%edx)
108117: 75 0c jne 108125 <rtems_termios_open+0x44>
108119: 8b 4d 0c mov 0xc(%ebp),%ecx
10811c: 39 4a 10 cmp %ecx,0x10(%edx)
10811f: 0f 84 26 03 00 00 je 10844b <rtems_termios_open+0x36a><== ALWAYS TAKEN
sc = rtems_semaphore_obtain(
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
108125: 8b 12 mov (%edx),%edx
108127: 85 d2 test %edx,%edx
108129: 75 e6 jne 108111 <rtems_termios_open+0x30>
10812b: e9 b5 03 00 00 jmp 1084e5 <rtems_termios_open+0x404>
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
if (tty == NULL) {
rtems_semaphore_release (rtems_termios_ttyMutex);
108130: 83 ec 0c sub $0xc,%esp
108133: eb 30 jmp 108165 <rtems_termios_open+0x84>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
108135: a1 44 20 12 00 mov 0x122044,%eax
10813a: 89 42 64 mov %eax,0x64(%edx)
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
10813d: 8b 42 64 mov 0x64(%edx),%eax
108140: 83 ec 0c sub $0xc,%esp
108143: 50 push %eax
108144: 89 55 e0 mov %edx,-0x20(%ebp)
108147: e8 98 f4 ff ff call 1075e4 <malloc>
10814c: 89 c7 mov %eax,%edi
10814e: 8b 55 e0 mov -0x20(%ebp),%edx
108151: 89 42 58 mov %eax,0x58(%edx)
if (tty->rawInBuf.theBuf == NULL) {
108154: 83 c4 10 add $0x10,%esp
108157: 85 c0 test %eax,%eax
108159: 75 24 jne 10817f <rtems_termios_open+0x9e>
free(tty);
10815b: 83 ec 0c sub $0xc,%esp
10815e: 52 push %edx
10815f: e8 e4 f1 ff ff call 107348 <free>
rtems_semaphore_release (rtems_termios_ttyMutex);
108164: 5b pop %ebx
108165: ff 35 dc 41 12 00 pushl 0x1241dc
10816b: e8 e0 20 00 00 call 10a250 <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
108170: 83 c4 10 add $0x10,%esp
108173: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp)
10817a: e9 5b 03 00 00 jmp 1084da <rtems_termios_open+0x3f9>
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
10817f: a1 48 20 12 00 mov 0x122048,%eax
108184: 89 82 88 00 00 00 mov %eax,0x88(%edx)
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
10818a: 8b 82 88 00 00 00 mov 0x88(%edx),%eax
108190: 83 ec 0c sub $0xc,%esp
108193: 50 push %eax
108194: 89 55 e0 mov %edx,-0x20(%ebp)
108197: e8 48 f4 ff ff call 1075e4 <malloc>
10819c: 8b 55 e0 mov -0x20(%ebp),%edx
10819f: 89 42 7c mov %eax,0x7c(%edx)
if (tty->rawOutBuf.theBuf == NULL) {
1081a2: 83 c4 10 add $0x10,%esp
1081a5: 85 c0 test %eax,%eax
1081a7: 75 05 jne 1081ae <rtems_termios_open+0xcd><== ALWAYS TAKEN
free((void *)(tty->rawInBuf.theBuf));
1081a9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1081ac: eb 2e jmp 1081dc <rtems_termios_open+0xfb><== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
1081ae: 83 ec 0c sub $0xc,%esp
1081b1: ff 35 40 20 12 00 pushl 0x122040
1081b7: 89 55 e0 mov %edx,-0x20(%ebp)
1081ba: 89 45 dc mov %eax,-0x24(%ebp)
1081bd: e8 22 f4 ff ff call 1075e4 <malloc>
1081c2: 8b 55 e0 mov -0x20(%ebp),%edx
1081c5: 89 42 1c mov %eax,0x1c(%edx)
if (tty->cbuf == NULL) {
1081c8: 83 c4 10 add $0x10,%esp
1081cb: 85 c0 test %eax,%eax
1081cd: 8b 4d dc mov -0x24(%ebp),%ecx
1081d0: 75 19 jne 1081eb <rtems_termios_open+0x10a>
free((void *)(tty->rawOutBuf.theBuf));
1081d2: 83 ec 0c sub $0xc,%esp
1081d5: 51 push %ecx
1081d6: e8 6d f1 ff ff call 107348 <free>
free((void *)(tty->rawInBuf.theBuf));
1081db: 59 pop %ecx
1081dc: 57 push %edi
1081dd: e8 66 f1 ff ff call 107348 <free>
free(tty);
1081e2: 5a pop %edx
1081e3: 8b 55 e0 mov -0x20(%ebp),%edx
1081e6: e9 73 ff ff ff jmp 10815e <rtems_termios_open+0x7d>
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
1081eb: c7 82 d4 00 00 00 00 movl $0x0,0xd4(%edx)
1081f2: 00 00 00
tty->tty_snd.sw_arg = NULL;
1081f5: c7 82 d8 00 00 00 00 movl $0x0,0xd8(%edx)
1081fc: 00 00 00
tty->tty_rcv.sw_pfn = NULL;
1081ff: c7 82 dc 00 00 00 00 movl $0x0,0xdc(%edx)
108206: 00 00 00
tty->tty_rcv.sw_arg = NULL;
108209: c7 82 e0 00 00 00 00 movl $0x0,0xe0(%edx)
108210: 00 00 00
tty->tty_rcvwakeup = 0;
108213: c7 82 e4 00 00 00 00 movl $0x0,0xe4(%edx)
10821a: 00 00 00
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
10821d: 89 32 mov %esi,(%edx)
tty->back = NULL;
10821f: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
if (rtems_termios_ttyHead != NULL)
108226: 85 f6 test %esi,%esi
108228: 74 03 je 10822d <rtems_termios_open+0x14c>
rtems_termios_ttyHead->back = tty;
10822a: 89 56 04 mov %edx,0x4(%esi)
rtems_termios_ttyHead = tty;
10822d: 89 1d e4 41 12 00 mov %ebx,0x1241e4
if (rtems_termios_ttyTail == NULL)
108233: 83 3d e0 41 12 00 00 cmpl $0x0,0x1241e0
10823a: 75 06 jne 108242 <rtems_termios_open+0x161>
rtems_termios_ttyTail = tty;
10823c: 89 1d e0 41 12 00 mov %ebx,0x1241e0
tty->minor = minor;
108242: 8b 45 0c mov 0xc(%ebp),%eax
108245: 89 43 10 mov %eax,0x10(%ebx)
tty->major = major;
108248: 8b 4d 08 mov 0x8(%ebp),%ecx
10824b: 89 4b 0c mov %ecx,0xc(%ebx)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
10824e: 83 ec 0c sub $0xc,%esp
108251: 8d 43 14 lea 0x14(%ebx),%eax
108254: 50 push %eax
108255: 6a 00 push $0x0
108257: 6a 54 push $0x54
108259: 6a 01 push $0x1
rtems_build_name ('T', 'R', 'i', c),
10825b: 0f be 05 4c 20 12 00 movsbl 0x12204c,%eax
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
108262: 0d 00 69 52 54 or $0x54526900,%eax
108267: 50 push %eax
108268: 89 55 e0 mov %edx,-0x20(%ebp)
10826b: e8 cc 1c 00 00 call 109f3c <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'i', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
108270: 83 c4 20 add $0x20,%esp
108273: 85 c0 test %eax,%eax
108275: 8b 55 e0 mov -0x20(%ebp),%edx
108278: 0f 85 42 02 00 00 jne 1084c0 <rtems_termios_open+0x3df>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
10827e: 83 ec 0c sub $0xc,%esp
108281: 8d 43 18 lea 0x18(%ebx),%eax
108284: 50 push %eax
108285: 6a 00 push $0x0
108287: 6a 54 push $0x54
108289: 6a 01 push $0x1
rtems_build_name ('T', 'R', 'o', c),
10828b: 0f be 05 4c 20 12 00 movsbl 0x12204c,%eax
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
108292: 0d 00 6f 52 54 or $0x54526f00,%eax
108297: 50 push %eax
108298: 89 55 e0 mov %edx,-0x20(%ebp)
10829b: e8 9c 1c 00 00 call 109f3c <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'o', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
1082a0: 83 c4 20 add $0x20,%esp
1082a3: 85 c0 test %eax,%eax
1082a5: 8b 55 e0 mov -0x20(%ebp),%edx
1082a8: 0f 85 12 02 00 00 jne 1084c0 <rtems_termios_open+0x3df>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
1082ae: 83 ec 0c sub $0xc,%esp
1082b1: 8d 83 8c 00 00 00 lea 0x8c(%ebx),%eax
1082b7: 50 push %eax
1082b8: 6a 00 push $0x0
1082ba: 6a 20 push $0x20
1082bc: 6a 00 push $0x0
rtems_build_name ('T', 'R', 'x', c),
1082be: 0f be 05 4c 20 12 00 movsbl 0x12204c,%eax
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
1082c5: 0d 00 78 52 54 or $0x54527800,%eax
1082ca: 50 push %eax
1082cb: 89 55 e0 mov %edx,-0x20(%ebp)
1082ce: e8 69 1c 00 00 call 109f3c <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'x', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
1082d3: 83 c4 20 add $0x20,%esp
1082d6: 85 c0 test %eax,%eax
1082d8: 8b 55 e0 mov -0x20(%ebp),%edx
1082db: 0f 85 df 01 00 00 jne 1084c0 <rtems_termios_open+0x3df>
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
1082e1: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx)
1082e8: 00 00 00
/*
* Set callbacks
*/
tty->device = *callbacks;
1082eb: 8d bb 98 00 00 00 lea 0x98(%ebx),%edi
1082f1: b9 08 00 00 00 mov $0x8,%ecx
1082f6: 8b 75 14 mov 0x14(%ebp),%esi
1082f9: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
1082fb: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
108302: 75 74 jne 108378 <rtems_termios_open+0x297>
sc = rtems_task_create (
108304: 50 push %eax
108305: 50 push %eax
108306: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax
10830c: 50 push %eax
10830d: 6a 00 push $0x0
10830f: 68 00 05 00 00 push $0x500
108314: 68 00 04 00 00 push $0x400
108319: 6a 0a push $0xa
rtems_build_name ('T', 'x', 'T', c),
10831b: 0f be 05 4c 20 12 00 movsbl 0x12204c,%eax
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
108322: 0d 00 54 78 54 or $0x54785400,%eax
108327: 50 push %eax
108328: 89 55 e0 mov %edx,-0x20(%ebp)
10832b: e8 b0 1f 00 00 call 10a2e0 <rtems_task_create>
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
108330: 83 c4 20 add $0x20,%esp
108333: 85 c0 test %eax,%eax
108335: 8b 55 e0 mov -0x20(%ebp),%edx
108338: 0f 85 82 01 00 00 jne 1084c0 <rtems_termios_open+0x3df><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
10833e: 57 push %edi
10833f: 57 push %edi
108340: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax
108346: 50 push %eax
108347: 6a 00 push $0x0
108349: 68 00 05 00 00 push $0x500
10834e: 68 00 04 00 00 push $0x400
108353: 6a 09 push $0x9
rtems_build_name ('R', 'x', 'T', c),
108355: 0f be 05 4c 20 12 00 movsbl 0x12204c,%eax
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
10835c: 0d 00 54 78 52 or $0x52785400,%eax
108361: 50 push %eax
108362: 89 55 e0 mov %edx,-0x20(%ebp)
108365: e8 76 1f 00 00 call 10a2e0 <rtems_task_create>
TERMIOS_RXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
10836a: 83 c4 20 add $0x20,%esp
10836d: 85 c0 test %eax,%eax
10836f: 8b 55 e0 mov -0x20(%ebp),%edx
108372: 0f 85 48 01 00 00 jne 1084c0 <rtems_termios_open+0x3df><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
108378: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
10837f: 74 09 je 10838a <rtems_termios_open+0x2a9>
108381: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
108388: 75 30 jne 1083ba <rtems_termios_open+0x2d9>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
10838a: 83 ec 0c sub $0xc,%esp
10838d: 8d 43 68 lea 0x68(%ebx),%eax
108390: 50 push %eax
108391: 6a 00 push $0x0
108393: 6a 24 push $0x24
108395: 6a 00 push $0x0
rtems_build_name ('T', 'R', 'r', c),
108397: 0f be 05 4c 20 12 00 movsbl 0x12204c,%eax
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
10839e: 0d 00 72 52 54 or $0x54527200,%eax
1083a3: 50 push %eax
1083a4: 89 55 e0 mov %edx,-0x20(%ebp)
1083a7: e8 90 1b 00 00 call 109f3c <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'r', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->rawInBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
1083ac: 83 c4 20 add $0x20,%esp
1083af: 85 c0 test %eax,%eax
1083b1: 8b 55 e0 mov -0x20(%ebp),%edx
1083b4: 0f 85 06 01 00 00 jne 1084c0 <rtems_termios_open+0x3df>
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
1083ba: c7 43 30 02 25 00 00 movl $0x2502,0x30(%ebx)
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
1083c1: c7 43 34 05 18 00 00 movl $0x1805,0x34(%ebx)
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
1083c8: c7 43 38 bd 08 00 00 movl $0x8bd,0x38(%ebx)
tty->termios.c_lflag =
1083cf: c7 43 3c 3b 82 00 00 movl $0x823b,0x3c(%ebx)
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
1083d6: c6 43 41 03 movb $0x3,0x41(%ebx)
tty->termios.c_cc[VQUIT] = '\034';
1083da: c6 43 42 1c movb $0x1c,0x42(%ebx)
tty->termios.c_cc[VERASE] = '\177';
1083de: c6 43 43 7f movb $0x7f,0x43(%ebx)
tty->termios.c_cc[VKILL] = '\025';
1083e2: c6 43 44 15 movb $0x15,0x44(%ebx)
tty->termios.c_cc[VEOF] = '\004';
1083e6: c6 43 45 04 movb $0x4,0x45(%ebx)
tty->termios.c_cc[VEOL] = '\000';
1083ea: c6 43 4c 00 movb $0x0,0x4c(%ebx)
tty->termios.c_cc[VEOL2] = '\000';
1083ee: c6 43 51 00 movb $0x0,0x51(%ebx)
tty->termios.c_cc[VSTART] = '\021';
1083f2: c6 43 49 11 movb $0x11,0x49(%ebx)
tty->termios.c_cc[VSTOP] = '\023';
1083f6: c6 43 4a 13 movb $0x13,0x4a(%ebx)
tty->termios.c_cc[VSUSP] = '\032';
1083fa: c6 43 4b 1a movb $0x1a,0x4b(%ebx)
tty->termios.c_cc[VREPRINT] = '\022';
1083fe: c6 43 4d 12 movb $0x12,0x4d(%ebx)
tty->termios.c_cc[VDISCARD] = '\017';
108402: c6 43 4e 0f movb $0xf,0x4e(%ebx)
tty->termios.c_cc[VWERASE] = '\027';
108406: c6 43 4f 17 movb $0x17,0x4f(%ebx)
tty->termios.c_cc[VLNEXT] = '\026';
10840a: c6 43 50 16 movb $0x16,0x50(%ebx)
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
10840e: c7 83 b8 00 00 00 00 movl $0x0,0xb8(%ebx)
108415: 00 00 00
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
108418: 8b 43 64 mov 0x64(%ebx),%eax
10841b: d1 e8 shr %eax
10841d: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
tty->highwater = tty->rawInBuf.Size * 3/4;
108423: 8b 43 64 mov 0x64(%ebx),%eax
108426: 8d 04 40 lea (%eax,%eax,2),%eax
108429: c1 e8 02 shr $0x2,%eax
10842c: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx)
/*
* Bump name characer
*/
if (c++ == 'z')
108432: a0 4c 20 12 00 mov 0x12204c,%al
108437: 8d 48 01 lea 0x1(%eax),%ecx
10843a: 88 0d 4c 20 12 00 mov %cl,0x12204c
108440: 3c 7a cmp $0x7a,%al
108442: 75 07 jne 10844b <rtems_termios_open+0x36a>
c = 'a';
108444: c6 05 4c 20 12 00 61 movb $0x61,0x12204c
}
args->iop->data1 = tty;
10844b: 8b 4d 10 mov 0x10(%ebp),%ecx
10844e: 8b 01 mov (%ecx),%eax
108450: 89 50 34 mov %edx,0x34(%eax)
if (!tty->refcount++) {
108453: 8b 42 08 mov 0x8(%edx),%eax
108456: 8d 48 01 lea 0x1(%eax),%ecx
108459: 89 4a 08 mov %ecx,0x8(%edx)
10845c: 85 c0 test %eax,%eax
10845e: 75 69 jne 1084c9 <rtems_termios_open+0x3e8>
if (tty->device.firstOpen)
108460: 8b 82 98 00 00 00 mov 0x98(%edx),%eax
108466: 85 c0 test %eax,%eax
108468: 74 15 je 10847f <rtems_termios_open+0x39e>
(*tty->device.firstOpen)(major, minor, arg);
10846a: 56 push %esi
10846b: ff 75 10 pushl 0x10(%ebp)
10846e: ff 75 0c pushl 0xc(%ebp)
108471: ff 75 08 pushl 0x8(%ebp)
108474: 89 55 e0 mov %edx,-0x20(%ebp)
108477: ff d0 call *%eax
108479: 83 c4 10 add $0x10,%esp
10847c: 8b 55 e0 mov -0x20(%ebp),%edx
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
10847f: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx)
108486: 75 41 jne 1084c9 <rtems_termios_open+0x3e8>
sc = rtems_task_start(
108488: 53 push %ebx
108489: 52 push %edx
10848a: 68 aa 95 10 00 push $0x1095aa
10848f: ff b2 c4 00 00 00 pushl 0xc4(%edx)
108495: 89 55 e0 mov %edx,-0x20(%ebp)
108498: e8 b7 20 00 00 call 10a554 <rtems_task_start>
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
10849d: 83 c4 10 add $0x10,%esp
1084a0: 85 c0 test %eax,%eax
1084a2: 8b 55 e0 mov -0x20(%ebp),%edx
1084a5: 75 19 jne 1084c0 <rtems_termios_open+0x3df><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
1084a7: 51 push %ecx
1084a8: 52 push %edx
1084a9: 68 dc 97 10 00 push $0x1097dc
1084ae: ff b2 c8 00 00 00 pushl 0xc8(%edx)
1084b4: e8 9b 20 00 00 call 10a554 <rtems_task_start>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
1084b9: 83 c4 10 add $0x10,%esp
1084bc: 85 c0 test %eax,%eax
1084be: 74 09 je 1084c9 <rtems_termios_open+0x3e8><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
1084c0: 83 ec 0c sub $0xc,%esp
1084c3: 50 push %eax
1084c4: e8 63 22 00 00 call 10a72c <rtems_fatal_error_occurred>
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
1084c9: 83 ec 0c sub $0xc,%esp
1084cc: ff 35 dc 41 12 00 pushl 0x1241dc
1084d2: e8 79 1d 00 00 call 10a250 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
1084d7: 83 c4 10 add $0x10,%esp
}
1084da: 8b 45 e4 mov -0x1c(%ebp),%eax
1084dd: 8d 65 f4 lea -0xc(%ebp),%esp
1084e0: 5b pop %ebx
1084e1: 5e pop %esi
1084e2: 5f pop %edi
1084e3: c9 leave
1084e4: c3 ret
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
1084e5: 52 push %edx
1084e6: 52 push %edx
1084e7: 68 e8 00 00 00 push $0xe8
1084ec: 6a 01 push $0x1
1084ee: e8 e9 ec ff ff call 1071dc <calloc>
1084f3: 89 c2 mov %eax,%edx
1084f5: 89 c3 mov %eax,%ebx
if (tty == NULL) {
1084f7: 83 c4 10 add $0x10,%esp
1084fa: 85 c0 test %eax,%eax
1084fc: 0f 85 33 fc ff ff jne 108135 <rtems_termios_open+0x54>
108502: e9 29 fc ff ff jmp 108130 <rtems_termios_open+0x4f>
001089fe <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
1089fe: 55 push %ebp
1089ff: 89 e5 mov %esp,%ebp
108a01: 57 push %edi
108a02: 56 push %esi
108a03: 53 push %ebx
108a04: 83 ec 3c sub $0x3c,%esp
108a07: 8b 45 08 mov 0x8(%ebp),%eax
108a0a: 8b 75 0c mov 0xc(%ebp),%esi
108a0d: 8b 5d 10 mov 0x10(%ebp),%ebx
const unsigned char *buf = _buf;
108a10: 89 c7 mov %eax,%edi
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
108a12: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx)
108a19: 75 1b jne 108a36 <rtems_termios_puts+0x38>
(*tty->device.write)(tty->minor, (void *)buf, len);
108a1b: 89 75 10 mov %esi,0x10(%ebp)
108a1e: 89 45 0c mov %eax,0xc(%ebp)
108a21: 8b 43 10 mov 0x10(%ebx),%eax
108a24: 89 45 08 mov %eax,0x8(%ebp)
108a27: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
108a2d: 8d 65 f4 lea -0xc(%ebp),%esp
108a30: 5b pop %ebx
108a31: 5e pop %esi
108a32: 5f pop %edi
108a33: c9 leave
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
108a34: ff e0 jmp *%eax
return;
}
newHead = tty->rawOutBuf.Head;
108a36: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
108a3c: 89 45 e4 mov %eax,-0x1c(%ebp)
while (len) {
108a3f: e9 ca 00 00 00 jmp 108b0e <rtems_termios_puts+0x110>
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
108a44: 8b 45 e4 mov -0x1c(%ebp),%eax
108a47: 40 inc %eax
108a48: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
108a4e: 31 d2 xor %edx,%edx
108a50: f7 f1 div %ecx
108a52: 89 55 c4 mov %edx,-0x3c(%ebp)
108a55: 89 55 e4 mov %edx,-0x1c(%ebp)
rtems_interrupt_disable (level);
108a58: 9c pushf
108a59: fa cli
108a5a: 8f 45 d4 popl -0x2c(%ebp)
108a5d: 8b 55 d4 mov -0x2c(%ebp),%edx
108a60: 8b 4d c4 mov -0x3c(%ebp),%ecx
while (newHead == tty->rawOutBuf.Tail) {
108a63: eb 35 jmp 108a9a <rtems_termios_puts+0x9c>
tty->rawOutBufState = rob_wait;
108a65: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
108a6c: 00 00 00
rtems_interrupt_enable (level);
108a6f: 52 push %edx
108a70: 9d popf
sc = rtems_semaphore_obtain(
108a71: 50 push %eax
108a72: 6a 00 push $0x0
108a74: 6a 00 push $0x0
108a76: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
108a7c: 89 4d e0 mov %ecx,-0x20(%ebp)
108a7f: e8 e0 16 00 00 call 10a164 <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
108a84: 83 c4 10 add $0x10,%esp
108a87: 85 c0 test %eax,%eax
108a89: 8b 4d e0 mov -0x20(%ebp),%ecx
108a8c: 74 09 je 108a97 <rtems_termios_puts+0x99><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
108a8e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108a91: 50 push %eax <== NOT EXECUTED
108a92: e8 95 1c 00 00 call 10a72c <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_interrupt_disable (level);
108a97: 9c pushf
108a98: fa cli
108a99: 5a pop %edx
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
108a9a: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
108aa0: 39 c1 cmp %eax,%ecx
108aa2: 74 c1 je 108a65 <rtems_termios_puts+0x67>
108aa4: 89 55 d4 mov %edx,-0x2c(%ebp)
108aa7: 89 4d c4 mov %ecx,-0x3c(%ebp)
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
108aaa: 8b 8b 80 00 00 00 mov 0x80(%ebx),%ecx
108ab0: 8a 07 mov (%edi),%al
108ab2: 8b 53 7c mov 0x7c(%ebx),%edx
108ab5: 88 04 0a mov %al,(%edx,%ecx,1)
108ab8: 47 inc %edi
tty->rawOutBuf.Head = newHead;
108ab9: 8b 4d c4 mov -0x3c(%ebp),%ecx
108abc: 89 8b 80 00 00 00 mov %ecx,0x80(%ebx)
if (tty->rawOutBufState == rob_idle) {
108ac2: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx)
108ac9: 75 3e jne 108b09 <rtems_termios_puts+0x10b>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
108acb: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108ad1: a8 10 test $0x10,%al
108ad3: 75 1b jne 108af0 <rtems_termios_puts+0xf2><== NEVER TAKEN
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
108ad5: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(tty->minor,
108adb: 51 push %ecx
108adc: 6a 01 push $0x1
108ade: 03 43 7c add 0x7c(%ebx),%eax
108ae1: 50 push %eax
108ae2: ff 73 10 pushl 0x10(%ebx)
108ae5: ff 93 a4 00 00 00 call *0xa4(%ebx)
108aeb: 83 c4 10 add $0x10,%esp
108aee: eb 0f jmp 108aff <rtems_termios_puts+0x101>
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
108af0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108af6: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
108af9: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
108aff: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
108b06: 00 00 00
}
rtems_interrupt_enable (level);
108b09: ff 75 d4 pushl -0x2c(%ebp)
108b0c: 9d popf
len--;
108b0d: 4e dec %esi
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
108b0e: 85 f6 test %esi,%esi
108b10: 0f 85 2e ff ff ff jne 108a44 <rtems_termios_puts+0x46>
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
108b16: 8d 65 f4 lea -0xc(%ebp),%esp
108b19: 5b pop %ebx
108b1a: 5e pop %esi
108b1b: 5f pop %edi
108b1c: c9 leave
108b1d: c3 ret
00109025 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
109025: 55 push %ebp
109026: 89 e5 mov %esp,%ebp
109028: 57 push %edi
109029: 56 push %esi
10902a: 53 push %ebx
10902b: 83 ec 40 sub $0x40,%esp
10902e: 8b 75 08 mov 0x8(%ebp),%esi
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
109031: 8b 06 mov (%esi),%eax
109033: 8b 58 34 mov 0x34(%eax),%ebx
uint32_t count = args->count;
109036: 8b 46 10 mov 0x10(%esi),%eax
109039: 89 45 e4 mov %eax,-0x1c(%ebp)
char *buffer = args->buffer;
10903c: 8b 46 0c mov 0xc(%esi),%eax
10903f: 89 45 e0 mov %eax,-0x20(%ebp)
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
109042: 6a 00 push $0x0
109044: 6a 00 push $0x0
109046: ff 73 14 pushl 0x14(%ebx)
109049: e8 16 11 00 00 call 10a164 <rtems_semaphore_obtain>
10904e: 89 45 dc mov %eax,-0x24(%ebp)
if (sc != RTEMS_SUCCESSFUL)
109051: 83 c4 10 add $0x10,%esp
109054: 85 c0 test %eax,%eax
109056: 0f 85 9d 02 00 00 jne 1092f9 <rtems_termios_read+0x2d4><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
10905c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
109062: c1 e0 05 shl $0x5,%eax
109065: 8b 80 9c 3e 12 00 mov 0x123e9c(%eax),%eax
10906b: 85 c0 test %eax,%eax
10906d: 74 19 je 109088 <rtems_termios_read+0x63>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
10906f: 57 push %edi
109070: 57 push %edi
109071: 56 push %esi
109072: 53 push %ebx
109073: ff d0 call *%eax
109075: 89 45 dc mov %eax,-0x24(%ebp)
tty->tty_rcvwakeup = 0;
109078: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10907f: 00 00 00
rtems_semaphore_release (tty->isem);
109082: 59 pop %ecx
109083: e9 66 02 00 00 jmp 1092ee <rtems_termios_read+0x2c9>
return sc;
}
if (tty->cindex == tty->ccount) {
109088: 8b 43 20 mov 0x20(%ebx),%eax
10908b: 39 43 24 cmp %eax,0x24(%ebx)
10908e: 0f 85 2d 02 00 00 jne 1092c1 <rtems_termios_read+0x29c><== NEVER TAKEN
tty->cindex = tty->ccount = 0;
109094: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
10909b: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
tty->read_start_column = tty->column;
1090a2: 8b 43 28 mov 0x28(%ebx),%eax
1090a5: 89 43 2c mov %eax,0x2c(%ebx)
if (tty->device.pollRead != NULL &&
1090a8: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
1090af: 0f 84 c4 00 00 00 je 109179 <rtems_termios_read+0x154>
1090b5: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx)
1090bc: 0f 85 b7 00 00 00 jne 109179 <rtems_termios_read+0x154>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
1090c2: f6 43 3c 02 testb $0x2,0x3c(%ebx)
1090c6: 74 35 je 1090fd <rtems_termios_read+0xd8>
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
1090c8: 83 ec 0c sub $0xc,%esp
1090cb: ff 73 10 pushl 0x10(%ebx)
1090ce: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (n < 0) {
1090d4: 83 c4 10 add $0x10,%esp
1090d7: 85 c0 test %eax,%eax
1090d9: 79 0f jns 1090ea <rtems_termios_read+0xc5>
rtems_task_wake_after (1);
1090db: 83 ec 0c sub $0xc,%esp
1090de: 6a 01 push $0x1
1090e0: e8 d3 14 00 00 call 10a5b8 <rtems_task_wake_after>
1090e5: 83 c4 10 add $0x10,%esp
1090e8: eb de jmp 1090c8 <rtems_termios_read+0xa3>
} else {
if (siproc (n, tty))
1090ea: 0f b6 c0 movzbl %al,%eax
1090ed: 89 da mov %ebx,%edx
1090ef: e8 38 fe ff ff call 108f2c <siproc>
1090f4: 85 c0 test %eax,%eax
1090f6: 74 d0 je 1090c8 <rtems_termios_read+0xa3>
1090f8: e9 c4 01 00 00 jmp 1092c1 <rtems_termios_read+0x29c>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
1090fd: e8 36 0a 00 00 call 109b38 <rtems_clock_get_ticks_since_boot>
109102: 89 c7 mov %eax,%edi
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
109104: 83 ec 0c sub $0xc,%esp
109107: ff 73 10 pushl 0x10(%ebx)
10910a: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (n < 0) {
109110: 83 c4 10 add $0x10,%esp
109113: 85 c0 test %eax,%eax
109115: 79 3d jns 109154 <rtems_termios_read+0x12f>
if (tty->termios.c_cc[VMIN]) {
109117: 80 7b 47 00 cmpb $0x0,0x47(%ebx)
10911b: 74 0e je 10912b <rtems_termios_read+0x106><== NEVER TAKEN
if (tty->termios.c_cc[VTIME] && tty->ccount) {
10911d: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
109121: 74 22 je 109145 <rtems_termios_read+0x120><== NEVER TAKEN
109123: 83 7b 20 00 cmpl $0x0,0x20(%ebx)
109127: 74 1c je 109145 <rtems_termios_read+0x120>
109129: eb 0a jmp 109135 <rtems_termios_read+0x110>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
10912b: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED
10912f: 0f 84 8c 01 00 00 je 1092c1 <rtems_termios_read+0x29c><== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
109135: e8 fe 09 00 00 call 109b38 <rtems_clock_get_ticks_since_boot>
if ((now - then) > tty->vtimeTicks) {
10913a: 29 f8 sub %edi,%eax
10913c: 3b 43 54 cmp 0x54(%ebx),%eax
10913f: 0f 87 7c 01 00 00 ja 1092c1 <rtems_termios_read+0x29c>
break;
}
}
rtems_task_wake_after (1);
109145: 83 ec 0c sub $0xc,%esp
109148: 6a 01 push $0x1
10914a: e8 69 14 00 00 call 10a5b8 <rtems_task_wake_after>
10914f: 83 c4 10 add $0x10,%esp
109152: eb b0 jmp 109104 <rtems_termios_read+0xdf>
} else {
siproc (n, tty);
109154: 0f b6 c0 movzbl %al,%eax
109157: 89 da mov %ebx,%edx
109159: e8 ce fd ff ff call 108f2c <siproc>
if (tty->ccount >= tty->termios.c_cc[VMIN])
10915e: 8a 43 47 mov 0x47(%ebx),%al
109161: 0f b6 d0 movzbl %al,%edx
109164: 39 53 20 cmp %edx,0x20(%ebx)
109167: 0f 8d 54 01 00 00 jge 1092c1 <rtems_termios_read+0x29c><== NEVER TAKEN
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
10916d: 84 c0 test %al,%al
10916f: 74 93 je 109104 <rtems_termios_read+0xdf><== NEVER TAKEN
109171: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
109175: 74 8d je 109104 <rtems_termios_read+0xdf><== NEVER TAKEN
109177: eb 84 jmp 1090fd <rtems_termios_read+0xd8>
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
109179: 8b 53 74 mov 0x74(%ebx),%edx
rtems_status_code sc;
int wait = (int)1;
10917c: bf 01 00 00 00 mov $0x1,%edi
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
109181: 8d 43 49 lea 0x49(%ebx),%eax
109184: 89 45 d0 mov %eax,-0x30(%ebp)
109187: e9 e6 00 00 00 jmp 109272 <rtems_termios_read+0x24d>
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
10918c: 8b 43 5c mov 0x5c(%ebx),%eax
10918f: 8b 4b 64 mov 0x64(%ebx),%ecx
109192: 40 inc %eax
109193: 31 d2 xor %edx,%edx
109195: f7 f1 div %ecx
c = tty->rawInBuf.theBuf[newHead];
109197: 8b 43 58 mov 0x58(%ebx),%eax
10919a: 8a 04 10 mov (%eax,%edx,1),%al
10919d: 88 45 db mov %al,-0x25(%ebp)
tty->rawInBuf.Head = newHead;
1091a0: 89 53 5c mov %edx,0x5c(%ebx)
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
1091a3: 8b 43 60 mov 0x60(%ebx),%eax
1091a6: 89 45 c4 mov %eax,-0x3c(%ebp)
1091a9: 8b 4b 64 mov 0x64(%ebx),%ecx
% tty->rawInBuf.Size)
1091ac: 8b 43 64 mov 0x64(%ebx),%eax
1091af: 89 45 d4 mov %eax,-0x2c(%ebp)
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
1091b2: 8b 45 c4 mov -0x3c(%ebp),%eax
1091b5: 8d 04 01 lea (%ecx,%eax,1),%eax
1091b8: 29 d0 sub %edx,%eax
% tty->rawInBuf.Size)
1091ba: 31 d2 xor %edx,%edx
1091bc: f7 75 d4 divl -0x2c(%ebp)
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
1091bf: 3b 93 bc 00 00 00 cmp 0xbc(%ebx),%edx
1091c5: 73 74 jae 10923b <rtems_termios_read+0x216><== NEVER TAKEN
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
1091c7: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1091cd: 83 e0 fe and $0xfffffffe,%eax
1091d0: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
1091d6: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1091dc: 25 02 02 00 00 and $0x202,%eax
1091e1: 3d 02 02 00 00 cmp $0x202,%eax
1091e6: 75 24 jne 10920c <rtems_termios_read+0x1e7><== ALWAYS TAKEN
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
1091e8: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
1091ef: 74 0a je 1091fb <rtems_termios_read+0x1d6><== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
1091f1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1091f7: a8 20 test $0x20,%al <== NOT EXECUTED
1091f9: 74 11 je 10920c <rtems_termios_read+0x1e7><== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
1091fb: 52 push %edx <== NOT EXECUTED
1091fc: 6a 01 push $0x1 <== NOT EXECUTED
1091fe: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED
109201: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109204: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
10920a: eb 2c jmp 109238 <rtems_termios_read+0x213><== NOT EXECUTED
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
10920c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109212: f6 c4 01 test $0x1,%ah
109215: 74 24 je 10923b <rtems_termios_read+0x216><== ALWAYS TAKEN
tty->flow_ctrl &= ~FL_IRTSOFF;
109217: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10921d: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
109220: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
109226: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED
10922c: 85 c0 test %eax,%eax <== NOT EXECUTED
10922e: 74 0b je 10923b <rtems_termios_read+0x216><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
109230: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109233: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109236: ff d0 call *%eax <== NOT EXECUTED
109238: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
10923b: f6 43 3c 02 testb $0x2,0x3c(%ebx)
10923f: 74 12 je 109253 <rtems_termios_read+0x22e><== NEVER TAKEN
if (siproc (c, tty))
109241: 0f b6 45 db movzbl -0x25(%ebp),%eax
109245: 89 da mov %ebx,%edx
109247: e8 e0 fc ff ff call 108f2c <siproc>
wait = 0;
10924c: 85 c0 test %eax,%eax
10924e: 0f 94 c0 sete %al
109251: eb 15 jmp 109268 <rtems_termios_read+0x243>
} else {
siproc (c, tty);
109253: 0f b6 45 db movzbl -0x25(%ebp),%eax <== NOT EXECUTED
109257: 89 da mov %ebx,%edx <== NOT EXECUTED
109259: e8 ce fc ff ff call 108f2c <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
10925e: 0f b6 43 47 movzbl 0x47(%ebx),%eax <== NOT EXECUTED
wait = 0;
109262: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED
109265: 0f 9c c0 setl %al <== NOT EXECUTED
109268: 0f b6 c0 movzbl %al,%eax
10926b: f7 d8 neg %eax
10926d: 21 c7 and %eax,%edi
}
timeout = tty->rawInBufSemaphoreTimeout;
10926f: 8b 53 70 mov 0x70(%ebx),%edx
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
109272: 8b 4b 5c mov 0x5c(%ebx),%ecx
109275: 8b 43 60 mov 0x60(%ebx),%eax
109278: 39 c1 cmp %eax,%ecx
10927a: 74 0f je 10928b <rtems_termios_read+0x266>
(tty->ccount < (CBUFSIZE-1))) {
10927c: a1 40 20 12 00 mov 0x122040,%eax
109281: 48 dec %eax
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
109282: 39 43 20 cmp %eax,0x20(%ebx)
109285: 0f 8c 01 ff ff ff jl 10918c <rtems_termios_read+0x167><== ALWAYS TAKEN
}
/*
* Wait for characters
*/
if ( wait ) {
10928b: 85 ff test %edi,%edi
10928d: 74 32 je 1092c1 <rtems_termios_read+0x29c>
sc = rtems_semaphore_obtain(
10928f: 50 push %eax
109290: 52 push %edx
109291: ff 73 6c pushl 0x6c(%ebx)
109294: ff 73 68 pushl 0x68(%ebx)
109297: 89 55 cc mov %edx,-0x34(%ebp)
10929a: e8 c5 0e 00 00 call 10a164 <rtems_semaphore_obtain>
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
10929f: 83 c4 10 add $0x10,%esp
1092a2: 85 c0 test %eax,%eax
1092a4: 8b 55 cc mov -0x34(%ebp),%edx
1092a7: 74 c9 je 109272 <rtems_termios_read+0x24d><== ALWAYS TAKEN
1092a9: eb 16 jmp 1092c1 <rtems_termios_read+0x29c><== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
1092ab: 8b 7b 1c mov 0x1c(%ebx),%edi
1092ae: 8b 45 e4 mov -0x1c(%ebp),%eax
1092b1: 8a 04 07 mov (%edi,%eax,1),%al
1092b4: 88 01 mov %al,(%ecx)
1092b6: 41 inc %ecx
1092b7: 8b 45 e4 mov -0x1c(%ebp),%eax
1092ba: 40 inc %eax
1092bb: 89 43 24 mov %eax,0x24(%ebx)
count--;
1092be: 4a dec %edx
1092bf: eb 06 jmp 1092c7 <rtems_termios_read+0x2a2>
1092c1: 8b 55 e4 mov -0x1c(%ebp),%edx
1092c4: 8b 4d e0 mov -0x20(%ebp),%ecx
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
1092c7: 85 d2 test %edx,%edx
1092c9: 74 0b je 1092d6 <rtems_termios_read+0x2b1>
1092cb: 8b 43 24 mov 0x24(%ebx),%eax
1092ce: 89 45 e4 mov %eax,-0x1c(%ebp)
1092d1: 3b 43 20 cmp 0x20(%ebx),%eax
1092d4: 7c d5 jl 1092ab <rtems_termios_read+0x286>
1092d6: 89 55 e4 mov %edx,-0x1c(%ebp)
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
1092d9: 8b 46 10 mov 0x10(%esi),%eax
1092dc: 29 d0 sub %edx,%eax
1092de: 89 46 18 mov %eax,0x18(%esi)
tty->tty_rcvwakeup = 0;
1092e1: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
1092e8: 00 00 00
rtems_semaphore_release (tty->isem);
1092eb: 83 ec 0c sub $0xc,%esp
1092ee: ff 73 14 pushl 0x14(%ebx)
1092f1: e8 5a 0f 00 00 call 10a250 <rtems_semaphore_release>
return sc;
1092f6: 83 c4 10 add $0x10,%esp
}
1092f9: 8b 45 dc mov -0x24(%ebp),%eax
1092fc: 8d 65 f4 lea -0xc(%ebp),%esp
1092ff: 5b pop %ebx
109300: 5e pop %esi
109301: 5f pop %edi
109302: c9 leave
109303: c3 ret
0010960e <rtems_termios_refill_transmitter>:
* in task-driven mode, this function is called in Tx task context
* in interrupt-driven mode, this function is called in TxIRQ context
*/
int
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
{
10960e: 55 push %ebp
10960f: 89 e5 mov %esp,%ebp
109611: 57 push %edi
109612: 56 push %esi
109613: 53 push %ebx
109614: 83 ec 0c sub $0xc,%esp
109617: 8b 5d 08 mov 0x8(%ebp),%ebx
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
10961a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109620: 25 03 04 00 00 and $0x403,%eax
109625: 3d 01 04 00 00 cmp $0x401,%eax
10962a: 75 2c jne 109658 <rtems_termios_refill_transmitter+0x4a><== ALWAYS TAKEN
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
10962c: 57 push %edi <== NOT EXECUTED
10962d: 6a 01 push $0x1 <== NOT EXECUTED
10962f: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED
109632: 50 push %eax <== NOT EXECUTED
109633: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109636: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
rtems_interrupt_disable(level);
10963c: 9c pushf <== NOT EXECUTED
10963d: fa cli <== NOT EXECUTED
10963e: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
10963f: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
109645: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10964b: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
10964e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
109654: 52 push %edx <== NOT EXECUTED
109655: 9d popf <== NOT EXECUTED
109656: eb 38 jmp 109690 <rtems_termios_refill_transmitter+0x82><== NOT EXECUTED
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
109658: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10965e: 83 e0 03 and $0x3,%eax
109661: 83 f8 02 cmp $0x2,%eax
109664: 75 37 jne 10969d <rtems_termios_refill_transmitter+0x8f><== ALWAYS TAKEN
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
109666: 56 push %esi <== NOT EXECUTED
109667: 6a 01 push $0x1 <== NOT EXECUTED
109669: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED
10966c: 50 push %eax <== NOT EXECUTED
10966d: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109670: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
rtems_interrupt_disable(level);
109676: 9c pushf <== NOT EXECUTED
109677: fa cli <== NOT EXECUTED
109678: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
109679: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
10967f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109685: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
109688: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
10968e: 52 push %edx <== NOT EXECUTED
10968f: 9d popf <== NOT EXECUTED
109690: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
nToSend = 1;
109693: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
109698: e9 35 01 00 00 jmp 1097d2 <rtems_termios_refill_transmitter+0x1c4><== NOT EXECUTED
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
10969d: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
1096a3: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
1096a9: 39 c2 cmp %eax,%edx
1096ab: 75 25 jne 1096d2 <rtems_termios_refill_transmitter+0xc4>
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
1096ad: 31 f6 xor %esi,%esi
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
1096af: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx)
1096b6: 0f 85 16 01 00 00 jne 1097d2 <rtems_termios_refill_transmitter+0x1c4><== ALWAYS TAKEN
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
1096bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1096bf: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED
1096c5: e8 86 0b 00 00 call 10a250 <rtems_semaphore_release><== NOT EXECUTED
1096ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1096cd: e9 00 01 00 00 jmp 1097d2 <rtems_termios_refill_transmitter+0x1c4><== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
1096d2: 9c pushf
1096d3: fa cli
1096d4: 58 pop %eax
len = tty->t_dqlen;
1096d5: 8b bb 90 00 00 00 mov 0x90(%ebx),%edi
tty->t_dqlen = 0;
1096db: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx)
1096e2: 00 00 00
rtems_interrupt_enable(level);
1096e5: 50 push %eax
1096e6: 9d popf
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
1096e7: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
1096ed: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
1096f3: 8d 04 07 lea (%edi,%eax,1),%eax
1096f6: 31 d2 xor %edx,%edx
1096f8: f7 f1 div %ecx
1096fa: 89 d7 mov %edx,%edi
tty->rawOutBuf.Tail = newTail;
1096fc: 89 93 84 00 00 00 mov %edx,0x84(%ebx)
if (tty->rawOutBufState == rob_wait) {
109702: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx)
109709: 75 11 jne 10971c <rtems_termios_refill_transmitter+0x10e>
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
10970b: 83 ec 0c sub $0xc,%esp
10970e: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
109714: e8 37 0b 00 00 call 10a250 <rtems_semaphore_release>
109719: 83 c4 10 add $0x10,%esp
}
if (newTail == tty->rawOutBuf.Head) {
10971c: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
109722: 39 c7 cmp %eax,%edi
109724: 75 2a jne 109750 <rtems_termios_refill_transmitter+0x142>
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
109726: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx)
10972d: 00 00 00
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
109730: 8b 83 d4 00 00 00 mov 0xd4(%ebx),%eax
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
nToSend = 0;
109736: 31 f6 xor %esi,%esi
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
109738: 85 c0 test %eax,%eax
10973a: 0f 84 8c 00 00 00 je 1097cc <rtems_termios_refill_transmitter+0x1be><== ALWAYS TAKEN
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
109740: 51 push %ecx <== NOT EXECUTED
109741: 51 push %ecx <== NOT EXECUTED
109742: ff b3 d8 00 00 00 pushl 0xd8(%ebx) <== NOT EXECUTED
109748: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED
10974b: 52 push %edx <== NOT EXECUTED
10974c: ff d0 call *%eax <== NOT EXECUTED
10974e: eb 79 jmp 1097c9 <rtems_termios_refill_transmitter+0x1bb><== NOT EXECUTED
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
109750: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109756: 25 10 02 00 00 and $0x210,%eax
10975b: 3d 10 02 00 00 cmp $0x210,%eax
109760: 75 22 jne 109784 <rtems_termios_refill_transmitter+0x176><== ALWAYS TAKEN
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
109762: 9c pushf <== NOT EXECUTED
109763: fa cli <== NOT EXECUTED
109764: 5a pop %edx <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
109765: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10976b: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
10976e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
109774: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED
10977b: 00 00 00
rtems_interrupt_enable(level);
10977e: 52 push %edx <== NOT EXECUTED
10977f: 9d popf <== NOT EXECUTED
nToSend = 0;
109780: 31 f6 xor %esi,%esi <== NOT EXECUTED
109782: eb 48 jmp 1097cc <rtems_termios_refill_transmitter+0x1be><== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
109784: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
10978a: 39 c7 cmp %eax,%edi
10978c: 76 08 jbe 109796 <rtems_termios_refill_transmitter+0x188>
nToSend = tty->rawOutBuf.Size - newTail;
10978e: 8b b3 88 00 00 00 mov 0x88(%ebx),%esi
109794: eb 06 jmp 10979c <rtems_termios_refill_transmitter+0x18e>
else
nToSend = tty->rawOutBuf.Head - newTail;
109796: 8b b3 80 00 00 00 mov 0x80(%ebx),%esi
10979c: 29 fe sub %edi,%esi
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
10979e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1097a4: f6 c4 06 test $0x6,%ah
1097a7: 74 05 je 1097ae <rtems_termios_refill_transmitter+0x1a0>
nToSend = 1;
1097a9: be 01 00 00 00 mov $0x1,%esi
}
tty->rawOutBufState = rob_busy; /*apm*/
1097ae: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
1097b5: 00 00 00
(*tty->device.write)(
1097b8: 52 push %edx
1097b9: 56 push %esi
1097ba: 8b 43 7c mov 0x7c(%ebx),%eax
1097bd: 01 f8 add %edi,%eax
1097bf: 50 push %eax
1097c0: ff 73 10 pushl 0x10(%ebx)
1097c3: ff 93 a4 00 00 00 call *0xa4(%ebx)
1097c9: 83 c4 10 add $0x10,%esp
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
1097cc: 89 bb 84 00 00 00 mov %edi,0x84(%ebx)
}
return nToSend;
}
1097d2: 89 f0 mov %esi,%eax
1097d4: 8d 65 f4 lea -0xc(%ebp),%esp
1097d7: 5b pop %ebx
1097d8: 5e pop %esi
1097d9: 5f pop %edi
1097da: c9 leave
1097db: c3 ret
001095aa <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
1095aa: 55 push %ebp
1095ab: 89 e5 mov %esp,%ebp
1095ad: 57 push %edi
1095ae: 56 push %esi
1095af: 53 push %ebx
1095b0: 83 ec 1c sub $0x1c,%esp
1095b3: 8b 5d 08 mov 0x8(%ebp),%ebx
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
1095b6: 8d 7d e0 lea -0x20(%ebp),%edi
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
1095b9: 8d 75 e7 lea -0x19(%ebp),%esi
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
1095bc: 57 push %edi
1095bd: 6a 00 push $0x0
1095bf: 6a 02 push $0x2
1095c1: 6a 03 push $0x3
1095c3: e8 d4 05 00 00 call 109b9c <rtems_event_receive>
(TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
1095c8: 83 c4 10 add $0x10,%esp
1095cb: f6 45 e0 01 testb $0x1,-0x20(%ebp)
1095cf: 74 17 je 1095e8 <rtems_termios_rxdaemon+0x3e><== ALWAYS TAKEN
tty->rxTaskId = 0;
1095d1: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx)
1095d8: 00 00 00
rtems_task_delete(RTEMS_SELF);
1095db: 83 ec 0c sub $0xc,%esp
1095de: 6a 00 push $0x0 <== NOT EXECUTED
1095e0: e8 33 0e 00 00 call 10a418 <rtems_task_delete> <== NOT EXECUTED
1095e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
1095e8: 83 ec 0c sub $0xc,%esp
1095eb: ff 73 10 pushl 0x10(%ebx)
1095ee: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (c != EOF) {
1095f4: 83 c4 10 add $0x10,%esp
1095f7: 83 f8 ff cmp $0xffffffff,%eax
1095fa: 74 c0 je 1095bc <rtems_termios_rxdaemon+0x12>
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
1095fc: 88 45 e7 mov %al,-0x19(%ebp)
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
1095ff: 50 push %eax
109600: 6a 01 push $0x1
109602: 56 push %esi
109603: 53 push %ebx
109604: e8 16 fd ff ff call 10931f <rtems_termios_enqueue_raw_characters>
109609: 83 c4 10 add $0x10,%esp
10960c: eb ae jmp 1095bc <rtems_termios_rxdaemon+0x12>
001097dc <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
1097dc: 55 push %ebp
1097dd: 89 e5 mov %esp,%ebp
1097df: 56 push %esi
1097e0: 53 push %ebx
1097e1: 83 ec 10 sub $0x10,%esp
1097e4: 8b 5d 08 mov 0x8(%ebp),%ebx
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
1097e7: 8d 75 f4 lea -0xc(%ebp),%esi
1097ea: 56 push %esi
1097eb: 6a 00 push $0x0
1097ed: 6a 02 push $0x2
1097ef: 6a 03 push $0x3
1097f1: e8 a6 03 00 00 call 109b9c <rtems_event_receive>
(TERMIOS_TX_START_EVENT | TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
1097f6: 83 c4 10 add $0x10,%esp
1097f9: f6 45 f4 01 testb $0x1,-0xc(%ebp)
1097fd: 74 17 je 109816 <rtems_termios_txdaemon+0x3a><== ALWAYS TAKEN
tty->txTaskId = 0;
1097ff: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED
109806: 00 00 00
rtems_task_delete(RTEMS_SELF);
109809: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10980c: 6a 00 push $0x0 <== NOT EXECUTED
10980e: e8 05 0c 00 00 call 10a418 <rtems_task_delete> <== NOT EXECUTED
109813: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
109816: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
10981c: c1 e0 05 shl $0x5,%eax
10981f: 8b 80 a8 3e 12 00 mov 0x123ea8(%eax),%eax
109825: 85 c0 test %eax,%eax
109827: 74 09 je 109832 <rtems_termios_txdaemon+0x56><== ALWAYS TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
109829: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10982c: 53 push %ebx <== NOT EXECUTED
10982d: ff d0 call *%eax <== NOT EXECUTED
10982f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
109832: 83 ec 0c sub $0xc,%esp
109835: 53 push %ebx
109836: e8 d3 fd ff ff call 10960e <rtems_termios_refill_transmitter>
}
10983b: 83 c4 10 add $0x10,%esp
10983e: eb aa jmp 1097ea <rtems_termios_txdaemon+0xe>
00108f7e <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
108f7e: 55 push %ebp
108f7f: 89 e5 mov %esp,%ebp
108f81: 57 push %edi
108f82: 56 push %esi
108f83: 53 push %ebx
108f84: 83 ec 20 sub $0x20,%esp
108f87: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
108f8a: 8b 03 mov (%ebx),%eax
108f8c: 8b 70 34 mov 0x34(%eax),%esi
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108f8f: 6a 00 push $0x0
108f91: 6a 00 push $0x0
108f93: ff 76 18 pushl 0x18(%esi)
108f96: e8 c9 11 00 00 call 10a164 <rtems_semaphore_obtain>
108f9b: 89 c7 mov %eax,%edi
if (sc != RTEMS_SUCCESSFUL)
108f9d: 83 c4 10 add $0x10,%esp
108fa0: 85 c0 test %eax,%eax
108fa2: 75 77 jne 10901b <rtems_termios_write+0x9d><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
108fa4: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax
108faa: c1 e0 05 shl $0x5,%eax
108fad: 8b 80 a0 3e 12 00 mov 0x123ea0(%eax),%eax
108fb3: 85 c0 test %eax,%eax
108fb5: 74 0b je 108fc2 <rtems_termios_write+0x44>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
108fb7: 57 push %edi
108fb8: 57 push %edi
108fb9: 53 push %ebx
108fba: 56 push %esi
108fbb: ff d0 call *%eax
108fbd: 89 c7 mov %eax,%edi
rtems_semaphore_release (tty->osem);
108fbf: 5b pop %ebx
108fc0: eb 4e jmp 109010 <rtems_termios_write+0x92>
return sc;
}
if (tty->termios.c_oflag & OPOST) {
108fc2: f6 46 34 01 testb $0x1,0x34(%esi)
108fc6: 74 2f je 108ff7 <rtems_termios_write+0x79><== NEVER TAKEN
uint32_t count = args->count;
108fc8: 8b 4b 10 mov 0x10(%ebx),%ecx
char *buffer = args->buffer;
108fcb: 8b 43 0c mov 0xc(%ebx),%eax
108fce: 89 45 e4 mov %eax,-0x1c(%ebp)
while (count--)
108fd1: eb 18 jmp 108feb <rtems_termios_write+0x6d>
oproc (*buffer++, tty);
108fd3: 8b 55 e4 mov -0x1c(%ebp),%edx
108fd6: 0f b6 02 movzbl (%edx),%eax
108fd9: 42 inc %edx
108fda: 89 55 e4 mov %edx,-0x1c(%ebp)
108fdd: 89 f2 mov %esi,%edx
108fdf: 89 4d e0 mov %ecx,-0x20(%ebp)
108fe2: e8 37 fb ff ff call 108b1e <oproc>
108fe7: 8b 4d e0 mov -0x20(%ebp),%ecx
108fea: 49 dec %ecx
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
108feb: 85 c9 test %ecx,%ecx
108fed: 75 e4 jne 108fd3 <rtems_termios_write+0x55>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
108fef: 8b 43 10 mov 0x10(%ebx),%eax
108ff2: 89 43 18 mov %eax,0x18(%ebx)
108ff5: eb 16 jmp 10900d <rtems_termios_write+0x8f>
} else {
rtems_termios_puts (args->buffer, args->count, tty);
108ff7: 51 push %ecx <== NOT EXECUTED
108ff8: 56 push %esi <== NOT EXECUTED
108ff9: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
108ffc: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED
108fff: e8 fa f9 ff ff call 1089fe <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
109004: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
109007: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED
10900a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
rtems_semaphore_release (tty->osem);
10900d: 83 ec 0c sub $0xc,%esp
109010: ff 76 18 pushl 0x18(%esi)
109013: e8 38 12 00 00 call 10a250 <rtems_semaphore_release>
return sc;
109018: 83 c4 10 add $0x10,%esp
}
10901b: 89 f8 mov %edi,%eax
10901d: 8d 65 f4 lea -0xc(%ebp),%esp
109020: 5b pop %ebx
109021: 5e pop %esi
109022: 5f pop %edi
109023: c9 leave
109024: c3 ret
00116394 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
116394: 55 push %ebp
116395: 89 e5 mov %esp,%ebp
116397: 83 ec 1c sub $0x1c,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
11639a: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
11639d: 50 push %eax
11639e: ff 75 08 pushl 0x8(%ebp)
1163a1: 68 04 e0 13 00 push $0x13e004
1163a6: e8 4d 27 00 00 call 118af8 <_Objects_Get>
switch ( location ) {
1163ab: 83 c4 10 add $0x10,%esp
1163ae: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
1163b2: 75 1e jne 1163d2 <rtems_timer_cancel+0x3e>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
1163b4: 83 78 38 04 cmpl $0x4,0x38(%eax)
1163b8: 74 0f je 1163c9 <rtems_timer_cancel+0x35><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
1163ba: 83 ec 0c sub $0xc,%esp
1163bd: 83 c0 10 add $0x10,%eax
1163c0: 50 push %eax
1163c1: e8 4e 41 00 00 call 11a514 <_Watchdog_Remove>
1163c6: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
1163c9: e8 08 2f 00 00 call 1192d6 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1163ce: 31 c0 xor %eax,%eax
1163d0: eb 05 jmp 1163d7 <rtems_timer_cancel+0x43>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1163d2: b8 04 00 00 00 mov $0x4,%eax
}
1163d7: c9 leave
1163d8: c3 ret
001167f4 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
1167f4: 55 push %ebp
1167f5: 89 e5 mov %esp,%ebp
1167f7: 57 push %edi
1167f8: 56 push %esi
1167f9: 53 push %ebx
1167fa: 83 ec 1c sub $0x1c,%esp
1167fd: 8b 7d 0c mov 0xc(%ebp),%edi
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
116800: 8b 35 44 e0 13 00 mov 0x13e044,%esi
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
116806: 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 )
11680b: 85 f6 test %esi,%esi
11680d: 0f 84 b1 00 00 00 je 1168c4 <rtems_timer_server_fire_when+0xd0>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
116813: b3 0b mov $0xb,%bl
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
116815: 80 3d cc d6 13 00 00 cmpb $0x0,0x13d6cc
11681c: 0f 84 a2 00 00 00 je 1168c4 <rtems_timer_server_fire_when+0xd0><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
116822: b3 09 mov $0x9,%bl
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
116824: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
116828: 0f 84 96 00 00 00 je 1168c4 <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
11682e: 83 ec 0c sub $0xc,%esp
116831: 57 push %edi
116832: e8 b5 d6 ff ff call 113eec <_TOD_Validate>
116837: 83 c4 10 add $0x10,%esp
return RTEMS_INVALID_CLOCK;
11683a: b3 14 mov $0x14,%bl
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
11683c: 84 c0 test %al,%al
11683e: 0f 84 80 00 00 00 je 1168c4 <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
116844: 83 ec 0c sub $0xc,%esp
116847: 57 push %edi
116848: e8 37 d6 ff ff call 113e84 <_TOD_To_seconds>
11684d: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
11684f: 83 c4 10 add $0x10,%esp
116852: 3b 05 44 d7 13 00 cmp 0x13d744,%eax
116858: 76 6a jbe 1168c4 <rtems_timer_server_fire_when+0xd0>
11685a: 51 push %ecx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
11685b: 8d 45 e4 lea -0x1c(%ebp),%eax
11685e: 50 push %eax
11685f: ff 75 08 pushl 0x8(%ebp)
116862: 68 04 e0 13 00 push $0x13e004
116867: e8 8c 22 00 00 call 118af8 <_Objects_Get>
11686c: 89 c3 mov %eax,%ebx
switch ( location ) {
11686e: 83 c4 10 add $0x10,%esp
116871: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
116875: 75 48 jne 1168bf <rtems_timer_server_fire_when+0xcb>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
116877: 83 ec 0c sub $0xc,%esp
11687a: 8d 40 10 lea 0x10(%eax),%eax
11687d: 50 push %eax
11687e: e8 91 3c 00 00 call 11a514 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
116883: 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;
11688a: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
the_watchdog->routine = routine;
116891: 8b 45 10 mov 0x10(%ebp),%eax
116894: 89 43 2c mov %eax,0x2c(%ebx)
the_watchdog->id = id;
116897: 8b 45 08 mov 0x8(%ebp),%eax
11689a: 89 43 30 mov %eax,0x30(%ebx)
the_watchdog->user_data = user_data;
11689d: 8b 45 14 mov 0x14(%ebp),%eax
1168a0: 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();
1168a3: 2b 3d 44 d7 13 00 sub 0x13d744,%edi
1168a9: 89 7b 1c mov %edi,0x1c(%ebx)
(*timer_server->schedule_operation)( timer_server, the_timer );
1168ac: 58 pop %eax
1168ad: 5a pop %edx
1168ae: 53 push %ebx
1168af: 56 push %esi
1168b0: ff 56 04 call *0x4(%esi)
_Thread_Enable_dispatch();
1168b3: e8 1e 2a 00 00 call 1192d6 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1168b8: 83 c4 10 add $0x10,%esp
1168bb: 31 db xor %ebx,%ebx
1168bd: eb 05 jmp 1168c4 <rtems_timer_server_fire_when+0xd0>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1168bf: bb 04 00 00 00 mov $0x4,%ebx
}
1168c4: 89 d8 mov %ebx,%eax
1168c6: 8d 65 f4 lea -0xc(%ebp),%esp
1168c9: 5b pop %ebx
1168ca: 5e pop %esi
1168cb: 5f pop %edi
1168cc: c9 leave
1168cd: c3 ret
0010b155 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
10b155: 55 push %ebp
10b156: 89 e5 mov %esp,%ebp
10b158: 57 push %edi
10b159: 56 push %esi
10b15a: 53 push %ebx
10b15b: 83 ec 1c sub $0x1c,%esp
10b15e: 89 c3 mov %eax,%ebx
10b160: 89 55 e4 mov %edx,-0x1c(%ebp)
10b163: 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) {
10b166: a9 00 00 00 20 test $0x20000000,%eax
10b16b: 74 2c je 10b199 <rtems_verror+0x44>
if (rtems_panic_in_progress++)
10b16d: a1 08 a3 12 00 mov 0x12a308,%eax
10b172: 8d 50 01 lea 0x1(%eax),%edx
10b175: 89 15 08 a3 12 00 mov %edx,0x12a308
10b17b: 85 c0 test %eax,%eax
10b17d: 74 0b je 10b18a <rtems_verror+0x35> <== ALWAYS TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b17f: a1 58 a4 12 00 mov 0x12a458,%eax <== NOT EXECUTED
10b184: 40 inc %eax <== NOT EXECUTED
10b185: a3 58 a4 12 00 mov %eax,0x12a458 <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
10b18a: 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)
10b18c: 83 3d 08 a3 12 00 02 cmpl $0x2,0x12a308
10b193: 0f 8f da 00 00 00 jg 10b273 <rtems_verror+0x11e> <== NEVER TAKEN
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
10b199: 83 ec 0c sub $0xc,%esp
10b19c: a1 a0 81 12 00 mov 0x1281a0,%eax
10b1a1: ff 70 08 pushl 0x8(%eax)
10b1a4: e8 43 ab 00 00 call 115cec <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
10b1a9: 89 df mov %ebx,%edi
10b1ab: 81 e7 ff ff ff 8f and $0x8fffffff,%edi
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
10b1b1: 83 c4 10 add $0x10,%esp
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
10b1b4: 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? */
10b1b6: 81 e3 00 00 00 40 and $0x40000000,%ebx
10b1bc: 74 07 je 10b1c5 <rtems_verror+0x70>
local_errno = errno;
10b1be: e8 91 a7 00 00 call 115954 <__errno>
10b1c3: 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);
10b1c5: 53 push %ebx
10b1c6: ff 75 e0 pushl -0x20(%ebp)
10b1c9: ff 75 e4 pushl -0x1c(%ebp)
10b1cc: a1 a0 81 12 00 mov 0x1281a0,%eax
10b1d1: ff 70 0c pushl 0xc(%eax)
10b1d4: e8 77 09 01 00 call 11bb50 <vfprintf>
10b1d9: 89 c3 mov %eax,%ebx
if (status)
10b1db: 83 c4 10 add $0x10,%esp
10b1de: 85 ff test %edi,%edi
10b1e0: 74 24 je 10b206 <rtems_verror+0xb1>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
10b1e2: 83 ec 0c sub $0xc,%esp
10b1e5: 57 push %edi
10b1e6: e8 55 ff ff ff call 10b140 <rtems_status_text>
10b1eb: 83 c4 0c add $0xc,%esp
10b1ee: 50 push %eax
10b1ef: 68 27 3b 12 00 push $0x123b27
10b1f4: a1 a0 81 12 00 mov 0x1281a0,%eax
10b1f9: ff 70 0c pushl 0xc(%eax)
10b1fc: e8 df ae 00 00 call 1160e0 <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
10b201: 01 c3 add %eax,%ebx
10b203: 83 c4 10 add $0x10,%esp
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
10b206: 83 fe 00 cmp $0x0,%esi
10b209: 74 40 je 10b24b <rtems_verror+0xf6>
if ((local_errno > 0) && *strerror(local_errno))
10b20b: 7e 25 jle 10b232 <rtems_verror+0xdd>
10b20d: 83 ec 0c sub $0xc,%esp
10b210: 56 push %esi
10b211: e8 76 b7 00 00 call 11698c <strerror>
10b216: 83 c4 10 add $0x10,%esp
10b219: 80 38 00 cmpb $0x0,(%eax)
10b21c: 74 14 je 10b232 <rtems_verror+0xdd> <== NEVER TAKEN
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
10b21e: 83 ec 0c sub $0xc,%esp
10b221: 56 push %esi
10b222: e8 65 b7 00 00 call 11698c <strerror>
10b227: 83 c4 0c add $0xc,%esp
10b22a: 50 push %eax
10b22b: 68 35 3b 12 00 push $0x123b35
10b230: eb 07 jmp 10b239 <rtems_verror+0xe4>
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
10b232: 51 push %ecx
10b233: 56 push %esi
10b234: 68 42 3b 12 00 push $0x123b42
10b239: a1 a0 81 12 00 mov 0x1281a0,%eax
10b23e: ff 70 0c pushl 0xc(%eax)
10b241: e8 9a ae 00 00 call 1160e0 <fprintf>
10b246: 01 c3 add %eax,%ebx
10b248: 83 c4 10 add $0x10,%esp
}
chars_written += fprintf(stderr, "\n");
10b24b: 52 push %edx
10b24c: 52 push %edx
10b24d: 68 b4 42 12 00 push $0x1242b4
10b252: a1 a0 81 12 00 mov 0x1281a0,%eax
10b257: ff 70 0c pushl 0xc(%eax)
10b25a: e8 81 ae 00 00 call 1160e0 <fprintf>
10b25f: 8d 34 18 lea (%eax,%ebx,1),%esi
(void) fflush(stderr);
10b262: 58 pop %eax
10b263: a1 a0 81 12 00 mov 0x1281a0,%eax
10b268: ff 70 0c pushl 0xc(%eax)
10b26b: e8 7c aa 00 00 call 115cec <fflush>
return chars_written;
10b270: 83 c4 10 add $0x10,%esp
}
10b273: 89 f0 mov %esi,%eax
10b275: 8d 65 f4 lea -0xc(%ebp),%esp
10b278: 5b pop %ebx
10b279: 5e pop %esi
10b27a: 5f pop %edi
10b27b: c9 leave
10b27c: c3 ret
00107930 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
107930: 55 push %ebp
107931: 89 e5 mov %esp,%ebp
107933: 57 push %edi
107934: 56 push %esi
107935: 53 push %ebx
107936: 83 ec 3c sub $0x3c,%esp
107939: 89 c3 mov %eax,%ebx
10793b: 89 55 e0 mov %edx,-0x20(%ebp)
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
int sign = 0;
10793e: 31 f6 xor %esi,%esi
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
107940: c7 45 e4 ff ff ff 7f movl $0x7fffffff,-0x1c(%ebp)
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
107947: 31 ff xor %edi,%edi
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
107949: 89 7d c4 mov %edi,-0x3c(%ebp)
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
10794c: 8b 43 04 mov 0x4(%ebx),%eax
10794f: 48 dec %eax
107950: 89 43 04 mov %eax,0x4(%ebx)
107953: 85 c0 test %eax,%eax
107955: 79 15 jns 10796c <scanInt+0x3c> <== ALWAYS TAKEN
107957: 50 push %eax <== NOT EXECUTED
107958: 50 push %eax <== NOT EXECUTED
107959: 53 push %ebx <== NOT EXECUTED
10795a: ff 35 20 41 12 00 pushl 0x124120 <== NOT EXECUTED
107960: e8 df be 00 00 call 113844 <__srget_r> <== NOT EXECUTED
107965: 89 c1 mov %eax,%ecx <== NOT EXECUTED
107967: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10796a: eb 08 jmp 107974 <scanInt+0x44> <== NOT EXECUTED
10796c: 8b 03 mov (%ebx),%eax
10796e: 0f b6 08 movzbl (%eax),%ecx
107971: 40 inc %eax
107972: 89 03 mov %eax,(%ebx)
if (c == ':')
107974: 83 f9 3a cmp $0x3a,%ecx
107977: 74 4a je 1079c3 <scanInt+0x93>
break;
if (sign == 0) {
107979: 85 f6 test %esi,%esi
10797b: 75 11 jne 10798e <scanInt+0x5e>
if (c == '-') {
sign = -1;
limit++;
continue;
}
sign = 1;
10797d: 66 be 01 00 mov $0x1,%si
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
107981: 83 f9 2d cmp $0x2d,%ecx
107984: 75 08 jne 10798e <scanInt+0x5e>
sign = -1;
limit++;
107986: ff 45 e4 incl -0x1c(%ebp)
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
107989: 83 ce ff or $0xffffffff,%esi
limit++;
continue;
10798c: eb be jmp 10794c <scanInt+0x1c>
}
sign = 1;
}
if (!isdigit(c))
10798e: a1 08 41 12 00 mov 0x124108,%eax
107993: f6 44 08 01 04 testb $0x4,0x1(%eax,%ecx,1)
107998: 74 41 je 1079db <scanInt+0xab>
return 0;
d = c - '0';
if ((i > (limit / 10))
10799a: 8b 45 e4 mov -0x1c(%ebp),%eax
10799d: bf 0a 00 00 00 mov $0xa,%edi
1079a2: 31 d2 xor %edx,%edx
1079a4: f7 f7 div %edi
1079a6: 89 55 d4 mov %edx,-0x2c(%ebp)
1079a9: 39 45 c4 cmp %eax,-0x3c(%ebp)
1079ac: 77 2d ja 1079db <scanInt+0xab>
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
1079ae: 83 e9 30 sub $0x30,%ecx
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
1079b1: 39 45 c4 cmp %eax,-0x3c(%ebp)
1079b4: 75 04 jne 1079ba <scanInt+0x8a>
1079b6: 39 d1 cmp %edx,%ecx
1079b8: 77 21 ja 1079db <scanInt+0xab> <== ALWAYS TAKEN
return 0;
i = i * 10 + d;
1079ba: 6b 7d c4 0a imul $0xa,-0x3c(%ebp),%edi
1079be: 8d 3c 39 lea (%ecx,%edi,1),%edi
1079c1: eb 86 jmp 107949 <scanInt+0x19>
1079c3: 8b 7d c4 mov -0x3c(%ebp),%edi
}
if (sign == 0)
return 0;
1079c6: 31 c0 xor %eax,%eax
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
1079c8: 85 f6 test %esi,%esi
1079ca: 74 11 je 1079dd <scanInt+0xad> <== NEVER TAKEN
return 0;
*val = i * sign;
1079cc: 0f af f7 imul %edi,%esi
1079cf: 8b 45 e0 mov -0x20(%ebp),%eax
1079d2: 89 30 mov %esi,(%eax)
return 1;
1079d4: b8 01 00 00 00 mov $0x1,%eax
1079d9: eb 02 jmp 1079dd <scanInt+0xad>
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
1079db: 31 c0 xor %eax,%eax
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
1079dd: 8d 65 f4 lea -0xc(%ebp),%esp
1079e0: 5b pop %ebx
1079e1: 5e pop %esi
1079e2: 5f pop %edi
1079e3: c9 leave
1079e4: c3 ret
00107a70 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
107a70: 55 push %ebp
107a71: 89 e5 mov %esp,%ebp
107a73: 57 push %edi
107a74: 56 push %esi
107a75: 53 push %ebx
107a76: 83 ec 34 sub $0x34,%esp
107a79: 89 c7 mov %eax,%edi
107a7b: 89 d3 mov %edx,%ebx
107a7d: 89 4d d4 mov %ecx,-0x2c(%ebp)
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
107a80: 6a 00 push $0x0
107a82: 8d 45 08 lea 0x8(%ebp),%eax
107a85: 50 push %eax
107a86: 8d 4d d4 lea -0x2c(%ebp),%ecx
107a89: 89 f8 mov %edi,%eax
107a8b: e8 55 ff ff ff call 1079e5 <scanString>
107a90: 83 c4 10 add $0x10,%esp
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
107a93: 31 f6 xor %esi,%esi
{
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
107a95: 85 c0 test %eax,%eax
107a97: 0f 84 c2 00 00 00 je 107b5f <scangr+0xef>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
107a9d: 50 push %eax
107a9e: 50 push %eax
107a9f: 8d 53 04 lea 0x4(%ebx),%edx
107aa2: 6a 00 push $0x0
107aa4: 8d 45 08 lea 0x8(%ebp),%eax
107aa7: 50 push %eax
107aa8: 8d 4d d4 lea -0x2c(%ebp),%ecx
107aab: 89 f8 mov %edi,%eax
107aad: e8 33 ff ff ff call 1079e5 <scanString>
107ab2: 83 c4 10 add $0x10,%esp
107ab5: 85 c0 test %eax,%eax
107ab7: 0f 84 a2 00 00 00 je 107b5f <scangr+0xef> <== NEVER TAKEN
|| !scanInt(fp, &grgid)
107abd: 8d 55 e4 lea -0x1c(%ebp),%edx
107ac0: 89 f8 mov %edi,%eax
107ac2: e8 69 fe ff ff call 107930 <scanInt>
107ac7: 85 c0 test %eax,%eax
107ac9: 0f 84 90 00 00 00 je 107b5f <scangr+0xef> <== NEVER TAKEN
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
107acf: 51 push %ecx
107ad0: 51 push %ecx
107ad1: 8d 55 e0 lea -0x20(%ebp),%edx
107ad4: 6a 01 push $0x1
107ad6: 8d 45 08 lea 0x8(%ebp),%eax
107ad9: 50 push %eax
107ada: 8d 4d d4 lea -0x2c(%ebp),%ecx
107add: 89 f8 mov %edi,%eax
107adf: e8 01 ff ff ff call 1079e5 <scanString>
107ae4: 83 c4 10 add $0x10,%esp
107ae7: 85 c0 test %eax,%eax
107ae9: 74 74 je 107b5f <scangr+0xef> <== NEVER TAKEN
return 0;
grp->gr_gid = grgid;
107aeb: 8b 45 e4 mov -0x1c(%ebp),%eax
107aee: 66 89 43 08 mov %ax,0x8(%ebx)
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107af2: 8b 4d e0 mov -0x20(%ebp),%ecx
107af5: 89 ca mov %ecx,%edx
107af7: b8 01 00 00 00 mov $0x1,%eax
107afc: 89 c6 mov %eax,%esi
107afe: eb 0b jmp 107b0b <scangr+0x9b>
if(*cp == ',')
memcount++;
107b00: 3c 2c cmp $0x2c,%al
107b02: 0f 94 c0 sete %al
107b05: 0f b6 c0 movzbl %al,%eax
107b08: 01 c6 add %eax,%esi
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107b0a: 42 inc %edx
107b0b: 8a 02 mov (%edx),%al
107b0d: 84 c0 test %al,%al
107b0f: 75 ef jne 107b00 <scangr+0x90>
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
107b11: 8d 04 b5 13 00 00 00 lea 0x13(,%esi,4),%eax
return 0;
107b18: 31 f6 xor %esi,%esi
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
107b1a: 39 45 08 cmp %eax,0x8(%ebp)
107b1d: 72 40 jb 107b5f <scangr+0xef> <== NEVER TAKEN
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
107b1f: 8b 45 d4 mov -0x2c(%ebp),%eax
107b22: 83 c0 0f add $0xf,%eax
107b25: 83 e0 f0 and $0xfffffff0,%eax
107b28: 89 43 0c mov %eax,0xc(%ebx)
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
107b2b: 89 08 mov %ecx,(%eax)
}
/*
* Extract a single group record from the database
*/
static int scangr(
107b2d: 8b 45 e0 mov -0x20(%ebp),%eax
107b30: 40 inc %eax
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107b31: ba 01 00 00 00 mov $0x1,%edx
107b36: eb 11 jmp 107b49 <scangr+0xd9>
if(*cp == ',') {
107b38: 80 f9 2c cmp $0x2c,%cl
107b3b: 75 0b jne 107b48 <scangr+0xd8>
*cp = '\0';
107b3d: c6 40 ff 00 movb $0x0,-0x1(%eax)
grp->gr_mem[memcount++] = cp + 1;
107b41: 8b 4b 0c mov 0xc(%ebx),%ecx
107b44: 89 04 91 mov %eax,(%ecx,%edx,4)
107b47: 42 inc %edx
107b48: 40 inc %eax
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107b49: 8a 48 ff mov -0x1(%eax),%cl
107b4c: 84 c9 test %cl,%cl
107b4e: 75 e8 jne 107b38 <scangr+0xc8>
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
107b50: 8b 43 0c mov 0xc(%ebx),%eax
107b53: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4)
return 1;
107b5a: be 01 00 00 00 mov $0x1,%esi
}
107b5f: 89 f0 mov %esi,%eax
107b61: 8d 65 f4 lea -0xc(%ebp),%esp
107b64: 5b pop %ebx
107b65: 5e pop %esi
107b66: 5f pop %edi
107b67: c9 leave
107b68: c3 ret
00107b69 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
107b69: 55 push %ebp
107b6a: 89 e5 mov %esp,%ebp
107b6c: 57 push %edi
107b6d: 56 push %esi
107b6e: 53 push %ebx
107b6f: 83 ec 34 sub $0x34,%esp
107b72: 89 c6 mov %eax,%esi
107b74: 89 d3 mov %edx,%ebx
107b76: 89 4d d4 mov %ecx,-0x2c(%ebp)
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
107b79: 8d 7d d4 lea -0x2c(%ebp),%edi
107b7c: 6a 00 push $0x0
107b7e: 8d 45 08 lea 0x8(%ebp),%eax
107b81: 50 push %eax
107b82: 89 f9 mov %edi,%ecx
107b84: 89 f0 mov %esi,%eax
107b86: e8 5a fe ff ff call 1079e5 <scanString>
107b8b: 83 c4 10 add $0x10,%esp
|| !scanInt(fp, &pwgid)
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
107b8e: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
107b95: 85 c0 test %eax,%eax
107b97: 0f 84 c4 00 00 00 je 107c61 <scanpw+0xf8>
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
107b9d: 51 push %ecx
107b9e: 51 push %ecx
107b9f: 8d 53 04 lea 0x4(%ebx),%edx
107ba2: 6a 00 push $0x0
107ba4: 8d 45 08 lea 0x8(%ebp),%eax
107ba7: 50 push %eax
107ba8: 89 f9 mov %edi,%ecx
107baa: 89 f0 mov %esi,%eax
107bac: e8 34 fe ff ff call 1079e5 <scanString>
107bb1: 83 c4 10 add $0x10,%esp
107bb4: 85 c0 test %eax,%eax
107bb6: 0f 84 a5 00 00 00 je 107c61 <scanpw+0xf8> <== NEVER TAKEN
|| !scanInt(fp, &pwuid)
107bbc: 8d 55 e4 lea -0x1c(%ebp),%edx
107bbf: 89 f0 mov %esi,%eax
107bc1: e8 6a fd ff ff call 107930 <scanInt>
107bc6: 85 c0 test %eax,%eax
107bc8: 0f 84 93 00 00 00 je 107c61 <scanpw+0xf8>
|| !scanInt(fp, &pwgid)
107bce: 8d 55 e0 lea -0x20(%ebp),%edx
107bd1: 89 f0 mov %esi,%eax
107bd3: e8 58 fd ff ff call 107930 <scanInt>
107bd8: 85 c0 test %eax,%eax
107bda: 0f 84 81 00 00 00 je 107c61 <scanpw+0xf8>
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
107be0: 52 push %edx
107be1: 52 push %edx
107be2: 8d 53 0c lea 0xc(%ebx),%edx
107be5: 6a 00 push $0x0
107be7: 8d 45 08 lea 0x8(%ebp),%eax
107bea: 50 push %eax
107beb: 89 f9 mov %edi,%ecx
107bed: 89 f0 mov %esi,%eax
107bef: e8 f1 fd ff ff call 1079e5 <scanString>
107bf4: 83 c4 10 add $0x10,%esp
107bf7: 85 c0 test %eax,%eax
107bf9: 74 66 je 107c61 <scanpw+0xf8> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
107bfb: 50 push %eax
107bfc: 50 push %eax
107bfd: 8d 53 10 lea 0x10(%ebx),%edx
107c00: 6a 00 push $0x0
107c02: 8d 45 08 lea 0x8(%ebp),%eax
107c05: 50 push %eax
107c06: 89 f9 mov %edi,%ecx
107c08: 89 f0 mov %esi,%eax
107c0a: e8 d6 fd ff ff call 1079e5 <scanString>
107c0f: 83 c4 10 add $0x10,%esp
107c12: 85 c0 test %eax,%eax
107c14: 74 4b je 107c61 <scanpw+0xf8> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
107c16: 51 push %ecx
107c17: 51 push %ecx
107c18: 8d 53 14 lea 0x14(%ebx),%edx
107c1b: 6a 00 push $0x0
107c1d: 8d 45 08 lea 0x8(%ebp),%eax
107c20: 50 push %eax
107c21: 89 f9 mov %edi,%ecx
107c23: 89 f0 mov %esi,%eax
107c25: e8 bb fd ff ff call 1079e5 <scanString>
107c2a: 83 c4 10 add $0x10,%esp
107c2d: 85 c0 test %eax,%eax
107c2f: 74 30 je 107c61 <scanpw+0xf8> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
107c31: 52 push %edx
107c32: 52 push %edx
107c33: 8d 53 18 lea 0x18(%ebx),%edx
107c36: 6a 01 push $0x1
107c38: 8d 45 08 lea 0x8(%ebp),%eax
107c3b: 50 push %eax
107c3c: 89 f9 mov %edi,%ecx
107c3e: 89 f0 mov %esi,%eax
107c40: e8 a0 fd ff ff call 1079e5 <scanString>
107c45: 83 c4 10 add $0x10,%esp
107c48: 85 c0 test %eax,%eax
107c4a: 74 15 je 107c61 <scanpw+0xf8>
return 0;
pwd->pw_uid = pwuid;
107c4c: 8b 45 e4 mov -0x1c(%ebp),%eax
107c4f: 66 89 43 08 mov %ax,0x8(%ebx)
pwd->pw_gid = pwgid;
107c53: 8b 45 e0 mov -0x20(%ebp),%eax
107c56: 66 89 43 0a mov %ax,0xa(%ebx)
return 1;
107c5a: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp)
}
107c61: 8b 45 d0 mov -0x30(%ebp),%eax
107c64: 8d 65 f4 lea -0xc(%ebp),%esp
107c67: 5b pop %ebx
107c68: 5e pop %esi
107c69: 5f pop %edi
107c6a: c9 leave
107c6b: c3 ret
0010a8f0 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
10a8f0: 55 push %ebp
10a8f1: 89 e5 mov %esp,%ebp
10a8f3: 83 ec 08 sub $0x8,%esp
10a8f6: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a8f9: 83 f9 04 cmp $0x4,%ecx
10a8fc: 77 0b ja 10a909 <sched_get_priority_max+0x19>
10a8fe: b8 01 00 00 00 mov $0x1,%eax
10a903: d3 e0 shl %cl,%eax
10a905: a8 17 test $0x17,%al
10a907: 75 10 jne 10a919 <sched_get_priority_max+0x29><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a909: e8 ae 73 00 00 call 111cbc <__errno>
10a90e: c7 00 16 00 00 00 movl $0x16,(%eax)
10a914: 83 c8 ff or $0xffffffff,%eax
10a917: eb 08 jmp 10a921 <sched_get_priority_max+0x31>
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
10a919: 0f b6 05 18 12 12 00 movzbl 0x121218,%eax
10a920: 48 dec %eax
}
10a921: c9 leave
10a922: c3 ret
0010a924 <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
10a924: 55 push %ebp
10a925: 89 e5 mov %esp,%ebp
10a927: 83 ec 08 sub $0x8,%esp
10a92a: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a92d: 83 f9 04 cmp $0x4,%ecx
10a930: 77 11 ja 10a943 <sched_get_priority_min+0x1f>
10a932: ba 01 00 00 00 mov $0x1,%edx
10a937: d3 e2 shl %cl,%edx
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
10a939: b8 01 00 00 00 mov $0x1,%eax
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
10a93e: 80 e2 17 and $0x17,%dl
10a941: 75 0e jne 10a951 <sched_get_priority_min+0x2d><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a943: e8 74 73 00 00 call 111cbc <__errno>
10a948: c7 00 16 00 00 00 movl $0x16,(%eax)
10a94e: 83 c8 ff or $0xffffffff,%eax
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
10a951: c9 leave
10a952: c3 ret
0010a954 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
10a954: 55 push %ebp
10a955: 89 e5 mov %esp,%ebp
10a957: 56 push %esi
10a958: 53 push %ebx
10a959: 8b 75 08 mov 0x8(%ebp),%esi
10a95c: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
10a95f: 85 f6 test %esi,%esi
10a961: 74 16 je 10a979 <sched_rr_get_interval+0x25><== NEVER TAKEN
10a963: e8 b8 d0 ff ff call 107a20 <getpid>
10a968: 39 c6 cmp %eax,%esi
10a96a: 74 0d je 10a979 <sched_rr_get_interval+0x25>
rtems_set_errno_and_return_minus_one( ESRCH );
10a96c: e8 4b 73 00 00 call 111cbc <__errno>
10a971: c7 00 03 00 00 00 movl $0x3,(%eax)
10a977: eb 0f jmp 10a988 <sched_rr_get_interval+0x34>
if ( !interval )
10a979: 85 db test %ebx,%ebx
10a97b: 75 10 jne 10a98d <sched_rr_get_interval+0x39>
rtems_set_errno_and_return_minus_one( EINVAL );
10a97d: e8 3a 73 00 00 call 111cbc <__errno>
10a982: c7 00 16 00 00 00 movl $0x16,(%eax)
10a988: 83 c8 ff or $0xffffffff,%eax
10a98b: eb 13 jmp 10a9a0 <sched_rr_get_interval+0x4c>
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
10a98d: 50 push %eax
10a98e: 50 push %eax
10a98f: 53 push %ebx
10a990: ff 35 a4 52 12 00 pushl 0x1252a4
10a996: e8 a1 2f 00 00 call 10d93c <_Timespec_From_ticks>
return 0;
10a99b: 83 c4 10 add $0x10,%esp
10a99e: 31 c0 xor %eax,%eax
}
10a9a0: 8d 65 f8 lea -0x8(%ebp),%esp
10a9a3: 5b pop %ebx
10a9a4: 5e pop %esi
10a9a5: c9 leave
10a9a6: c3 ret
0010d040 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
10d040: 55 push %ebp
10d041: 89 e5 mov %esp,%ebp
10d043: 57 push %edi
10d044: 56 push %esi
10d045: 53 push %ebx
10d046: 83 ec 2c sub $0x2c,%esp
10d049: 8b 75 08 mov 0x8(%ebp),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10d04c: a1 cc a4 12 00 mov 0x12a4cc,%eax
10d051: 40 inc %eax
10d052: a3 cc a4 12 00 mov %eax,0x12a4cc
va_list arg;
mode_t mode;
unsigned int value = 0;
10d057: 31 ff xor %edi,%edi
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
10d059: 8b 45 0c mov 0xc(%ebp),%eax
10d05c: 25 00 02 00 00 and $0x200,%eax
10d061: 89 45 d4 mov %eax,-0x2c(%ebp)
10d064: 74 03 je 10d069 <sem_open+0x29>
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
10d066: 8b 7d 14 mov 0x14(%ebp),%edi
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
10d069: 52 push %edx
10d06a: 52 push %edx
10d06b: 8d 45 e4 lea -0x1c(%ebp),%eax
10d06e: 50 push %eax
10d06f: 56 push %esi
10d070: e8 9b 58 00 00 call 112910 <_POSIX_Semaphore_Name_to_id>
10d075: 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 ) {
10d077: 83 c4 10 add $0x10,%esp
10d07a: 85 c0 test %eax,%eax
10d07c: 74 19 je 10d097 <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) ) ) {
10d07e: 83 f8 02 cmp $0x2,%eax
10d081: 75 06 jne 10d089 <sem_open+0x49> <== NEVER TAKEN
10d083: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10d087: 75 59 jne 10d0e2 <sem_open+0xa2>
_Thread_Enable_dispatch();
10d089: e8 68 25 00 00 call 10f5f6 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
10d08e: e8 45 7f 00 00 call 114fd8 <__errno>
10d093: 89 18 mov %ebx,(%eax)
10d095: eb 1f jmp 10d0b6 <sem_open+0x76>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
10d097: 8b 45 0c mov 0xc(%ebp),%eax
10d09a: 25 00 0a 00 00 and $0xa00,%eax
10d09f: 3d 00 0a 00 00 cmp $0xa00,%eax
10d0a4: 75 15 jne 10d0bb <sem_open+0x7b>
_Thread_Enable_dispatch();
10d0a6: e8 4b 25 00 00 call 10f5f6 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
10d0ab: e8 28 7f 00 00 call 114fd8 <__errno>
10d0b0: c7 00 11 00 00 00 movl $0x11,(%eax)
10d0b6: 83 c8 ff or $0xffffffff,%eax
10d0b9: eb 4a jmp 10d105 <sem_open+0xc5>
10d0bb: 50 push %eax
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
10d0bc: 8d 45 dc lea -0x24(%ebp),%eax
10d0bf: 50 push %eax
10d0c0: ff 75 e4 pushl -0x1c(%ebp)
10d0c3: 68 98 a7 12 00 push $0x12a798
10d0c8: e8 d7 1c 00 00 call 10eda4 <_Objects_Get>
10d0cd: 89 45 e0 mov %eax,-0x20(%ebp)
the_semaphore->open_count += 1;
10d0d0: ff 40 18 incl 0x18(%eax)
_Thread_Enable_dispatch();
10d0d3: e8 1e 25 00 00 call 10f5f6 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10d0d8: e8 19 25 00 00 call 10f5f6 <_Thread_Enable_dispatch>
goto return_id;
10d0dd: 83 c4 10 add $0x10,%esp
10d0e0: eb 1d jmp 10d0ff <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(
10d0e2: 8d 45 e0 lea -0x20(%ebp),%eax
10d0e5: 50 push %eax
10d0e6: 57 push %edi
10d0e7: 6a 00 push $0x0
10d0e9: 56 push %esi
10d0ea: e8 ed 56 00 00 call 1127dc <_POSIX_Semaphore_Create_support>
10d0ef: 89 c3 mov %eax,%ebx
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
10d0f1: e8 00 25 00 00 call 10f5f6 <_Thread_Enable_dispatch>
if ( status == -1 )
10d0f6: 83 c4 10 add $0x10,%esp
return SEM_FAILED;
10d0f9: 83 c8 ff or $0xffffffff,%eax
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
if ( status == -1 )
10d0fc: 43 inc %ebx
10d0fd: 74 06 je 10d105 <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;
10d0ff: 8b 45 e0 mov -0x20(%ebp),%eax
10d102: 83 c0 08 add $0x8,%eax
#endif
return id;
}
10d105: 8d 65 f4 lea -0xc(%ebp),%esp
10d108: 5b pop %ebx
10d109: 5e pop %esi
10d10a: 5f pop %edi
10d10b: c9 leave
10d10c: c3 ret
0010a7cc <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
10a7cc: 55 push %ebp
10a7cd: 89 e5 mov %esp,%ebp
10a7cf: 57 push %edi
10a7d0: 56 push %esi
10a7d1: 53 push %ebx
10a7d2: 83 ec 1c sub $0x1c,%esp
10a7d5: 8b 5d 08 mov 0x8(%ebp),%ebx
10a7d8: 8b 55 0c mov 0xc(%ebp),%edx
10a7db: 8b 45 10 mov 0x10(%ebp),%eax
ISR_Level level;
if ( oact )
10a7de: 85 c0 test %eax,%eax
10a7e0: 74 12 je 10a7f4 <sigaction+0x28>
*oact = _POSIX_signals_Vectors[ sig ];
10a7e2: 6b f3 0c imul $0xc,%ebx,%esi
10a7e5: 81 c6 84 68 12 00 add $0x126884,%esi
10a7eb: b9 03 00 00 00 mov $0x3,%ecx
10a7f0: 89 c7 mov %eax,%edi
10a7f2: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !sig )
10a7f4: 85 db test %ebx,%ebx
10a7f6: 74 0d je 10a805 <sigaction+0x39>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a7f8: 8d 43 ff lea -0x1(%ebx),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
10a7fb: 83 f8 1f cmp $0x1f,%eax
10a7fe: 77 05 ja 10a805 <sigaction+0x39>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
10a800: 83 fb 09 cmp $0x9,%ebx
10a803: 75 10 jne 10a815 <sigaction+0x49>
rtems_set_errno_and_return_minus_one( EINVAL );
10a805: e8 36 77 00 00 call 111f40 <__errno>
10a80a: c7 00 16 00 00 00 movl $0x16,(%eax)
10a810: 83 c8 ff or $0xffffffff,%eax
10a813: eb 57 jmp 10a86c <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;
10a815: 31 c0 xor %eax,%eax
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
10a817: 85 d2 test %edx,%edx
10a819: 74 51 je 10a86c <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 );
10a81b: 9c pushf
10a81c: fa cli
10a81d: 8f 45 e4 popl -0x1c(%ebp)
if ( act->sa_handler == SIG_DFL ) {
10a820: 83 7a 08 00 cmpl $0x0,0x8(%edx)
10a824: 75 1a jne 10a840 <sigaction+0x74>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
10a826: 6b f3 0c imul $0xc,%ebx,%esi
10a829: 8d 86 84 68 12 00 lea 0x126884(%esi),%eax
10a82f: 81 c6 f4 08 12 00 add $0x1208f4,%esi
10a835: b9 03 00 00 00 mov $0x3,%ecx
10a83a: 89 c7 mov %eax,%edi
10a83c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a83e: eb 26 jmp 10a866 <sigaction+0x9a>
} else {
_POSIX_signals_Clear_process_signals( sig );
10a840: 83 ec 0c sub $0xc,%esp
10a843: 53 push %ebx
10a844: 89 55 e0 mov %edx,-0x20(%ebp)
10a847: e8 8c 4d 00 00 call 10f5d8 <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
10a84c: 6b db 0c imul $0xc,%ebx,%ebx
10a84f: 81 c3 84 68 12 00 add $0x126884,%ebx
10a855: b9 03 00 00 00 mov $0x3,%ecx
10a85a: 8b 55 e0 mov -0x20(%ebp),%edx
10a85d: 89 df mov %ebx,%edi
10a85f: 89 d6 mov %edx,%esi
10a861: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a863: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10a866: ff 75 e4 pushl -0x1c(%ebp)
10a869: 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;
10a86a: 31 c0 xor %eax,%eax
}
10a86c: 8d 65 f4 lea -0xc(%ebp),%esp
10a86f: 5b pop %ebx
10a870: 5e pop %esi
10a871: 5f pop %edi
10a872: c9 leave
10a873: c3 ret
0010aba3 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
10aba3: 55 push %ebp
10aba4: 89 e5 mov %esp,%ebp
10aba6: 57 push %edi
10aba7: 56 push %esi
10aba8: 53 push %ebx
10aba9: 83 ec 3c sub $0x3c,%esp
10abac: 8b 75 08 mov 0x8(%ebp),%esi
10abaf: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
10abb2: 85 f6 test %esi,%esi
10abb4: 74 24 je 10abda <sigtimedwait+0x37>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
10abb6: 85 db test %ebx,%ebx
10abb8: 74 30 je 10abea <sigtimedwait+0x47>
if ( !_Timespec_Is_valid( timeout ) )
10abba: 83 ec 0c sub $0xc,%esp
10abbd: 53 push %ebx
10abbe: e8 45 30 00 00 call 10dc08 <_Timespec_Is_valid>
10abc3: 83 c4 10 add $0x10,%esp
10abc6: 84 c0 test %al,%al
10abc8: 74 10 je 10abda <sigtimedwait+0x37>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
10abca: 83 ec 0c sub $0xc,%esp
10abcd: 53 push %ebx
10abce: e8 8d 30 00 00 call 10dc60 <_Timespec_To_ticks>
if ( !interval )
10abd3: 83 c4 10 add $0x10,%esp
10abd6: 85 c0 test %eax,%eax
10abd8: 75 12 jne 10abec <sigtimedwait+0x49> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10abda: e8 19 79 00 00 call 1124f8 <__errno>
10abdf: c7 00 16 00 00 00 movl $0x16,(%eax)
10abe5: e9 39 01 00 00 jmp 10ad23 <sigtimedwait+0x180>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
10abea: 31 c0 xor %eax,%eax
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
10abec: 8b 7d 0c mov 0xc(%ebp),%edi
10abef: 85 ff test %edi,%edi
10abf1: 75 03 jne 10abf6 <sigtimedwait+0x53>
10abf3: 8d 7d dc lea -0x24(%ebp),%edi
the_thread = _Thread_Executing;
10abf6: 8b 15 74 68 12 00 mov 0x126874,%edx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10abfc: 8b 8a f8 00 00 00 mov 0xf8(%edx),%ecx
10ac02: 89 4d d4 mov %ecx,-0x2c(%ebp)
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
10ac05: 9c pushf
10ac06: fa cli
10ac07: 8f 45 d0 popl -0x30(%ebp)
if ( *set & api->signals_pending ) {
10ac0a: 8b 1e mov (%esi),%ebx
10ac0c: 89 5d c4 mov %ebx,-0x3c(%ebp)
10ac0f: 8b 5d d4 mov -0x2c(%ebp),%ebx
10ac12: 8b 8b d4 00 00 00 mov 0xd4(%ebx),%ecx
10ac18: 85 4d c4 test %ecx,-0x3c(%ebp)
10ac1b: 74 32 je 10ac4f <sigtimedwait+0xac>
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
10ac1d: 83 ec 0c sub $0xc,%esp
10ac20: 51 push %ecx
10ac21: e8 3e ff ff ff call 10ab64 <_POSIX_signals_Get_lowest>
10ac26: 89 07 mov %eax,(%edi)
_POSIX_signals_Clear_signals(
10ac28: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ac2f: 6a 00 push $0x0
10ac31: 57 push %edi
10ac32: 50 push %eax
10ac33: 53 push %ebx
10ac34: e8 fb 4f 00 00 call 10fc34 <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
10ac39: ff 75 d0 pushl -0x30(%ebp)
10ac3c: 9d popf
the_info->si_code = SI_USER;
10ac3d: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10ac44: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return the_info->si_signo;
10ac4b: 8b 1f mov (%edi),%ebx
10ac4d: eb 3d jmp 10ac8c <sigtimedwait+0xe9>
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
10ac4f: 8b 0d 78 6a 12 00 mov 0x126a78,%ecx
10ac55: 85 4d c4 test %ecx,-0x3c(%ebp)
10ac58: 74 3a je 10ac94 <sigtimedwait+0xf1>
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
10ac5a: 83 ec 0c sub $0xc,%esp
10ac5d: 51 push %ecx
10ac5e: e8 01 ff ff ff call 10ab64 <_POSIX_signals_Get_lowest>
10ac63: 89 c3 mov %eax,%ebx
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
10ac65: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ac6c: 6a 01 push $0x1
10ac6e: 57 push %edi
10ac6f: 50 push %eax
10ac70: ff 75 d4 pushl -0x2c(%ebp)
10ac73: e8 bc 4f 00 00 call 10fc34 <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
10ac78: ff 75 d0 pushl -0x30(%ebp)
10ac7b: 9d popf
the_info->si_signo = signo;
10ac7c: 89 1f mov %ebx,(%edi)
the_info->si_code = SI_USER;
10ac7e: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10ac85: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return signo;
10ac8c: 83 c4 20 add $0x20,%esp
10ac8f: e9 92 00 00 00 jmp 10ad26 <sigtimedwait+0x183>
}
the_info->si_signo = -1;
10ac94: c7 07 ff ff ff ff movl $0xffffffff,(%edi)
10ac9a: 8b 0d 24 63 12 00 mov 0x126324,%ecx
10aca0: 41 inc %ecx
10aca1: 89 0d 24 63 12 00 mov %ecx,0x126324
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
10aca7: c7 42 44 10 6a 12 00 movl $0x126a10,0x44(%edx)
the_thread->Wait.return_code = EINTR;
10acae: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx)
the_thread->Wait.option = *set;
10acb5: 8b 0e mov (%esi),%ecx
10acb7: 89 4a 30 mov %ecx,0x30(%edx)
the_thread->Wait.return_argument = the_info;
10acba: 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;
10acbd: c7 05 40 6a 12 00 01 movl $0x1,0x126a40
10acc4: 00 00 00
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
10acc7: ff 75 d0 pushl -0x30(%ebp)
10acca: 9d popf
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
10accb: 52 push %edx
10accc: 68 00 d8 10 00 push $0x10d800
10acd1: 50 push %eax
10acd2: 68 10 6a 12 00 push $0x126a10
10acd7: e8 4c 28 00 00 call 10d528 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10acdc: e8 c1 23 00 00 call 10d0a2 <_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 );
10ace1: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ace8: 6a 00 push $0x0
10acea: 57 push %edi
10aceb: ff 37 pushl (%edi)
10aced: ff 75 d4 pushl -0x2c(%ebp)
10acf0: e8 3f 4f 00 00 call 10fc34 <_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)
10acf5: 83 c4 20 add $0x20,%esp
10acf8: a1 74 68 12 00 mov 0x126874,%eax
10acfd: 83 78 34 04 cmpl $0x4,0x34(%eax)
10ad01: 75 10 jne 10ad13 <sigtimedwait+0x170>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
10ad03: 8b 1f mov (%edi),%ebx
10ad05: 8d 4b ff lea -0x1(%ebx),%ecx
10ad08: b8 01 00 00 00 mov $0x1,%eax
10ad0d: d3 e0 shl %cl,%eax
10ad0f: 85 06 test %eax,(%esi)
10ad11: 75 13 jne 10ad26 <sigtimedwait+0x183>
errno = _Thread_Executing->Wait.return_code;
10ad13: e8 e0 77 00 00 call 1124f8 <__errno>
10ad18: 8b 15 74 68 12 00 mov 0x126874,%edx
10ad1e: 8b 52 34 mov 0x34(%edx),%edx
10ad21: 89 10 mov %edx,(%eax)
return -1;
10ad23: 83 cb ff or $0xffffffff,%ebx
}
return the_info->si_signo;
}
10ad26: 89 d8 mov %ebx,%eax
10ad28: 8d 65 f4 lea -0xc(%ebp),%esp
10ad2b: 5b pop %ebx
10ad2c: 5e pop %esi
10ad2d: 5f pop %edi
10ad2e: c9 leave
10ad2f: c3 ret
0010ca14 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
10ca14: 55 push %ebp
10ca15: 89 e5 mov %esp,%ebp
10ca17: 53 push %ebx
10ca18: 83 ec 08 sub $0x8,%esp
10ca1b: 8b 5d 0c mov 0xc(%ebp),%ebx
int status;
status = sigtimedwait( set, NULL, NULL );
10ca1e: 6a 00 push $0x0
10ca20: 6a 00 push $0x0
10ca22: ff 75 08 pushl 0x8(%ebp)
10ca25: e8 45 fe ff ff call 10c86f <sigtimedwait>
10ca2a: 89 c2 mov %eax,%edx
if ( status != -1 ) {
10ca2c: 83 c4 10 add $0x10,%esp
10ca2f: 83 f8 ff cmp $0xffffffff,%eax
10ca32: 74 0a je 10ca3e <sigwait+0x2a>
if ( sig )
*sig = status;
return 0;
10ca34: 31 c0 xor %eax,%eax
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
10ca36: 85 db test %ebx,%ebx
10ca38: 74 0b je 10ca45 <sigwait+0x31> <== NEVER TAKEN
*sig = status;
10ca3a: 89 13 mov %edx,(%ebx)
10ca3c: eb 07 jmp 10ca45 <sigwait+0x31>
return 0;
}
return errno;
10ca3e: e8 cd 72 00 00 call 113d10 <__errno>
10ca43: 8b 00 mov (%eax),%eax
}
10ca45: 8b 5d fc mov -0x4(%ebp),%ebx
10ca48: c9 leave
10ca49: c3 ret
00108f2c <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
108f2c: 55 push %ebp
108f2d: 89 e5 mov %esp,%ebp
108f2f: 56 push %esi
108f30: 53 push %ebx
108f31: 89 d3 mov %edx,%ebx
108f33: 89 c6 mov %eax,%esi
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
108f35: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx)
108f3c: 74 30 je 108f6e <siproc+0x42> <== NEVER TAKEN
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108f3e: 52 push %edx
108f3f: 6a 00 push $0x0
108f41: 6a 00 push $0x0
108f43: ff 73 18 pushl 0x18(%ebx)
108f46: e8 19 12 00 00 call 10a164 <rtems_semaphore_obtain>
i = iproc (c, tty);
108f4b: 89 f2 mov %esi,%edx
108f4d: 0f b6 c2 movzbl %dl,%eax
108f50: 89 da mov %ebx,%edx
108f52: e8 b5 fe ff ff call 108e0c <iproc>
108f57: 89 c6 mov %eax,%esi
rtems_semaphore_release (tty->osem);
108f59: 58 pop %eax
108f5a: ff 73 18 pushl 0x18(%ebx)
108f5d: e8 ee 12 00 00 call 10a250 <rtems_semaphore_release>
108f62: 83 c4 10 add $0x10,%esp
}
else {
i = iproc (c, tty);
}
return i;
}
108f65: 89 f0 mov %esi,%eax
108f67: 8d 65 f8 lea -0x8(%ebp),%esp
108f6a: 5b pop %ebx
108f6b: 5e pop %esi
108f6c: c9 leave
108f6d: c3 ret
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
108f6e: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
108f71: 89 da mov %ebx,%edx <== NOT EXECUTED
}
return i;
}
108f73: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
108f76: 5b pop %ebx <== NOT EXECUTED
108f77: 5e pop %esi <== NOT EXECUTED
108f78: c9 leave <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
108f79: e9 8e fe ff ff jmp 108e0c <iproc> <== NOT EXECUTED
0010a100 <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
10a100: 55 push %ebp
10a101: 89 e5 mov %esp,%ebp
10a103: 57 push %edi
10a104: 56 push %esi
10a105: 53 push %ebx
10a106: 83 ec 38 sub $0x38,%esp
10a109: 8b 55 08 mov 0x8(%ebp),%edx
10a10c: 8b 75 0c mov 0xc(%ebp),%esi
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
10a10f: 31 c0 xor %eax,%eax
10a111: 83 c9 ff or $0xffffffff,%ecx
10a114: 89 d7 mov %edx,%edi
10a116: f2 ae repnz scas %es:(%edi),%al
10a118: f7 d1 not %ecx
10a11a: 49 dec %ecx
10a11b: 6a 01 push $0x1
10a11d: 8d 5d d4 lea -0x2c(%ebp),%ebx
10a120: 53 push %ebx
10a121: 6a 00 push $0x0
10a123: 51 push %ecx
10a124: 52 push %edx
10a125: e8 28 ee ff ff call 108f52 <rtems_filesystem_evaluate_path>
10a12a: 83 c4 20 add $0x20,%esp
return -1;
10a12d: 83 cf ff or $0xffffffff,%edi
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
10a130: 85 c0 test %eax,%eax
10a132: 75 26 jne 10a15a <statvfs+0x5a> <== NEVER TAKEN
return -1;
mt_entry = loc.mt_entry;
10a134: 8b 55 e4 mov -0x1c(%ebp),%edx
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
10a137: b9 0e 00 00 00 mov $0xe,%ecx
10a13c: 89 f7 mov %esi,%edi
10a13e: f3 ab rep stos %eax,%es:(%edi)
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
10a140: 50 push %eax
10a141: 50 push %eax
10a142: 8b 42 28 mov 0x28(%edx),%eax
10a145: 56 push %esi
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
mt_entry = loc.mt_entry;
fs_mount_root = &mt_entry->mt_fs_root;
10a146: 83 c2 1c add $0x1c,%edx
memset (sb, 0, sizeof (struct statvfs));
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
10a149: 52 push %edx
10a14a: ff 50 44 call *0x44(%eax)
10a14d: 89 c7 mov %eax,%edi
rtems_filesystem_freenode( &loc );
10a14f: 89 1c 24 mov %ebx,(%esp)
10a152: e8 b9 ee ff ff call 109010 <rtems_filesystem_freenode>
return result;
10a157: 83 c4 10 add $0x10,%esp
}
10a15a: 89 f8 mov %edi,%eax
10a15c: 8d 65 f4 lea -0xc(%ebp),%esp
10a15f: 5b pop %ebx
10a160: 5e pop %esi
10a161: 5f pop %edi
10a162: c9 leave
10a163: c3 ret
00108f78 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
108f78: 55 push %ebp
108f79: 89 e5 mov %esp,%ebp
108f7b: 53 push %ebx
108f7c: 83 ec 04 sub $0x4,%esp
108f7f: 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;
108f82: 8b 88 f0 00 00 00 mov 0xf0(%eax),%ecx
if ( this_reent ) {
108f88: 85 c9 test %ecx,%ecx
108f8a: 74 32 je 108fbe <sync_per_thread+0x46> <== NEVER TAKEN
current_reent = _Thread_Executing->libc_reent;
108f8c: 8b 15 34 68 12 00 mov 0x126834,%edx
108f92: 8b 9a f0 00 00 00 mov 0xf0(%edx),%ebx
_Thread_Executing->libc_reent = this_reent;
108f98: 89 8a f0 00 00 00 mov %ecx,0xf0(%edx)
_fwalk (t->libc_reent, sync_wrapper);
108f9e: 52 push %edx
108f9f: 52 push %edx
108fa0: 68 c3 8f 10 00 push $0x108fc3
108fa5: ff b0 f0 00 00 00 pushl 0xf0(%eax)
108fab: e8 8c 9e 00 00 call 112e3c <_fwalk>
_Thread_Executing->libc_reent = current_reent;
108fb0: a1 34 68 12 00 mov 0x126834,%eax
108fb5: 89 98 f0 00 00 00 mov %ebx,0xf0(%eax)
108fbb: 83 c4 10 add $0x10,%esp
}
}
108fbe: 8b 5d fc mov -0x4(%ebp),%ebx
108fc1: c9 leave
108fc2: c3 ret
00109828 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
109828: 55 push %ebp
109829: 89 e5 mov %esp,%ebp
10982b: 56 push %esi
10982c: 53 push %ebx
10982d: 8b 5d 08 mov 0x8(%ebp),%ebx
109830: 8b 45 0c mov 0xc(%ebp),%eax
109833: 8b 75 10 mov 0x10(%ebp),%esi
switch (opt) {
109836: 85 c0 test %eax,%eax
109838: 74 22 je 10985c <tcsetattr+0x34>
10983a: 48 dec %eax
10983b: 74 0d je 10984a <tcsetattr+0x22>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
10983d: e8 2e 92 00 00 call 112a70 <__errno>
109842: c7 00 86 00 00 00 movl $0x86,(%eax)
109848: eb 2a jmp 109874 <tcsetattr+0x4c>
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
10984a: 50 push %eax
10984b: 6a 00 push $0x0
10984d: 6a 03 push $0x3
10984f: 53 push %ebx
109850: e8 4f 63 00 00 call 10fba4 <ioctl>
109855: 83 c4 10 add $0x10,%esp
109858: 85 c0 test %eax,%eax
10985a: 78 18 js 109874 <tcsetattr+0x4c> <== NEVER TAKEN
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
10985c: 89 75 10 mov %esi,0x10(%ebp)
10985f: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp)
109866: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
109869: 8d 65 f8 lea -0x8(%ebp),%esp
10986c: 5b pop %ebx
10986d: 5e pop %esi
10986e: c9 leave
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
10986f: e9 30 63 00 00 jmp 10fba4 <ioctl>
}
}
109874: 83 c8 ff or $0xffffffff,%eax
109877: 8d 65 f8 lea -0x8(%ebp),%esp
10987a: 5b pop %ebx
10987b: 5e pop %esi
10987c: c9 leave
10987d: c3 ret
0010a02c <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
10a02c: 55 push %ebp
10a02d: 89 e5 mov %esp,%ebp
10a02f: 56 push %esi
10a030: 53 push %ebx
10a031: 8b 5d 0c mov 0xc(%ebp),%ebx
10a034: 8b 75 10 mov 0x10(%ebp),%esi
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
10a037: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
10a03b: 75 1d jne 10a05a <timer_create+0x2e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
10a03d: 85 f6 test %esi,%esi
10a03f: 74 19 je 10a05a <timer_create+0x2e>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
10a041: 85 db test %ebx,%ebx
10a043: 74 22 je 10a067 <timer_create+0x3b>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
10a045: 8b 03 mov (%ebx),%eax
10a047: 48 dec %eax
10a048: 83 f8 01 cmp $0x1,%eax
10a04b: 77 0d ja 10a05a <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 )
10a04d: 8b 43 04 mov 0x4(%ebx),%eax
10a050: 85 c0 test %eax,%eax
10a052: 74 06 je 10a05a <timer_create+0x2e> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a054: 48 dec %eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
10a055: 83 f8 1f cmp $0x1f,%eax
10a058: 76 0d jbe 10a067 <timer_create+0x3b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10a05a: e8 7d 7c 00 00 call 111cdc <__errno>
10a05f: c7 00 16 00 00 00 movl $0x16,(%eax)
10a065: eb 2f jmp 10a096 <timer_create+0x6a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a067: a1 38 63 12 00 mov 0x126338,%eax
10a06c: 40 inc %eax
10a06d: a3 38 63 12 00 mov %eax,0x126338
* 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 );
10a072: 83 ec 0c sub $0xc,%esp
10a075: 68 44 66 12 00 push $0x126644
10a07a: e8 71 1b 00 00 call 10bbf0 <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
10a07f: 83 c4 10 add $0x10,%esp
10a082: 85 c0 test %eax,%eax
10a084: 75 18 jne 10a09e <timer_create+0x72>
_Thread_Enable_dispatch();
10a086: e8 73 27 00 00 call 10c7fe <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
10a08b: e8 4c 7c 00 00 call 111cdc <__errno>
10a090: c7 00 0b 00 00 00 movl $0xb,(%eax)
10a096: 83 c8 ff or $0xffffffff,%eax
10a099: e9 83 00 00 00 jmp 10a121 <timer_create+0xf5>
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
10a09e: c6 40 3c 02 movb $0x2,0x3c(%eax)
ptimer->thread_id = _Thread_Executing->Object.id;
10a0a2: 8b 15 88 68 12 00 mov 0x126888,%edx
10a0a8: 8b 52 08 mov 0x8(%edx),%edx
10a0ab: 89 50 38 mov %edx,0x38(%eax)
if ( evp != NULL ) {
10a0ae: 85 db test %ebx,%ebx
10a0b0: 74 11 je 10a0c3 <timer_create+0x97>
ptimer->inf.sigev_notify = evp->sigev_notify;
10a0b2: 8b 13 mov (%ebx),%edx
10a0b4: 89 50 40 mov %edx,0x40(%eax)
ptimer->inf.sigev_signo = evp->sigev_signo;
10a0b7: 8b 53 04 mov 0x4(%ebx),%edx
10a0ba: 89 50 44 mov %edx,0x44(%eax)
ptimer->inf.sigev_value = evp->sigev_value;
10a0bd: 8b 53 08 mov 0x8(%ebx),%edx
10a0c0: 89 50 48 mov %edx,0x48(%eax)
}
ptimer->overrun = 0;
10a0c3: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax)
ptimer->timer_data.it_value.tv_sec = 0;
10a0ca: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
ptimer->timer_data.it_value.tv_nsec = 0;
10a0d1: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
ptimer->timer_data.it_interval.tv_sec = 0;
10a0d8: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
ptimer->timer_data.it_interval.tv_nsec = 0;
10a0df: 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;
10a0e6: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10a0ed: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10a0f4: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10a0fb: 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 ),
10a102: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a105: 0f b7 da movzwl %dx,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a108: 8b 0d 60 66 12 00 mov 0x126660,%ecx
10a10e: 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;
10a111: 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;
10a118: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10a11a: e8 df 26 00 00 call 10c7fe <_Thread_Enable_dispatch>
return 0;
10a11f: 31 c0 xor %eax,%eax
}
10a121: 8d 65 f8 lea -0x8(%ebp),%esp
10a124: 5b pop %ebx
10a125: 5e pop %esi
10a126: c9 leave
10a127: c3 ret
0010a128 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
10a128: 55 push %ebp
10a129: 89 e5 mov %esp,%ebp
10a12b: 57 push %edi
10a12c: 56 push %esi
10a12d: 53 push %ebx
10a12e: 83 ec 2c sub $0x2c,%esp
10a131: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
10a134: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a138: 0f 84 58 01 00 00 je 10a296 <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) ) ) {
10a13e: 83 ec 0c sub $0xc,%esp
10a141: 8b 45 10 mov 0x10(%ebp),%eax
10a144: 83 c0 08 add $0x8,%eax
10a147: 50 push %eax
10a148: e8 3b 32 00 00 call 10d388 <_Timespec_Is_valid>
10a14d: 83 c4 10 add $0x10,%esp
10a150: 84 c0 test %al,%al
10a152: 0f 84 3e 01 00 00 je 10a296 <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
10a158: 83 ec 0c sub $0xc,%esp
10a15b: ff 75 10 pushl 0x10(%ebp)
10a15e: e8 25 32 00 00 call 10d388 <_Timespec_Is_valid>
10a163: 83 c4 10 add $0x10,%esp
10a166: 84 c0 test %al,%al
10a168: 0f 84 28 01 00 00 je 10a296 <timer_settime+0x16e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
10a16e: 85 db test %ebx,%ebx
10a170: 74 09 je 10a17b <timer_settime+0x53>
10a172: 83 fb 04 cmp $0x4,%ebx
10a175: 0f 85 1b 01 00 00 jne 10a296 <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
10a17b: 8d 7d cc lea -0x34(%ebp),%edi
10a17e: b9 04 00 00 00 mov $0x4,%ecx
10a183: 8b 75 10 mov 0x10(%ebp),%esi
10a186: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
10a188: 83 fb 04 cmp $0x4,%ebx
10a18b: 75 2f jne 10a1bc <timer_settime+0x94>
struct timespec now;
_TOD_Get( &now );
10a18d: 83 ec 0c sub $0xc,%esp
10a190: 8d 5d dc lea -0x24(%ebp),%ebx
10a193: 53 push %ebx
10a194: e8 a7 15 00 00 call 10b740 <_TOD_Get>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
10a199: 59 pop %ecx
10a19a: 5e pop %esi
10a19b: 8d 75 d4 lea -0x2c(%ebp),%esi
10a19e: 56 push %esi
10a19f: 53 push %ebx
10a1a0: e8 bf 31 00 00 call 10d364 <_Timespec_Greater_than>
10a1a5: 83 c4 10 add $0x10,%esp
10a1a8: 84 c0 test %al,%al
10a1aa: 0f 85 e6 00 00 00 jne 10a296 <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
10a1b0: 52 push %edx
10a1b1: 56 push %esi
10a1b2: 56 push %esi
10a1b3: 53 push %ebx
10a1b4: e8 f3 31 00 00 call 10d3ac <_Timespec_Subtract>
10a1b9: 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 );
10a1bc: 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 );
10a1bd: 8d 45 e4 lea -0x1c(%ebp),%eax
10a1c0: 50 push %eax
10a1c1: ff 75 08 pushl 0x8(%ebp)
10a1c4: 68 44 66 12 00 push $0x126644
10a1c9: e8 52 1e 00 00 call 10c020 <_Objects_Get>
10a1ce: 89 c3 mov %eax,%ebx
switch ( location ) {
10a1d0: 83 c4 10 add $0x10,%esp
10a1d3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10a1d7: 0f 85 b9 00 00 00 jne 10a296 <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 ) {
10a1dd: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10a1e1: 75 3b jne 10a21e <timer_settime+0xf6>
10a1e3: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10a1e7: 75 35 jne 10a21e <timer_settime+0xf6>
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
10a1e9: 83 ec 0c sub $0xc,%esp
10a1ec: 8d 40 10 lea 0x10(%eax),%eax
10a1ef: 50 push %eax
10a1f0: e8 7b 35 00 00 call 10d770 <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
10a1f5: 83 c4 10 add $0x10,%esp
10a1f8: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a1fc: 74 0d je 10a20b <timer_settime+0xe3>
*ovalue = ptimer->timer_data;
10a1fe: 8d 73 54 lea 0x54(%ebx),%esi
10a201: b9 04 00 00 00 mov $0x4,%ecx
10a206: 8b 7d 14 mov 0x14(%ebp),%edi
10a209: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* The new data are set */
ptimer->timer_data = normalize;
10a20b: 8d 7b 54 lea 0x54(%ebx),%edi
10a20e: 8d 75 cc lea -0x34(%ebp),%esi
10a211: b9 04 00 00 00 mov $0x4,%ecx
10a216: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a218: c6 43 3c 04 movb $0x4,0x3c(%ebx)
10a21c: eb 35 jmp 10a253 <timer_settime+0x12b>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
10a21e: 83 ec 0c sub $0xc,%esp
10a221: ff 75 10 pushl 0x10(%ebp)
10a224: e8 b7 31 00 00 call 10d3e0 <_Timespec_To_ticks>
10a229: 89 43 64 mov %eax,0x64(%ebx)
initial_period = _Timespec_To_ticks( &normalize.it_value );
10a22c: 8d 45 d4 lea -0x2c(%ebp),%eax
10a22f: 89 04 24 mov %eax,(%esp)
10a232: e8 a9 31 00 00 call 10d3e0 <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
10a237: 89 1c 24 mov %ebx,(%esp)
10a23a: 68 ac a2 10 00 push $0x10a2ac
10a23f: ff 73 08 pushl 0x8(%ebx)
10a242: 50 push %eax
10a243: 8d 43 10 lea 0x10(%ebx),%eax
10a246: 50 push %eax
10a247: e8 64 56 00 00 call 10f8b0 <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
10a24c: 83 c4 20 add $0x20,%esp
10a24f: 84 c0 test %al,%al
10a251: 75 07 jne 10a25a <timer_settime+0x132>
_Thread_Enable_dispatch();
10a253: e8 a6 25 00 00 call 10c7fe <_Thread_Enable_dispatch>
10a258: eb 38 jmp 10a292 <timer_settime+0x16a>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
10a25a: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a25e: 74 0d je 10a26d <timer_settime+0x145>
*ovalue = ptimer->timer_data;
10a260: 8d 73 54 lea 0x54(%ebx),%esi
10a263: b9 04 00 00 00 mov $0x4,%ecx
10a268: 8b 7d 14 mov 0x14(%ebp),%edi
10a26b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ptimer->timer_data = normalize;
10a26d: 8d 7b 54 lea 0x54(%ebx),%edi
10a270: 8d 75 cc lea -0x34(%ebp),%esi
10a273: b9 04 00 00 00 mov $0x4,%ecx
10a278: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a27a: c6 43 3c 03 movb $0x3,0x3c(%ebx)
_TOD_Get( &ptimer->time );
10a27e: 83 ec 0c sub $0xc,%esp
10a281: 83 c3 6c add $0x6c,%ebx
10a284: 53 push %ebx
10a285: e8 b6 14 00 00 call 10b740 <_TOD_Get>
_Thread_Enable_dispatch();
10a28a: e8 6f 25 00 00 call 10c7fe <_Thread_Enable_dispatch>
return 0;
10a28f: 83 c4 10 add $0x10,%esp
10a292: 31 c0 xor %eax,%eax
10a294: eb 0e jmp 10a2a4 <timer_settime+0x17c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10a296: e8 41 7a 00 00 call 111cdc <__errno>
10a29b: c7 00 16 00 00 00 movl $0x16,(%eax)
10a2a1: 83 c8 ff or $0xffffffff,%eax
}
10a2a4: 8d 65 f4 lea -0xc(%ebp),%esp
10a2a7: 5b pop %ebx
10a2a8: 5e pop %esi
10a2a9: 5f pop %edi
10a2aa: c9 leave
10a2ab: c3 ret
00109f68 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
109f68: 55 push %ebp
109f69: 89 e5 mov %esp,%ebp
109f6b: 57 push %edi
109f6c: 56 push %esi
109f6d: 53 push %ebx
109f6e: 83 ec 1c sub $0x1c,%esp
109f71: 8b 75 08 mov 0x8(%ebp),%esi
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
109f74: 83 3d 28 6c 12 00 00 cmpl $0x0,0x126c28
109f7b: 75 2c jne 109fa9 <ualarm+0x41>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
109f7d: c7 05 14 6c 12 00 00 movl $0x0,0x126c14
109f84: 00 00 00
the_watchdog->routine = routine;
109f87: c7 05 28 6c 12 00 30 movl $0x109f30,0x126c28
109f8e: 9f 10 00
the_watchdog->id = id;
109f91: c7 05 2c 6c 12 00 00 movl $0x0,0x126c2c
109f98: 00 00 00
the_watchdog->user_data = user_data;
109f9b: c7 05 30 6c 12 00 00 movl $0x0,0x126c30
109fa2: 00 00 00
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
109fa5: 31 db xor %ebx,%ebx
109fa7: eb 4f jmp 109ff8 <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 );
109fa9: 83 ec 0c sub $0xc,%esp
109fac: 68 0c 6c 12 00 push $0x126c0c
109fb1: e8 a2 33 00 00 call 10d358 <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
109fb6: 83 e8 02 sub $0x2,%eax
109fb9: 83 c4 10 add $0x10,%esp
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
109fbc: 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) ) {
109fbe: 83 f8 01 cmp $0x1,%eax
109fc1: 77 35 ja 109ff8 <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);
109fc3: a1 20 6c 12 00 mov 0x126c20,%eax
109fc8: 03 05 18 6c 12 00 add 0x126c18,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
109fce: 57 push %edi
109fcf: 57 push %edi
109fd0: 8d 55 e0 lea -0x20(%ebp),%edx
109fd3: 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);
109fd4: 2b 05 24 6c 12 00 sub 0x126c24,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
109fda: 50 push %eax
109fdb: e8 20 2f 00 00 call 10cf00 <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
109fe0: 69 4d e0 40 42 0f 00 imul $0xf4240,-0x20(%ebp),%ecx
remaining += tp.tv_nsec / 1000;
109fe7: 8b 45 e4 mov -0x1c(%ebp),%eax
109fea: bf e8 03 00 00 mov $0x3e8,%edi
109fef: 99 cltd
109ff0: f7 ff idiv %edi
109ff2: 8d 1c 08 lea (%eax,%ecx,1),%ebx
109ff5: 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 ) {
109ff8: 85 f6 test %esi,%esi
109ffa: 74 44 je 10a040 <ualarm+0xd8> <== NEVER TAKEN
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
109ffc: b9 40 42 0f 00 mov $0xf4240,%ecx
10a001: 89 f0 mov %esi,%eax
10a003: 31 d2 xor %edx,%edx
10a005: f7 f1 div %ecx
10a007: 89 45 e0 mov %eax,-0x20(%ebp)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
10a00a: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx
10a010: 89 55 e4 mov %edx,-0x1c(%ebp)
ticks = _Timespec_To_ticks( &tp );
10a013: 83 ec 0c sub $0xc,%esp
10a016: 8d 75 e0 lea -0x20(%ebp),%esi
10a019: 56 push %esi
10a01a: e8 3d 2f 00 00 call 10cf5c <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
10a01f: 89 34 24 mov %esi,(%esp)
10a022: e8 35 2f 00 00 call 10cf5c <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a027: a3 18 6c 12 00 mov %eax,0x126c18
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a02c: 59 pop %ecx
10a02d: 5e pop %esi
10a02e: 68 0c 6c 12 00 push $0x126c0c
10a033: 68 fc 63 12 00 push $0x1263fc
10a038: e8 03 32 00 00 call 10d240 <_Watchdog_Insert>
10a03d: 83 c4 10 add $0x10,%esp
}
return remaining;
}
10a040: 89 d8 mov %ebx,%eax
10a042: 8d 65 f4 lea -0xc(%ebp),%esp
10a045: 5b pop %ebx
10a046: 5e pop %esi
10a047: 5f pop %edi
10a048: c9 leave
10a049: c3 ret
0010a6d4 <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
10a6d4: 55 push %ebp
10a6d5: 89 e5 mov %esp,%ebp
10a6d7: 57 push %edi
10a6d8: 56 push %esi
10a6d9: 53 push %ebx
10a6da: 83 ec 58 sub $0x58,%esp
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
10a6dd: ff 75 08 pushl 0x8(%ebp)
10a6e0: e8 1a d9 ff ff call 107fff <rtems_filesystem_dirname>
10a6e5: 89 45 b4 mov %eax,-0x4c(%ebp)
if ( parentpathlen == 0 )
10a6e8: 83 c4 10 add $0x10,%esp
10a6eb: 85 c0 test %eax,%eax
10a6ed: 8d 45 d0 lea -0x30(%ebp),%eax
10a6f0: 75 15 jne 10a707 <unlink+0x33>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
10a6f2: 51 push %ecx
10a6f3: 50 push %eax
10a6f4: 8d 45 e4 lea -0x1c(%ebp),%eax
10a6f7: 50 push %eax
10a6f8: ff 75 08 pushl 0x8(%ebp)
10a6fb: e8 d4 e6 ff ff call 108dd4 <rtems_filesystem_get_start_loc>
10a700: 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;
10a703: 31 db xor %ebx,%ebx
10a705: eb 25 jmp 10a72c <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,
10a707: 83 ec 0c sub $0xc,%esp
10a70a: 6a 00 push $0x0
10a70c: 50 push %eax
10a70d: 6a 02 push $0x2
10a70f: ff 75 b4 pushl -0x4c(%ebp)
10a712: ff 75 08 pushl 0x8(%ebp)
10a715: e8 a4 d8 ff ff call 107fbe <rtems_filesystem_evaluate_path>
10a71a: 89 c2 mov %eax,%edx
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
10a71c: 83 c4 20 add $0x20,%esp
return -1;
10a71f: 83 c8 ff or $0xffffffff,%eax
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
10a722: 85 d2 test %edx,%edx
10a724: 0f 85 d6 00 00 00 jne 10a800 <unlink+0x12c> <== NEVER TAKEN
return -1;
free_parentloc = true;
10a72a: b3 01 mov $0x1,%bl
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
10a72c: 8d 7d bc lea -0x44(%ebp),%edi
10a72f: 8d 75 d0 lea -0x30(%ebp),%esi
10a732: b9 05 00 00 00 mov $0x5,%ecx
10a737: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = path + parentpathlen;
10a739: 8b 75 08 mov 0x8(%ebp),%esi
10a73c: 03 75 b4 add -0x4c(%ebp),%esi
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
10a73f: 83 c9 ff or $0xffffffff,%ecx
10a742: 89 f7 mov %esi,%edi
10a744: 31 c0 xor %eax,%eax
10a746: f2 ae repnz scas %es:(%edi),%al
10a748: f7 d1 not %ecx
10a74a: 49 dec %ecx
10a74b: 52 push %edx
10a74c: 52 push %edx
10a74d: 51 push %ecx
10a74e: 56 push %esi
10a74f: e8 ea d8 ff ff call 10803e <rtems_filesystem_prefix_separators>
10a754: 01 c6 add %eax,%esi
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
10a756: 83 c9 ff or $0xffffffff,%ecx
10a759: 89 f7 mov %esi,%edi
10a75b: 31 c0 xor %eax,%eax
10a75d: f2 ae repnz scas %es:(%edi),%al
10a75f: f7 d1 not %ecx
10a761: 49 dec %ecx
10a762: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10a769: 8d 7d bc lea -0x44(%ebp),%edi
10a76c: 57 push %edi
10a76d: 6a 00 push $0x0
10a76f: 51 push %ecx
10a770: 56 push %esi
10a771: e8 ea d7 ff ff call 107f60 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
10a776: 83 c4 20 add $0x20,%esp
10a779: 85 c0 test %eax,%eax
10a77b: 74 13 je 10a790 <unlink+0xbc>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
10a77d: 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 )
10a780: 84 db test %bl,%bl
10a782: 74 7c je 10a800 <unlink+0x12c> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
10a784: 83 ec 0c sub $0xc,%esp
10a787: 8d 55 d0 lea -0x30(%ebp),%edx
10a78a: 52 push %edx
10a78b: 89 45 b0 mov %eax,-0x50(%ebp)
10a78e: eb 65 jmp 10a7f5 <unlink+0x121>
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
10a790: 83 ec 0c sub $0xc,%esp
10a793: 57 push %edi
10a794: 8b 45 c8 mov -0x38(%ebp),%eax
10a797: ff 50 10 call *0x10(%eax)
10a79a: 83 c4 10 add $0x10,%esp
10a79d: 48 dec %eax
10a79e: 75 2f jne 10a7cf <unlink+0xfb>
rtems_filesystem_freenode( &loc );
10a7a0: 83 ec 0c sub $0xc,%esp
10a7a3: 57 push %edi
10a7a4: e8 d3 d8 ff ff call 10807c <rtems_filesystem_freenode>
if ( free_parentloc )
10a7a9: 83 c4 10 add $0x10,%esp
10a7ac: 84 db test %bl,%bl
10a7ae: 74 0f je 10a7bf <unlink+0xeb>
rtems_filesystem_freenode( &parentloc );
10a7b0: 83 ec 0c sub $0xc,%esp
10a7b3: 8d 45 d0 lea -0x30(%ebp),%eax
10a7b6: 50 push %eax
10a7b7: e8 c0 d8 ff ff call 10807c <rtems_filesystem_freenode>
10a7bc: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( EISDIR );
10a7bf: e8 04 a0 00 00 call 1147c8 <__errno>
10a7c4: c7 00 15 00 00 00 movl $0x15,(%eax)
10a7ca: 83 c8 ff or $0xffffffff,%eax
10a7cd: eb 31 jmp 10a800 <unlink+0x12c>
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
10a7cf: 50 push %eax
10a7d0: 50 push %eax
10a7d1: 57 push %edi
10a7d2: 8d 75 d0 lea -0x30(%ebp),%esi
10a7d5: 56 push %esi
10a7d6: 8b 45 c8 mov -0x38(%ebp),%eax
10a7d9: ff 50 0c call *0xc(%eax)
rtems_filesystem_freenode( &loc );
10a7dc: 89 3c 24 mov %edi,(%esp)
10a7df: 89 45 b0 mov %eax,-0x50(%ebp)
10a7e2: e8 95 d8 ff ff call 10807c <rtems_filesystem_freenode>
if ( free_parentloc )
10a7e7: 83 c4 10 add $0x10,%esp
10a7ea: 84 db test %bl,%bl
10a7ec: 8b 45 b0 mov -0x50(%ebp),%eax
10a7ef: 74 0f je 10a800 <unlink+0x12c>
rtems_filesystem_freenode( &parentloc );
10a7f1: 83 ec 0c sub $0xc,%esp
10a7f4: 56 push %esi
10a7f5: e8 82 d8 ff ff call 10807c <rtems_filesystem_freenode>
10a7fa: 83 c4 10 add $0x10,%esp
10a7fd: 8b 45 b0 mov -0x50(%ebp),%eax
return result;
}
10a800: 8d 65 f4 lea -0xc(%ebp),%esp
10a803: 5b pop %ebx
10a804: 5e pop %esi
10a805: 5f pop %edi
10a806: c9 leave
10a807: c3 ret
0010a935 <unmount>:
*/
int unmount(
const char *path
)
{
10a935: 55 push %ebp
10a936: 89 e5 mov %esp,%ebp
10a938: 57 push %edi
10a939: 56 push %esi
10a93a: 53 push %ebx
10a93b: 83 ec 38 sub $0x38,%esp
10a93e: 8b 55 08 mov 0x8(%ebp),%edx
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
10a941: 83 cb ff or $0xffffffff,%ebx
10a944: 31 c0 xor %eax,%eax
10a946: 89 d9 mov %ebx,%ecx
10a948: 89 d7 mov %edx,%edi
10a94a: f2 ae repnz scas %es:(%edi),%al
10a94c: f7 d1 not %ecx
10a94e: 49 dec %ecx
10a94f: 6a 01 push $0x1
10a951: 8d 7d d4 lea -0x2c(%ebp),%edi
10a954: 57 push %edi
10a955: 6a 00 push $0x0
10a957: 51 push %ecx
10a958: 52 push %edx
10a959: e8 e8 d5 ff ff call 107f46 <rtems_filesystem_evaluate_path>
10a95e: 83 c4 20 add $0x20,%esp
10a961: 85 c0 test %eax,%eax
10a963: 0f 85 f2 00 00 00 jne 10aa5b <unmount+0x126>
return -1;
mt_entry = loc.mt_entry;
10a969: 8b 75 e4 mov -0x1c(%ebp),%esi
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
10a96c: 8b 45 d4 mov -0x2c(%ebp),%eax
10a96f: 39 46 1c cmp %eax,0x1c(%esi)
10a972: 74 1c je 10a990 <unmount+0x5b>
rtems_filesystem_freenode( &loc );
10a974: 83 ec 0c sub $0xc,%esp
10a977: 57 push %edi
10a978: e8 87 d6 ff ff call 108004 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EACCES );
10a97d: e8 b2 76 00 00 call 112034 <__errno>
10a982: c7 00 0d 00 00 00 movl $0xd,(%eax)
10a988: 83 c4 10 add $0x10,%esp
10a98b: e9 cb 00 00 00 jmp 10aa5b <unmount+0x126>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
10a990: 83 ec 0c sub $0xc,%esp
10a993: 57 push %edi
10a994: e8 6b d6 ff ff call 108004 <rtems_filesystem_freenode>
* that made the current node thread based instead
* of system based? I thought it was but it doesn't
* look like it in this version.
*/
if ( rtems_filesystem_current.mt_entry == mt_entry )
10a999: 83 c4 10 add $0x10,%esp
10a99c: a1 dc 50 12 00 mov 0x1250dc,%eax
10a9a1: 39 70 14 cmp %esi,0x14(%eax)
10a9a4: 74 25 je 10a9cb <unmount+0x96>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
10a9a6: 51 push %ecx
10a9a7: 51 push %ecx
10a9a8: ff 76 2c pushl 0x2c(%esi)
10a9ab: 68 24 a9 10 00 push $0x10a924
10a9b0: e8 44 dd ff ff call 1086f9 <rtems_filesystem_mount_iterate>
10a9b5: 83 c4 10 add $0x10,%esp
10a9b8: 84 c0 test %al,%al
10a9ba: 75 0f jne 10a9cb <unmount+0x96>
* Run the file descriptor table to determine if there are any file
* descriptors that are currently active and reference nodes in the
* file system that we are trying to unmount
*/
if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )
10a9bc: 83 ec 0c sub $0xc,%esp
10a9bf: 56 push %esi
10a9c0: e8 27 d9 ff ff call 1082ec <rtems_libio_is_open_files_in_fs>
10a9c5: 83 c4 10 add $0x10,%esp
10a9c8: 48 dec %eax
10a9c9: 75 10 jne 10a9db <unmount+0xa6>
rtems_set_errno_and_return_minus_one( EBUSY );
10a9cb: e8 64 76 00 00 call 112034 <__errno>
10a9d0: c7 00 10 00 00 00 movl $0x10,(%eax)
10a9d6: e9 80 00 00 00 jmp 10aa5b <unmount+0x126>
* Allow the file system being unmounted on to do its cleanup.
* If it fails it will set the errno to the approprate value
* and the fileystem will not be modified.
*/
if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 )
10a9db: 83 ec 0c sub $0xc,%esp
10a9de: 8b 46 14 mov 0x14(%esi),%eax
10a9e1: 56 push %esi
10a9e2: ff 50 28 call *0x28(%eax)
10a9e5: 83 c4 10 add $0x10,%esp
return -1;
10a9e8: 83 ca ff or $0xffffffff,%edx
* Allow the file system being unmounted on to do its cleanup.
* If it fails it will set the errno to the approprate value
* and the fileystem will not be modified.
*/
if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 )
10a9eb: 85 c0 test %eax,%eax
10a9ed: 75 6f jne 10aa5e <unmount+0x129> <== NEVER TAKEN
* NOTE: Fatal error is called in a case which should never happen
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
10a9ef: 83 ec 0c sub $0xc,%esp
10a9f2: 8b 46 28 mov 0x28(%esi),%eax
10a9f5: 56 push %esi
10a9f6: ff 50 2c call *0x2c(%eax)
10a9f9: 83 c4 10 add $0x10,%esp
10a9fc: 85 c0 test %eax,%eax
10a9fe: 74 1d je 10aa1d <unmount+0xe8> <== ALWAYS TAKEN
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
10aa00: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa03: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED
10aa06: 56 push %esi <== NOT EXECUTED
10aa07: ff 50 20 call *0x20(%eax) <== NOT EXECUTED
10aa0a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
return -1;
10aa0d: 89 da mov %ebx,%edx <== NOT EXECUTED
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
10aa0f: 85 c0 test %eax,%eax <== NOT EXECUTED
10aa11: 74 4b je 10aa5e <unmount+0x129> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
10aa13: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa16: 6a 00 push $0x0 <== NOT EXECUTED
10aa18: e8 8b 0e 00 00 call 10b8a8 <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10aa1d: 52 push %edx
10aa1e: 6a 00 push $0x0
10aa20: 6a 00 push $0x0
10aa22: ff 35 c8 72 12 00 pushl 0x1272c8
10aa28: e8 f7 08 00 00 call 10b324 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10aa2d: 89 34 24 mov %esi,(%esp)
10aa30: e8 3b 11 00 00 call 10bb70 <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10aa35: 58 pop %eax
10aa36: ff 35 c8 72 12 00 pushl 0x1272c8
10aa3c: e8 cf 09 00 00 call 10b410 <rtems_semaphore_release>
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
mt_entry = loc.mt_entry;
fs_mount_loc = &mt_entry->mt_point_node;
10aa41: 8d 46 08 lea 0x8(%esi),%eax
/*
* Free the memory node that was allocated in mount
* Free the memory associated with the extracted mount table entry.
*/
rtems_filesystem_freenode( fs_mount_loc );
10aa44: 89 04 24 mov %eax,(%esp)
10aa47: e8 b8 d5 ff ff call 108004 <rtems_filesystem_freenode>
free( mt_entry );
10aa4c: 89 34 24 mov %esi,(%esp)
10aa4f: e8 c4 d5 ff ff call 108018 <free>
return 0;
10aa54: 83 c4 10 add $0x10,%esp
10aa57: 31 d2 xor %edx,%edx
10aa59: eb 03 jmp 10aa5e <unmount+0x129>
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
10aa5b: 83 ca ff or $0xffffffff,%edx
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
10aa5e: 89 d0 mov %edx,%eax
10aa60: 8d 65 f4 lea -0xc(%ebp),%esp
10aa63: 5b pop %ebx
10aa64: 5e pop %esi
10aa65: 5f pop %edi
10aa66: c9 leave
10aa67: c3 ret
0011c99c <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
11c99c: 55 push %ebp
11c99d: 89 e5 mov %esp,%ebp
11c99f: 56 push %esi
11c9a0: 53 push %ebx
11c9a1: 8b 5d 08 mov 0x8(%ebp),%ebx
11c9a4: 8b 55 0c mov 0xc(%ebp),%edx
11c9a7: 8b 4d 10 mov 0x10(%ebp),%ecx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11c9aa: 3b 1d 44 01 12 00 cmp 0x120144,%ebx
11c9b0: 73 14 jae 11c9c6 <write+0x2a>
iop = rtems_libio_iop( fd );
11c9b2: 6b db 38 imul $0x38,%ebx,%ebx
11c9b5: 03 1d 98 41 12 00 add 0x124198,%ebx
rtems_libio_check_is_open( iop );
11c9bb: 8b 73 14 mov 0x14(%ebx),%esi
11c9be: f7 c6 00 01 00 00 test $0x100,%esi
11c9c4: 75 0d jne 11c9d3 <write+0x37>
11c9c6: e8 e1 46 ff ff call 1110ac <__errno>
11c9cb: c7 00 09 00 00 00 movl $0x9,(%eax)
11c9d1: eb 1a jmp 11c9ed <write+0x51>
rtems_libio_check_buffer( buffer );
11c9d3: 85 d2 test %edx,%edx
11c9d5: 74 0b je 11c9e2 <write+0x46> <== NEVER TAKEN
rtems_libio_check_count( count );
11c9d7: 31 c0 xor %eax,%eax
11c9d9: 85 c9 test %ecx,%ecx
11c9db: 74 31 je 11ca0e <write+0x72>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
11c9dd: 83 e6 04 and $0x4,%esi
11c9e0: 75 10 jne 11c9f2 <write+0x56>
11c9e2: e8 c5 46 ff ff call 1110ac <__errno>
11c9e7: c7 00 16 00 00 00 movl $0x16,(%eax)
11c9ed: 83 c8 ff or $0xffffffff,%eax
11c9f0: eb 1c jmp 11ca0e <write+0x72>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
11c9f2: 50 push %eax
11c9f3: 8b 43 20 mov 0x20(%ebx),%eax
11c9f6: 51 push %ecx
11c9f7: 52 push %edx
11c9f8: 53 push %ebx
11c9f9: ff 50 0c call *0xc(%eax)
if ( rc > 0 )
11c9fc: 83 c4 10 add $0x10,%esp
11c9ff: 85 c0 test %eax,%eax
11ca01: 7e 0b jle 11ca0e <write+0x72>
iop->offset += rc;
11ca03: 89 c1 mov %eax,%ecx
11ca05: c1 f9 1f sar $0x1f,%ecx
11ca08: 01 43 0c add %eax,0xc(%ebx)
11ca0b: 11 4b 10 adc %ecx,0x10(%ebx)
return rc;
}
11ca0e: 8d 65 f8 lea -0x8(%ebp),%esp
11ca11: 5b pop %ebx
11ca12: 5e pop %esi
11ca13: c9 leave
11ca14: c3 ret
0010a948 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
10a948: 55 push %ebp
10a949: 89 e5 mov %esp,%ebp
10a94b: 57 push %edi
10a94c: 56 push %esi
10a94d: 53 push %ebx
10a94e: 83 ec 1c sub $0x1c,%esp
10a951: 8b 75 08 mov 0x8(%ebp),%esi
10a954: 8b 7d 0c mov 0xc(%ebp),%edi
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
10a957: 3b 35 44 11 12 00 cmp 0x121144,%esi
10a95d: 73 11 jae 10a970 <writev+0x28>
iop = rtems_libio_iop( fd );
10a95f: 6b f6 38 imul $0x38,%esi,%esi
10a962: 03 35 98 51 12 00 add 0x125198,%esi
rtems_libio_check_is_open( iop );
10a968: 8b 46 14 mov 0x14(%esi),%eax
10a96b: f6 c4 01 test $0x1,%ah
10a96e: 75 10 jne 10a980 <writev+0x38>
10a970: e8 17 73 00 00 call 111c8c <__errno>
10a975: c7 00 09 00 00 00 movl $0x9,(%eax)
10a97b: e9 ad 00 00 00 jmp 10aa2d <writev+0xe5>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10a980: a8 04 test $0x4,%al
10a982: 74 42 je 10a9c6 <writev+0x7e> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
10a984: 85 ff test %edi,%edi
10a986: 74 3e je 10a9c6 <writev+0x7e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
10a988: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a98c: 7e 38 jle 10a9c6 <writev+0x7e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
10a98e: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp)
10a995: 7f 2f jg 10a9c6 <writev+0x7e> <== NEVER TAKEN
10a997: b2 01 mov $0x1,%dl
10a999: 31 c0 xor %eax,%eax
10a99b: 31 c9 xor %ecx,%ecx
10a99d: eb 02 jmp 10a9a1 <writev+0x59>
if ( iov[v].iov_len )
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
10a99f: 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 )
10a9a1: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8)
10a9a5: 74 1f je 10a9c6 <writev+0x7e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
10a9a7: 83 7c c7 04 00 cmpl $0x0,0x4(%edi,%eax,8)
10a9ac: 0f 94 c3 sete %bl
10a9af: f7 db neg %ebx
10a9b1: 21 da and %ebx,%edx
/* check for wrap */
old = total;
total += iov[v].iov_len;
10a9b3: 8b 5c c7 04 mov 0x4(%edi,%eax,8),%ebx
10a9b7: 8d 1c 19 lea (%ecx,%ebx,1),%ebx
if ( total < old || total > SSIZE_MAX )
10a9ba: 81 fb ff 7f 00 00 cmp $0x7fff,%ebx
10a9c0: 7f 04 jg 10a9c6 <writev+0x7e> <== NEVER TAKEN
10a9c2: 39 cb cmp %ecx,%ebx
10a9c4: 7d 0d jge 10a9d3 <writev+0x8b>
rtems_set_errno_and_return_minus_one( EINVAL );
10a9c6: e8 c1 72 00 00 call 111c8c <__errno>
10a9cb: c7 00 16 00 00 00 movl $0x16,(%eax)
10a9d1: eb 5a jmp 10aa2d <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++ ) {
10a9d3: 40 inc %eax
10a9d4: 3b 45 10 cmp 0x10(%ebp),%eax
10a9d7: 7c c6 jl 10a99f <writev+0x57>
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
return 0;
10a9d9: 31 db xor %ebx,%ebx
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
10a9db: 84 d2 test %dl,%dl
10a9dd: 75 51 jne 10aa30 <writev+0xe8>
10a9df: 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 )
10a9e6: 8b 55 e4 mov -0x1c(%ebp),%edx
10a9e9: 8b 44 d7 04 mov 0x4(%edi,%edx,8),%eax
10a9ed: 85 c0 test %eax,%eax
10a9ef: 74 2f je 10aa20 <writev+0xd8> <== NEVER TAKEN
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
10a9f1: 52 push %edx
10a9f2: 8b 56 20 mov 0x20(%esi),%edx
10a9f5: 50 push %eax
10a9f6: 8b 45 e4 mov -0x1c(%ebp),%eax
10a9f9: ff 34 c7 pushl (%edi,%eax,8)
10a9fc: 56 push %esi
10a9fd: ff 52 0c call *0xc(%edx)
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
10aa00: 83 c4 10 add $0x10,%esp
10aa03: 83 f8 00 cmp $0x0,%eax
10aa06: 7c 25 jl 10aa2d <writev+0xe5> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
10aa08: 74 0d je 10aa17 <writev+0xcf> <== NEVER TAKEN
iop->offset += bytes;
10aa0a: 89 c1 mov %eax,%ecx
10aa0c: c1 f9 1f sar $0x1f,%ecx
10aa0f: 01 46 0c add %eax,0xc(%esi)
10aa12: 11 4e 10 adc %ecx,0x10(%esi)
total += bytes;
10aa15: 01 c3 add %eax,%ebx
}
if (bytes != iov[ v ].iov_len)
10aa17: 8b 55 e4 mov -0x1c(%ebp),%edx
10aa1a: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax
10aa1e: 75 10 jne 10aa30 <writev+0xe8> <== NEVER TAKEN
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
10aa20: ff 45 e4 incl -0x1c(%ebp)
10aa23: 8b 45 10 mov 0x10(%ebp),%eax
10aa26: 39 45 e4 cmp %eax,-0x1c(%ebp)
10aa29: 7c bb jl 10a9e6 <writev+0x9e>
10aa2b: eb 03 jmp 10aa30 <writev+0xe8>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
10aa2d: 83 cb ff or $0xffffffff,%ebx
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
10aa30: 89 d8 mov %ebx,%eax
10aa32: 8d 65 f4 lea -0xc(%ebp),%esp
10aa35: 5b pop %ebx
10aa36: 5e pop %esi
10aa37: 5f pop %edi
10aa38: c9 leave
10aa39: c3 ret