RTEMS 4.11Annotated Report
Fri Jul 16 21:10:19 2010
0010d610 <IMFS_Set_handlers>:
#define MAXSYMLINK 5
int IMFS_Set_handlers(
rtems_filesystem_location_info_t *loc
)
{
10d610: 55 push %ebp
10d611: 89 e5 mov %esp,%ebp
10d613: 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;
10d616: 8b 50 10 mov 0x10(%eax),%edx
10d619: 8b 52 34 mov 0x34(%edx),%edx
switch( node->type ) {
10d61c: 8b 08 mov (%eax),%ecx
10d61e: 8b 49 4c mov 0x4c(%ecx),%ecx
10d621: 49 dec %ecx
10d622: 83 f9 06 cmp $0x6,%ecx
10d625: 77 29 ja 10d650 <IMFS_Set_handlers+0x40><== NEVER TAKEN
10d627: ff 24 8d a0 ec 11 00 jmp *0x11eca0(,%ecx,4)
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
10d62e: 8b 52 0c mov 0xc(%edx),%edx
10d631: eb 1a jmp 10d64d <IMFS_Set_handlers+0x3d>
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
10d633: c7 40 08 c4 ec 11 00 movl $0x11ecc4,0x8(%eax)
break;
10d63a: eb 14 jmp 10d650 <IMFS_Set_handlers+0x40>
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
10d63c: c7 40 08 34 ed 11 00 movl $0x11ed34,0x8(%eax)
break;
10d643: eb 0b jmp 10d650 <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;
10d645: 8b 52 08 mov 0x8(%edx),%edx
10d648: eb 03 jmp 10d64d <IMFS_Set_handlers+0x3d>
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
10d64a: 8b 52 10 mov 0x10(%edx),%edx
10d64d: 89 50 08 mov %edx,0x8(%eax)
break;
}
return 0;
}
10d650: 31 c0 xor %eax,%eax
10d652: c9 leave
10d653: c3 ret
0010d410 <IMFS_chown>:
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
10d410: 55 push %ebp
10d411: 89 e5 mov %esp,%ebp
10d413: 57 push %edi
10d414: 56 push %esi
10d415: 53 push %ebx
10d416: 83 ec 1c sub $0x1c,%esp
10d419: 8b 7d 0c mov 0xc(%ebp),%edi
10d41c: 8b 75 10 mov 0x10(%ebp),%esi
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = (IMFS_jnode_t *) pathloc->node_access;
10d41f: 8b 45 08 mov 0x8(%ebp),%eax
10d422: 8b 18 mov (%eax),%ebx
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
10d424: e8 33 0c 00 00 call 10e05c <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
10d429: 66 85 c0 test %ax,%ax
10d42c: 74 16 je 10d444 <IMFS_chown+0x34> <== ALWAYS TAKEN
10d42e: 66 3b 43 3c cmp 0x3c(%ebx),%ax <== NOT EXECUTED
10d432: 74 10 je 10d444 <IMFS_chown+0x34> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
10d434: e8 1b 3d 00 00 call 111154 <__errno> <== NOT EXECUTED
10d439: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10d43f: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10d442: eb 20 jmp 10d464 <IMFS_chown+0x54> <== NOT EXECUTED
#endif
jnode->st_uid = owner;
10d444: 66 89 7b 3c mov %di,0x3c(%ebx)
jnode->st_gid = group;
10d448: 66 89 73 3e mov %si,0x3e(%ebx)
IMFS_update_ctime( jnode );
10d44c: 50 push %eax
10d44d: 50 push %eax
10d44e: 6a 00 push $0x0
10d450: 8d 45 e0 lea -0x20(%ebp),%eax
10d453: 50 push %eax
10d454: e8 03 9f ff ff call 10735c <gettimeofday>
10d459: 8b 45 e0 mov -0x20(%ebp),%eax
10d45c: 89 43 48 mov %eax,0x48(%ebx)
return 0;
10d45f: 83 c4 10 add $0x10,%esp
10d462: 31 c0 xor %eax,%eax
}
10d464: 8d 65 f4 lea -0xc(%ebp),%esp
10d467: 5b pop %ebx
10d468: 5e pop %esi
10d469: 5f pop %edi
10d46a: c9 leave
10d46b: c3 ret
0010d4db <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
10d4db: 55 push %ebp
10d4dc: 89 e5 mov %esp,%ebp
10d4de: 57 push %edi
10d4df: 56 push %esi
10d4e0: 53 push %ebx
10d4e1: 83 ec 1c sub $0x1c,%esp
10d4e4: 8b 4d 08 mov 0x8(%ebp),%ecx
10d4e7: 8b 7d 0c mov 0xc(%ebp),%edi
10d4ea: 8b 5d 18 mov 0x18(%ebp),%ebx
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
return NULL;
10d4ed: 31 c0 xor %eax,%eax
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
10d4ef: 85 c9 test %ecx,%ecx
10d4f1: 0f 84 dc 00 00 00 je 10d5d3 <IMFS_create_node+0xf8> <== NEVER TAKEN
return NULL;
parent = parent_loc->node_access;
10d4f7: 8b 11 mov (%ecx),%edx
fs_info = parent_loc->mt_entry->fs_info;
10d4f9: 8b 49 10 mov 0x10(%ecx),%ecx
10d4fc: 8b 71 34 mov 0x34(%ecx),%esi
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
10d4ff: 83 ff 07 cmp $0x7,%edi
10d502: 75 0d jne 10d511 <IMFS_create_node+0x36>
10d504: 81 7e 10 1c ec 11 00 cmpl $0x11ec1c,0x10(%esi)
10d50b: 0f 84 c2 00 00 00 je 10d5d3 <IMFS_create_node+0xf8>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
10d511: 50 push %eax
10d512: a1 54 1f 12 00 mov 0x121f54,%eax
10d517: 8b 40 2c mov 0x2c(%eax),%eax
10d51a: f7 d0 not %eax
10d51c: 23 45 14 and 0x14(%ebp),%eax
10d51f: 50 push %eax
10d520: ff 75 10 pushl 0x10(%ebp)
10d523: 57 push %edi
10d524: 89 55 e4 mov %edx,-0x1c(%ebp)
10d527: e8 40 ff ff ff call 10d46c <IMFS_allocate_node>
if ( !node )
10d52c: 83 c4 10 add $0x10,%esp
10d52f: 85 c0 test %eax,%eax
10d531: 8b 55 e4 mov -0x1c(%ebp),%edx
10d534: 0f 84 99 00 00 00 je 10d5d3 <IMFS_create_node+0xf8>
return NULL;
/*
* Set the type specific information
*/
switch (type) {
10d53a: 4f dec %edi
10d53b: 83 ff 06 cmp $0x6,%edi
10d53e: 77 71 ja 10d5b1 <IMFS_create_node+0xd6> <== NEVER TAKEN
10d540: ff 24 bd 84 ec 11 00 jmp *0x11ec84(,%edi,4)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10d547: 8d 48 54 lea 0x54(%eax),%ecx
10d54a: 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;
10d54d: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
case IMFS_DIRECTORY:
rtems_chain_initialize_empty(&node->info.directory.Entries);
10d554: 8d 48 50 lea 0x50(%eax),%ecx
10d557: 89 48 58 mov %ecx,0x58(%eax)
10d55a: eb 55 jmp 10d5b1 <IMFS_create_node+0xd6>
case IMFS_HARD_LINK:
node->info.hard_link.link_node = info->hard_link.link_node;
break;
case IMFS_SYM_LINK:
node->info.sym_link.name = info->sym_link.name;
10d55c: 8b 0b mov (%ebx),%ecx
10d55e: 89 48 50 mov %ecx,0x50(%eax)
break;
10d561: eb 4e jmp 10d5b1 <IMFS_create_node+0xd6>
case IMFS_DEVICE:
node->info.device.major = info->device.major;
10d563: 8b 0b mov (%ebx),%ecx
10d565: 89 48 50 mov %ecx,0x50(%eax)
node->info.device.minor = info->device.minor;
10d568: 8b 4b 04 mov 0x4(%ebx),%ecx
10d56b: 89 48 54 mov %ecx,0x54(%eax)
break;
10d56e: eb 41 jmp 10d5b1 <IMFS_create_node+0xd6>
case IMFS_LINEAR_FILE:
node->info.linearfile.size = 0;
10d570: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10d577: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.linearfile.direct = 0;
10d57e: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
case IMFS_MEMORY_FILE:
node->info.file.size = 0;
10d585: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10d58c: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.file.indirect = 0;
10d593: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
node->info.file.doubly_indirect = 0;
10d59a: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
node->info.file.triply_indirect = 0;
10d5a1: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
break;
10d5a8: eb 07 jmp 10d5b1 <IMFS_create_node+0xd6>
case IMFS_FIFO:
node->info.fifo.pipe = NULL;
10d5aa: 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;
10d5b1: 89 50 08 mov %edx,0x8(%eax)
node->st_ino = ++fs_info->ino_count;
10d5b4: 8b 4e 04 mov 0x4(%esi),%ecx
10d5b7: 41 inc %ecx
10d5b8: 89 4e 04 mov %ecx,0x4(%esi)
10d5bb: 89 48 38 mov %ecx,0x38(%eax)
10d5be: 53 push %ebx
10d5bf: 53 push %ebx
10d5c0: 50 push %eax
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
10d5c1: 83 c2 50 add $0x50,%edx
10d5c4: 52 push %edx
10d5c5: 89 45 e4 mov %eax,-0x1c(%ebp)
10d5c8: e8 67 d4 ff ff call 10aa34 <_Chain_Append>
return node;
10d5cd: 83 c4 10 add $0x10,%esp
10d5d0: 8b 45 e4 mov -0x1c(%ebp),%eax
}
10d5d3: 8d 65 f4 lea -0xc(%ebp),%esp
10d5d6: 5b pop %ebx
10d5d7: 5e pop %esi
10d5d8: 5f pop %edi
10d5d9: c9 leave
10d5da: c3 ret
0010d5db <IMFS_create_root_node>:
return node;
}
IMFS_jnode_t *IMFS_create_root_node(void)
{
10d5db: 55 push %ebp
10d5dc: 89 e5 mov %esp,%ebp
10d5de: 83 ec 0c sub $0xc,%esp
IMFS_jnode_t *node;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( IMFS_DIRECTORY, "", (S_IFDIR | 0755) );
10d5e1: 68 ed 41 00 00 push $0x41ed
10d5e6: 68 05 e9 11 00 push $0x11e905
10d5eb: 6a 01 push $0x1
10d5ed: e8 7a fe ff ff call 10d46c <IMFS_allocate_node>
if ( !node )
10d5f2: 83 c4 10 add $0x10,%esp
10d5f5: 85 c0 test %eax,%eax
10d5f7: 74 13 je 10d60c <IMFS_create_root_node+0x31><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10d5f9: 8d 50 54 lea 0x54(%eax),%edx
10d5fc: 89 50 50 mov %edx,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;
10d5ff: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
/*
* Set the type specific information
*
* NOTE: Root node is always a directory.
*/
rtems_chain_initialize_empty(&node->info.directory.Entries);
10d606: 8d 50 50 lea 0x50(%eax),%edx
10d609: 89 50 58 mov %edx,0x58(%eax)
return node;
}
10d60c: c9 leave
10d60d: c3 ret
0010d6f0 <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
10d6f0: 55 push %ebp
10d6f1: 89 e5 mov %esp,%ebp
10d6f3: 57 push %edi
10d6f4: 56 push %esi
10d6f5: 53 push %ebx
10d6f6: 83 ec 5c sub $0x5c,%esp
10d6f9: 8b 5d 14 mov 0x14(%ebp),%ebx
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10d6fc: 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;
10d6fe: 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;
10d703: 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) ) {
10d70a: e9 39 01 00 00 jmp 10d848 <IMFS_eval_path+0x158>
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
10d70f: 8d 45 e4 lea -0x1c(%ebp),%eax
10d712: 50 push %eax
10d713: 8d 4d af lea -0x51(%ebp),%ecx
10d716: 51 push %ecx
10d717: ff 75 0c pushl 0xc(%ebp)
10d71a: 8b 45 08 mov 0x8(%ebp),%eax
10d71d: 03 45 a4 add -0x5c(%ebp),%eax
10d720: 50 push %eax
10d721: e8 e6 05 00 00 call 10dd0c <IMFS_get_token>
10d726: 89 c6 mov %eax,%esi
pathnamelen -= len;
10d728: 8b 55 e4 mov -0x1c(%ebp),%edx
i += len;
if ( !pathloc->node_access )
10d72b: 83 c4 10 add $0x10,%esp
10d72e: 83 3b 00 cmpl $0x0,(%ebx)
10d731: 0f 84 ed 00 00 00 je 10d824 <IMFS_eval_path+0x134> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10d737: 85 c0 test %eax,%eax
10d739: 74 30 je 10d76b <IMFS_eval_path+0x7b>
if ( node->type == IMFS_DIRECTORY )
10d73b: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10d73f: 75 2a jne 10d76b <IMFS_eval_path+0x7b>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10d741: 57 push %edi
10d742: 57 push %edi
10d743: 6a 01 push $0x1
10d745: 53 push %ebx
10d746: 89 55 a0 mov %edx,-0x60(%ebp)
10d749: e8 06 ff ff ff call 10d654 <IMFS_evaluate_permission>
10d74e: 83 c4 10 add $0x10,%esp
10d751: 85 c0 test %eax,%eax
10d753: 8b 55 a0 mov -0x60(%ebp),%edx
10d756: 75 13 jne 10d76b <IMFS_eval_path+0x7b>
rtems_set_errno_and_return_minus_one( EACCES );
10d758: e8 f7 39 00 00 call 111154 <__errno>
10d75d: c7 00 0d 00 00 00 movl $0xd,(%eax)
10d763: 83 cf ff or $0xffffffff,%edi
10d766: e9 55 01 00 00 jmp 10d8c0 <IMFS_eval_path+0x1d0>
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
10d76b: 29 55 0c sub %edx,0xc(%ebp)
i += len;
10d76e: 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;
10d771: 8b 3b mov (%ebx),%edi
switch( type ) {
10d773: 83 fe 03 cmp $0x3,%esi
10d776: 74 38 je 10d7b0 <IMFS_eval_path+0xc0>
10d778: 83 fe 04 cmp $0x4,%esi
10d77b: 0f 84 b7 00 00 00 je 10d838 <IMFS_eval_path+0x148>
10d781: 83 fe 02 cmp $0x2,%esi
10d784: 0f 85 be 00 00 00 jne 10d848 <IMFS_eval_path+0x158>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
10d78a: a1 54 1f 12 00 mov 0x121f54,%eax
10d78f: 3b 78 18 cmp 0x18(%eax),%edi
10d792: 0f 84 b0 00 00 00 je 10d848 <IMFS_eval_path+0x158>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access) {
10d798: 8b 43 10 mov 0x10(%ebx),%eax
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
10d79b: 3b 78 1c cmp 0x1c(%eax),%edi
10d79e: 75 0b jne 10d7ab <IMFS_eval_path+0xbb>
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
newloc = pathloc->mt_entry->mt_point_node;
10d7a0: 8d 7d d0 lea -0x30(%ebp),%edi
10d7a3: 8d 70 08 lea 0x8(%eax),%esi
10d7a6: e9 bd 00 00 00 jmp 10d868 <IMFS_eval_path+0x178>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
10d7ab: 8b 7f 08 mov 0x8(%edi),%edi
10d7ae: eb 70 jmp 10d820 <IMFS_eval_path+0x130>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
10d7b0: 8b 47 4c mov 0x4c(%edi),%eax
10d7b3: 83 f8 03 cmp $0x3,%eax
10d7b6: 75 15 jne 10d7cd <IMFS_eval_path+0xdd>
IMFS_evaluate_hard_link( pathloc, 0 );
10d7b8: 51 push %ecx
10d7b9: 51 push %ecx
10d7ba: 6a 00 push $0x0
10d7bc: 53 push %ebx
10d7bd: e8 d8 fe ff ff call 10d69a <IMFS_evaluate_hard_link>
node = pathloc->node_access;
10d7c2: 8b 3b mov (%ebx),%edi
if ( !node )
10d7c4: 83 c4 10 add $0x10,%esp
10d7c7: 85 ff test %edi,%edi
10d7c9: 75 1f jne 10d7ea <IMFS_eval_path+0xfa> <== ALWAYS TAKEN
10d7cb: eb 23 jmp 10d7f0 <IMFS_eval_path+0x100> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTDIR );
} else if ( node->type == IMFS_SYM_LINK ) {
10d7cd: 83 f8 04 cmp $0x4,%eax
10d7d0: 75 18 jne 10d7ea <IMFS_eval_path+0xfa>
result = IMFS_evaluate_sym_link( pathloc, 0 );
10d7d2: 52 push %edx
10d7d3: 52 push %edx
10d7d4: 6a 00 push $0x0
10d7d6: 53 push %ebx
10d7d7: e8 ee 00 00 00 call 10d8ca <IMFS_evaluate_sym_link>
node = pathloc->node_access;
10d7dc: 8b 3b mov (%ebx),%edi
if ( result == -1 )
10d7de: 83 c4 10 add $0x10,%esp
10d7e1: 83 f8 ff cmp $0xffffffff,%eax
10d7e4: 0f 84 d4 00 00 00 je 10d8be <IMFS_eval_path+0x1ce> <== NEVER TAKEN
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10d7ea: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10d7ee: 74 10 je 10d800 <IMFS_eval_path+0x110>
rtems_set_errno_and_return_minus_one( ENOTDIR );
10d7f0: e8 5f 39 00 00 call 111154 <__errno>
10d7f5: c7 00 14 00 00 00 movl $0x14,(%eax)
10d7fb: e9 63 ff ff ff jmp 10d763 <IMFS_eval_path+0x73>
/*
* 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 ) {
10d800: 8b 47 5c mov 0x5c(%edi),%eax
10d803: 85 c0 test %eax,%eax
10d805: 74 08 je 10d80f <IMFS_eval_path+0x11f>
newloc = node->info.directory.mt_fs->mt_fs_root;
10d807: 8d 7d d0 lea -0x30(%ebp),%edi
10d80a: 8d 70 1c lea 0x1c(%eax),%esi
10d80d: eb 59 jmp 10d868 <IMFS_eval_path+0x178>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10d80f: 50 push %eax
10d810: 50 push %eax
10d811: 8d 45 af lea -0x51(%ebp),%eax
10d814: 50 push %eax
10d815: 57 push %edi
10d816: e8 79 04 00 00 call 10dc94 <IMFS_find_match_in_dir>
10d81b: 89 c7 mov %eax,%edi
if ( !node )
10d81d: 83 c4 10 add $0x10,%esp
10d820: 85 ff test %edi,%edi
10d822: 75 10 jne 10d834 <IMFS_eval_path+0x144>
rtems_set_errno_and_return_minus_one( ENOENT );
10d824: e8 2b 39 00 00 call 111154 <__errno>
10d829: c7 00 02 00 00 00 movl $0x2,(%eax)
10d82f: e9 2f ff ff ff jmp 10d763 <IMFS_eval_path+0x73>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
10d834: 89 3b mov %edi,(%ebx)
10d836: eb 10 jmp 10d848 <IMFS_eval_path+0x158>
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
10d838: e8 17 39 00 00 call 111154 <__errno>
10d83d: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10d843: e9 1b ff ff ff jmp 10d763 <IMFS_eval_path+0x73>
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
10d848: 83 fe 04 cmp $0x4,%esi
10d84b: 74 08 je 10d855 <IMFS_eval_path+0x165> <== NEVER TAKEN
10d84d: 85 f6 test %esi,%esi
10d84f: 0f 85 ba fe ff ff jne 10d70f <IMFS_eval_path+0x1f>
* 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 ) {
10d855: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10d859: 75 41 jne 10d89c <IMFS_eval_path+0x1ac>
if ( node->info.directory.mt_fs != NULL ) {
10d85b: 8b 77 5c mov 0x5c(%edi),%esi
10d85e: 85 f6 test %esi,%esi
10d860: 74 3a je 10d89c <IMFS_eval_path+0x1ac>
newloc = node->info.directory.mt_fs->mt_fs_root;
10d862: 8d 7d d0 lea -0x30(%ebp),%edi
10d865: 83 c6 1c add $0x1c,%esi
10d868: b9 05 00 00 00 mov $0x5,%ecx
10d86d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10d86f: 8d 75 d0 lea -0x30(%ebp),%esi
10d872: b1 05 mov $0x5,%cl
10d874: 89 df mov %ebx,%edi
10d876: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
10d878: 8b 45 e4 mov -0x1c(%ebp),%eax
10d87b: 8b 53 0c mov 0xc(%ebx),%edx
10d87e: 53 push %ebx
10d87f: ff 75 10 pushl 0x10(%ebp)
10d882: 8b 4d 0c mov 0xc(%ebp),%ecx
10d885: 01 c1 add %eax,%ecx
10d887: 51 push %ecx
10d888: 8b 4d a4 mov -0x5c(%ebp),%ecx
10d88b: 29 c1 sub %eax,%ecx
10d88d: 8b 45 08 mov 0x8(%ebp),%eax
10d890: 01 c8 add %ecx,%eax
10d892: 50 push %eax
10d893: ff 12 call *(%edx)
10d895: 89 c7 mov %eax,%edi
10d897: 83 c4 10 add $0x10,%esp
10d89a: eb 24 jmp 10d8c0 <IMFS_eval_path+0x1d0>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
10d89c: 83 ec 0c sub $0xc,%esp
10d89f: 53 push %ebx
10d8a0: e8 6b fd ff ff call 10d610 <IMFS_Set_handlers>
10d8a5: 89 c7 mov %eax,%edi
10d8a7: 59 pop %ecx
10d8a8: 5e pop %esi
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
10d8a9: ff 75 10 pushl 0x10(%ebp)
10d8ac: 53 push %ebx
10d8ad: e8 a2 fd ff ff call 10d654 <IMFS_evaluate_permission>
10d8b2: 83 c4 10 add $0x10,%esp
10d8b5: 85 c0 test %eax,%eax
10d8b7: 75 07 jne 10d8c0 <IMFS_eval_path+0x1d0>
10d8b9: e9 9a fe ff ff jmp 10d758 <IMFS_eval_path+0x68>
10d8be: 89 c7 mov %eax,%edi <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10d8c0: 89 f8 mov %edi,%eax
10d8c2: 8d 65 f4 lea -0xc(%ebp),%esp
10d8c5: 5b pop %ebx
10d8c6: 5e pop %esi
10d8c7: 5f pop %edi
10d8c8: c9 leave
10d8c9: c3 ret
0010d9e0 <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 */
)
{
10d9e0: 55 push %ebp
10d9e1: 89 e5 mov %esp,%ebp
10d9e3: 57 push %edi
10d9e4: 56 push %esi
10d9e5: 53 push %ebx
10d9e6: 83 ec 5c sub $0x5c,%esp
10d9e9: 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;
10d9ec: 8b 1a mov (%edx),%ebx
/*
* Get the path length.
*/
pathlen = strlen( path );
10d9ee: 31 c0 xor %eax,%eax
10d9f0: 83 c9 ff or $0xffffffff,%ecx
10d9f3: 8b 7d 08 mov 0x8(%ebp),%edi
10d9f6: f2 ae repnz scas %es:(%edi),%al
10d9f8: f7 d1 not %ecx
10d9fa: 49 dec %ecx
10d9fb: 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;
10d9fe: 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 );
10da05: 8d 7d af lea -0x51(%ebp),%edi
10da08: 89 d6 mov %edx,%esi
10da0a: 8d 45 e4 lea -0x1c(%ebp),%eax
10da0d: 50 push %eax
10da0e: 57 push %edi
10da0f: ff 75 a0 pushl -0x60(%ebp)
10da12: 8b 45 08 mov 0x8(%ebp),%eax
10da15: 03 45 a4 add -0x5c(%ebp),%eax
10da18: 50 push %eax
10da19: e8 ee 02 00 00 call 10dd0c <IMFS_get_token>
10da1e: 89 c2 mov %eax,%edx
pathlen -= len;
10da20: 8b 4d e4 mov -0x1c(%ebp),%ecx
10da23: 29 4d a0 sub %ecx,-0x60(%ebp)
i += len;
if ( !pathloc->node_access )
10da26: 83 c4 10 add $0x10,%esp
10da29: 83 3e 00 cmpl $0x0,(%esi)
10da2c: 0f 84 79 01 00 00 je 10dbab <IMFS_evaluate_for_make+0x1cb><== NEVER TAKEN
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10da32: 85 c0 test %eax,%eax
10da34: 74 36 je 10da6c <IMFS_evaluate_for_make+0x8c>
if ( node->type == IMFS_DIRECTORY )
10da36: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10da3a: 75 30 jne 10da6c <IMFS_evaluate_for_make+0x8c>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10da3c: 53 push %ebx
10da3d: 53 push %ebx
10da3e: 6a 01 push $0x1
10da40: 56 push %esi
10da41: 89 45 9c mov %eax,-0x64(%ebp)
10da44: 89 4d 98 mov %ecx,-0x68(%ebp)
10da47: e8 08 fc ff ff call 10d654 <IMFS_evaluate_permission>
10da4c: 83 c4 10 add $0x10,%esp
10da4f: 85 c0 test %eax,%eax
10da51: 8b 55 9c mov -0x64(%ebp),%edx
10da54: 8b 4d 98 mov -0x68(%ebp),%ecx
10da57: 75 13 jne 10da6c <IMFS_evaluate_for_make+0x8c>
rtems_set_errno_and_return_minus_one( EACCES );
10da59: e8 f6 36 00 00 call 111154 <__errno>
10da5e: c7 00 0d 00 00 00 movl $0xd,(%eax)
10da64: 83 cb ff or $0xffffffff,%ebx
10da67: e9 99 01 00 00 jmp 10dc05 <IMFS_evaluate_for_make+0x225>
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
10da6c: 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;
10da6f: 8b 1e mov (%esi),%ebx
switch( type ) {
10da71: 83 fa 02 cmp $0x2,%edx
10da74: 74 1f je 10da95 <IMFS_evaluate_for_make+0xb5>
10da76: 77 0a ja 10da82 <IMFS_evaluate_for_make+0xa2>
10da78: 85 d2 test %edx,%edx
10da7a: 0f 84 d9 00 00 00 je 10db59 <IMFS_evaluate_for_make+0x179>
10da80: eb 88 jmp 10da0a <IMFS_evaluate_for_make+0x2a>
10da82: 83 fa 03 cmp $0x3,%edx
10da85: 74 40 je 10dac7 <IMFS_evaluate_for_make+0xe7>
10da87: 83 fa 04 cmp $0x4,%edx
10da8a: 0f 85 7a ff ff ff jne 10da0a <IMFS_evaluate_for_make+0x2a><== NEVER TAKEN
10da90: e9 d4 00 00 00 jmp 10db69 <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 )
10da95: a1 54 1f 12 00 mov 0x121f54,%eax
10da9a: 3b 58 18 cmp 0x18(%eax),%ebx
10da9d: 0f 84 67 ff ff ff je 10da0a <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){
10daa3: 8b 46 10 mov 0x10(%esi),%eax
10daa6: 3b 58 1c cmp 0x1c(%eax),%ebx
10daa9: 75 0c jne 10dab7 <IMFS_evaluate_for_make+0xd7>
10daab: 89 f2 mov %esi,%edx
10daad: 89 c6 mov %eax,%esi
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
10daaf: 8d 7d d0 lea -0x30(%ebp),%edi
10dab2: 83 c6 08 add $0x8,%esi
10dab5: eb 5a jmp 10db11 <IMFS_evaluate_for_make+0x131>
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
10dab7: 8b 5b 08 mov 0x8(%ebx),%ebx
10daba: 85 db test %ebx,%ebx
10dabc: 0f 85 90 00 00 00 jne 10db52 <IMFS_evaluate_for_make+0x172>
10dac2: e9 e4 00 00 00 jmp 10dbab <IMFS_evaluate_for_make+0x1cb>
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
10dac7: 8b 43 4c mov 0x4c(%ebx),%eax
10daca: 83 f8 03 cmp $0x3,%eax
10dacd: 74 05 je 10dad4 <IMFS_evaluate_for_make+0xf4>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
10dacf: 83 f8 04 cmp $0x4,%eax
10dad2: 75 16 jne 10daea <IMFS_evaluate_for_make+0x10a>
result = IMFS_evaluate_link( pathloc, 0 );
10dad4: 50 push %eax
10dad5: 50 push %eax
10dad6: 6a 00 push $0x0
10dad8: 56 push %esi
10dad9: e8 7f fe ff ff call 10d95d <IMFS_evaluate_link>
if ( result == -1 )
10dade: 83 c4 10 add $0x10,%esp
10dae1: 83 f8 ff cmp $0xffffffff,%eax
10dae4: 0f 84 19 01 00 00 je 10dc03 <IMFS_evaluate_for_make+0x223><== NEVER TAKEN
return -1;
}
node = pathloc->node_access;
10daea: 8b 06 mov (%esi),%eax
if ( !node )
10daec: 85 c0 test %eax,%eax
10daee: 0f 84 e9 00 00 00 je 10dbdd <IMFS_evaluate_for_make+0x1fd><== NEVER TAKEN
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10daf4: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10daf8: 0f 85 df 00 00 00 jne 10dbdd <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 ) {
10dafe: 8b 50 5c mov 0x5c(%eax),%edx
10db01: 85 d2 test %edx,%edx
10db03: 74 3b je 10db40 <IMFS_evaluate_for_make+0x160>
10db05: 89 f0 mov %esi,%eax
10db07: 89 d6 mov %edx,%esi
10db09: 89 c2 mov %eax,%edx
newloc = node->info.directory.mt_fs->mt_fs_root;
10db0b: 8d 7d d0 lea -0x30(%ebp),%edi
10db0e: 83 c6 1c add $0x1c,%esi
10db11: b9 05 00 00 00 mov $0x5,%ecx
10db16: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10db18: 8d 75 d0 lea -0x30(%ebp),%esi
10db1b: b1 05 mov $0x5,%cl
10db1d: 89 d7 mov %edx,%edi
10db1f: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
10db21: 56 push %esi
10db22: 8b 42 0c mov 0xc(%edx),%eax
10db25: ff 75 10 pushl 0x10(%ebp)
10db28: 52 push %edx
10db29: 8b 55 a4 mov -0x5c(%ebp),%edx
10db2c: 2b 55 e4 sub -0x1c(%ebp),%edx
10db2f: 03 55 08 add 0x8(%ebp),%edx
10db32: 52 push %edx
10db33: ff 50 04 call *0x4(%eax)
10db36: 89 c3 mov %eax,%ebx
10db38: 83 c4 10 add $0x10,%esp
10db3b: e9 c5 00 00 00 jmp 10dc05 <IMFS_evaluate_for_make+0x225>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10db40: 53 push %ebx
10db41: 53 push %ebx
10db42: 57 push %edi
10db43: 50 push %eax
10db44: e8 4b 01 00 00 call 10dc94 <IMFS_find_match_in_dir>
10db49: 89 c3 mov %eax,%ebx
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
10db4b: 83 c4 10 add $0x10,%esp
10db4e: 85 c0 test %eax,%eax
10db50: 74 27 je 10db79 <IMFS_evaluate_for_make+0x199>
done = true;
else
pathloc->node_access = node;
10db52: 89 1e mov %ebx,(%esi)
10db54: e9 b1 fe ff ff jmp 10da0a <IMFS_evaluate_for_make+0x2a>
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
10db59: e8 f6 35 00 00 call 111154 <__errno>
10db5e: c7 00 11 00 00 00 movl $0x11,(%eax)
10db64: e9 fb fe ff ff jmp 10da64 <IMFS_evaluate_for_make+0x84>
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
10db69: e8 e6 35 00 00 call 111154 <__errno>
10db6e: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10db74: e9 eb fe ff ff jmp 10da64 <IMFS_evaluate_for_make+0x84>
10db79: 89 f2 mov %esi,%edx
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
10db7b: 8b 45 a4 mov -0x5c(%ebp),%eax
10db7e: 2b 45 e4 sub -0x1c(%ebp),%eax
10db81: 03 45 08 add 0x8(%ebp),%eax
10db84: 8b 4d 10 mov 0x10(%ebp),%ecx
10db87: 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(
10db89: 8b 5d 08 mov 0x8(%ebp),%ebx
10db8c: 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++) {
10db8f: eb 2a jmp 10dbbb <IMFS_evaluate_for_make+0x1db>
if ( !IMFS_is_separator( path[ i ] ) )
10db91: 83 ec 0c sub $0xc,%esp
10db94: 0f be c0 movsbl %al,%eax
10db97: 50 push %eax
10db98: 89 55 9c mov %edx,-0x64(%ebp)
10db9b: e8 10 a4 ff ff call 107fb0 <rtems_filesystem_is_separator>
10dba0: 43 inc %ebx
10dba1: 83 c4 10 add $0x10,%esp
10dba4: 85 c0 test %eax,%eax
10dba6: 8b 55 9c mov -0x64(%ebp),%edx
10dba9: 75 10 jne 10dbbb <IMFS_evaluate_for_make+0x1db>
rtems_set_errno_and_return_minus_one( ENOENT );
10dbab: e8 a4 35 00 00 call 111154 <__errno>
10dbb0: c7 00 02 00 00 00 movl $0x2,(%eax)
10dbb6: e9 a9 fe ff ff jmp 10da64 <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++) {
10dbbb: 8a 03 mov (%ebx),%al
10dbbd: 84 c0 test %al,%al
10dbbf: 75 d0 jne 10db91 <IMFS_evaluate_for_make+0x1b1>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
10dbc1: 83 ec 0c sub $0xc,%esp
10dbc4: 52 push %edx
10dbc5: 89 55 9c mov %edx,-0x64(%ebp)
10dbc8: e8 43 fa ff ff call 10d610 <IMFS_Set_handlers>
10dbcd: 89 c3 mov %eax,%ebx
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
10dbcf: 8b 55 9c mov -0x64(%ebp),%edx
10dbd2: 8b 02 mov (%edx),%eax
10dbd4: 83 c4 10 add $0x10,%esp
10dbd7: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10dbdb: 74 10 je 10dbed <IMFS_evaluate_for_make+0x20d><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
10dbdd: e8 72 35 00 00 call 111154 <__errno>
10dbe2: c7 00 14 00 00 00 movl $0x14,(%eax)
10dbe8: e9 77 fe ff ff jmp 10da64 <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 ) )
10dbed: 51 push %ecx
10dbee: 51 push %ecx
10dbef: 6a 03 push $0x3
10dbf1: 52 push %edx
10dbf2: e8 5d fa ff ff call 10d654 <IMFS_evaluate_permission>
10dbf7: 83 c4 10 add $0x10,%esp
10dbfa: 85 c0 test %eax,%eax
10dbfc: 75 07 jne 10dc05 <IMFS_evaluate_for_make+0x225>
10dbfe: e9 56 fe ff ff jmp 10da59 <IMFS_evaluate_for_make+0x79>
10dc03: 89 c3 mov %eax,%ebx <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10dc05: 89 d8 mov %ebx,%eax
10dc07: 8d 65 f4 lea -0xc(%ebp),%esp
10dc0a: 5b pop %ebx
10dc0b: 5e pop %esi
10dc0c: 5f pop %edi
10dc0d: c9 leave
10dc0e: c3 ret
0010d69a <IMFS_evaluate_hard_link>:
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10d69a: 55 push %ebp
10d69b: 89 e5 mov %esp,%ebp
10d69d: 53 push %ebx
10d69e: 83 ec 04 sub $0x4,%esp
10d6a1: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_jnode_t *jnode = node->node_access;
10d6a4: 8b 03 mov (%ebx),%eax
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_HARD_LINK )
10d6a6: 83 78 4c 03 cmpl $0x3,0x4c(%eax)
10d6aa: 74 0d je 10d6b9 <IMFS_evaluate_hard_link+0x1f><== ALWAYS TAKEN
rtems_fatal_error_occurred (0xABCD0000);
10d6ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10d6af: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED
10d6b4: e8 d7 d0 ff ff call 10a790 <rtems_fatal_error_occurred><== NOT EXECUTED
/*
* Set the hard link value and the handlers.
*/
node->node_access = jnode->info.hard_link.link_node;
10d6b9: 8b 40 50 mov 0x50(%eax),%eax
10d6bc: 89 03 mov %eax,(%ebx)
IMFS_Set_handlers( node );
10d6be: 83 ec 0c sub $0xc,%esp
10d6c1: 53 push %ebx
10d6c2: e8 49 ff ff ff call 10d610 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
10d6c7: 58 pop %eax
10d6c8: 5a pop %edx
10d6c9: ff 75 0c pushl 0xc(%ebp)
10d6cc: 53 push %ebx
10d6cd: e8 82 ff ff ff call 10d654 <IMFS_evaluate_permission>
10d6d2: 89 c2 mov %eax,%edx
10d6d4: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( EACCES );
return result;
10d6d7: 31 c0 xor %eax,%eax
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
10d6d9: 85 d2 test %edx,%edx
10d6db: 75 0e jne 10d6eb <IMFS_evaluate_hard_link+0x51><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EACCES );
10d6dd: e8 72 3a 00 00 call 111154 <__errno> <== NOT EXECUTED
10d6e2: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED
10d6e8: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
return result;
}
10d6eb: 8b 5d fc mov -0x4(%ebp),%ebx
10d6ee: c9 leave
10d6ef: c3 ret
0010d654 <IMFS_evaluate_permission>:
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
10d654: 55 push %ebp
10d655: 89 e5 mov %esp,%ebp
10d657: 57 push %edi
10d658: 56 push %esi
10d659: 53 push %ebx
10d65a: 83 ec 0c sub $0xc,%esp
10d65d: 8b 75 0c mov 0xc(%ebp),%esi
if ( !rtems_libio_is_valid_perms( flags ) ) {
rtems_set_errno_and_return_minus_one( EIO );
}
jnode = node->node_access;
10d660: 8b 45 08 mov 0x8(%ebp),%eax
10d663: 8b 18 mov (%eax),%ebx
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
10d665: e8 f2 09 00 00 call 10e05c <geteuid>
10d66a: 89 c7 mov %eax,%edi
st_gid = getegid();
10d66c: e8 db 09 00 00 call 10e04c <getegid>
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
10d671: 66 3b 7b 3c cmp 0x3c(%ebx),%di
10d675: 75 05 jne 10d67c <IMFS_evaluate_permission+0x28>
flags_to_test <<= 6;
10d677: c1 e6 06 shl $0x6,%esi
10d67a: eb 09 jmp 10d685 <IMFS_evaluate_permission+0x31>
else if ( st_gid == jnode->st_gid )
10d67c: 66 3b 43 3e cmp 0x3e(%ebx),%ax
10d680: 75 03 jne 10d685 <IMFS_evaluate_permission+0x31><== NEVER TAKEN
flags_to_test <<= 3;
10d682: 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 )
10d685: 8b 43 30 mov 0x30(%ebx),%eax
10d688: 21 f0 and %esi,%eax
return 1;
return 0;
10d68a: 39 f0 cmp %esi,%eax
10d68c: 0f 94 c0 sete %al
10d68f: 0f b6 c0 movzbl %al,%eax
}
10d692: 83 c4 0c add $0xc,%esp
10d695: 5b pop %ebx
10d696: 5e pop %esi
10d697: 5f pop %edi
10d698: c9 leave
10d699: c3 ret
0010d8ca <IMFS_evaluate_sym_link>:
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10d8ca: 55 push %ebp
10d8cb: 89 e5 mov %esp,%ebp
10d8cd: 57 push %edi
10d8ce: 56 push %esi
10d8cf: 53 push %ebx
10d8d0: 83 ec 1c sub $0x1c,%esp
10d8d3: 8b 5d 08 mov 0x8(%ebp),%ebx
10d8d6: 8b 75 0c mov 0xc(%ebp),%esi
IMFS_jnode_t *jnode = node->node_access;
10d8d9: 8b 3b mov (%ebx),%edi
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_SYM_LINK )
10d8db: 83 7f 4c 04 cmpl $0x4,0x4c(%edi)
10d8df: 74 0a je 10d8eb <IMFS_evaluate_sym_link+0x21><== ALWAYS TAKEN
rtems_fatal_error_occurred (0xABCD0000);
10d8e1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10d8e4: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED
10d8e9: eb 0f jmp 10d8fa <IMFS_evaluate_sym_link+0x30><== NOT EXECUTED
if ( !jnode->Parent )
10d8eb: 8b 47 08 mov 0x8(%edi),%eax
10d8ee: 85 c0 test %eax,%eax
10d8f0: 75 0d jne 10d8ff <IMFS_evaluate_sym_link+0x35><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xBAD00000 );
10d8f2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10d8f5: 68 00 00 d0 ba push $0xbad00000 <== NOT EXECUTED
10d8fa: e8 91 ce ff ff call 10a790 <rtems_fatal_error_occurred><== NOT EXECUTED
/*
* Move the node_access to either the symbolic links parent or
* root depending on the symbolic links path.
*/
node->node_access = jnode->Parent;
10d8ff: 89 03 mov %eax,(%ebx)
rtems_filesystem_get_sym_start_loc(
10d901: 51 push %ecx
10d902: 53 push %ebx
10d903: 8d 45 e4 lea -0x1c(%ebp),%eax
10d906: 50 push %eax
10d907: ff 77 50 pushl 0x50(%edi)
10d90a: e8 65 0b 00 00 call 10e474 <rtems_filesystem_get_sym_start_loc>
/*
* Use eval path to evaluate the path of the symbolic link.
*/
result = IMFS_eval_path(
10d90f: 8b 57 50 mov 0x50(%edi),%edx
10d912: 03 55 e4 add -0x1c(%ebp),%edx
10d915: 31 c0 xor %eax,%eax
10d917: 83 c9 ff or $0xffffffff,%ecx
10d91a: 89 d7 mov %edx,%edi
10d91c: f2 ae repnz scas %es:(%edi),%al
10d91e: f7 d1 not %ecx
10d920: 49 dec %ecx
10d921: 53 push %ebx
10d922: 56 push %esi
10d923: 51 push %ecx
10d924: 52 push %edx
10d925: e8 c6 fd ff ff call 10d6f0 <IMFS_eval_path>
10d92a: 89 c7 mov %eax,%edi
strlen( &jnode->info.sym_link.name[i] ),
flags,
node
);
IMFS_Set_handlers( node );
10d92c: 83 c4 14 add $0x14,%esp
10d92f: 53 push %ebx
10d930: e8 db fc ff ff call 10d610 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
10d935: 58 pop %eax
10d936: 5a pop %edx
10d937: 56 push %esi
10d938: 53 push %ebx
10d939: e8 16 fd ff ff call 10d654 <IMFS_evaluate_permission>
10d93e: 83 c4 10 add $0x10,%esp
10d941: 85 c0 test %eax,%eax
10d943: 75 0e jne 10d953 <IMFS_evaluate_sym_link+0x89><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EACCES );
10d945: e8 0a 38 00 00 call 111154 <__errno> <== NOT EXECUTED
10d94a: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED
10d950: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED
return result;
}
10d953: 89 f8 mov %edi,%eax
10d955: 8d 65 f4 lea -0xc(%ebp),%esp
10d958: 5b pop %ebx
10d959: 5e pop %esi
10d95a: 5f pop %edi
10d95b: c9 leave
10d95c: c3 ret
00110974 <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
110974: 55 push %ebp
110975: 89 e5 mov %esp,%ebp
110977: 53 push %ebx
110978: 83 ec 14 sub $0x14,%esp
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = loc->node_access;
11097b: 8b 45 08 mov 0x8(%ebp),%eax
11097e: 8b 18 mov (%eax),%ebx
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
110980: e8 d7 d6 ff ff call 10e05c <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
110985: 66 85 c0 test %ax,%ax
110988: 74 16 je 1109a0 <IMFS_fchmod+0x2c> <== ALWAYS TAKEN
11098a: 66 3b 43 3c cmp 0x3c(%ebx),%ax <== NOT EXECUTED
11098e: 74 10 je 1109a0 <IMFS_fchmod+0x2c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
110990: e8 bf 07 00 00 call 111154 <__errno> <== NOT EXECUTED
110995: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
11099b: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
11099e: eb 2e jmp 1109ce <IMFS_fchmod+0x5a> <== NOT EXECUTED
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
1109a0: 8b 45 0c mov 0xc(%ebp),%eax
1109a3: 25 ff 0f 00 00 and $0xfff,%eax
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
1109a8: 8b 53 30 mov 0x30(%ebx),%edx
1109ab: 81 e2 00 f0 ff ff and $0xfffff000,%edx
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
1109b1: 09 d0 or %edx,%eax
1109b3: 89 43 30 mov %eax,0x30(%ebx)
IMFS_update_ctime( jnode );
1109b6: 50 push %eax
1109b7: 50 push %eax
1109b8: 6a 00 push $0x0
1109ba: 8d 45 f0 lea -0x10(%ebp),%eax
1109bd: 50 push %eax
1109be: e8 99 69 ff ff call 10735c <gettimeofday>
1109c3: 8b 45 f0 mov -0x10(%ebp),%eax
1109c6: 89 43 48 mov %eax,0x48(%ebx)
return 0;
1109c9: 83 c4 10 add $0x10,%esp
1109cc: 31 c0 xor %eax,%eax
}
1109ce: 8b 5d fc mov -0x4(%ebp),%ebx
1109d1: c9 leave
1109d2: c3 ret
00107503 <IMFS_fifo_close>:
}
int IMFS_fifo_close(
rtems_libio_t *iop
)
{
107503: 55 push %ebp
107504: 89 e5 mov %esp,%ebp
107506: 57 push %edi
107507: 56 push %esi
107508: 53 push %ebx
107509: 83 ec 14 sub $0x14,%esp
10750c: 8b 75 08 mov 0x8(%ebp),%esi
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
10750f: 8b 7e 18 mov 0x18(%esi),%edi
int err = pipe_release(&JNODE2PIPE(jnode), iop);
107512: 56 push %esi
107513: 8d 47 50 lea 0x50(%edi),%eax
107516: 50 push %eax
107517: e8 89 7e 00 00 call 10f3a5 <pipe_release>
10751c: 89 c3 mov %eax,%ebx
if (err == 0) {
10751e: 83 c4 10 add $0x10,%esp
107521: 83 f8 00 cmp $0x0,%eax
107524: 75 15 jne 10753b <IMFS_fifo_close+0x38> <== NEVER TAKEN
iop->flags &= ~LIBIO_FLAGS_OPEN;
107526: 81 66 14 ff fe ff ff andl $0xfffffeff,0x14(%esi)
IMFS_check_node_remove(jnode);
10752d: 83 ec 0c sub $0xc,%esp
107530: 57 push %edi
107531: e8 4c 05 00 00 call 107a82 <IMFS_check_node_remove>
107536: 83 c4 10 add $0x10,%esp
107539: eb 0e jmp 107549 <IMFS_fifo_close+0x46>
}
IMFS_FIFO_RETURN(err);
10753b: 7d 0c jge 107549 <IMFS_fifo_close+0x46> <== NOT EXECUTED
10753d: e8 9e b4 00 00 call 1129e0 <__errno> <== NOT EXECUTED
107542: f7 db neg %ebx <== NOT EXECUTED
107544: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
107546: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED
}
107549: 89 d8 mov %ebx,%eax
10754b: 8d 65 f4 lea -0xc(%ebp),%esp
10754e: 5b pop %ebx
10754f: 5e pop %esi
107550: 5f pop %edi
107551: c9 leave
107552: c3 ret
001073b8 <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
1073b8: 55 push %ebp
1073b9: 89 e5 mov %esp,%ebp
1073bb: 53 push %ebx
1073bc: 83 ec 10 sub $0x10,%esp
1073bf: 8b 45 08 mov 0x8(%ebp),%eax
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
1073c2: 50 push %eax
1073c3: ff 75 14 pushl 0x14(%ebp)
1073c6: ff 75 10 pushl 0x10(%ebp)
1073c9: ff 75 0c pushl 0xc(%ebp)
1073cc: 8b 40 18 mov 0x18(%eax),%eax
1073cf: ff 70 50 pushl 0x50(%eax)
1073d2: e8 55 87 00 00 call 10fb2c <pipe_lseek>
1073d7: 89 c3 mov %eax,%ebx
1073d9: 99 cltd
IMFS_FIFO_RETURN(err);
1073da: 83 c4 20 add $0x20,%esp
1073dd: 85 d2 test %edx,%edx
1073df: 79 0e jns 1073ef <IMFS_fifo_lseek+0x37> <== NEVER TAKEN
1073e1: e8 fa b5 00 00 call 1129e0 <__errno>
1073e6: f7 db neg %ebx
1073e8: 89 18 mov %ebx,(%eax)
1073ea: 83 c8 ff or $0xffffffff,%eax
1073ed: 89 c2 mov %eax,%edx
}
1073ef: 8b 5d fc mov -0x4(%ebp),%ebx
1073f2: c9 leave
1073f3: c3 ret
00107454 <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
107454: 55 push %ebp
107455: 89 e5 mov %esp,%ebp
107457: 56 push %esi
107458: 53 push %ebx
107459: 83 ec 10 sub $0x10,%esp
10745c: 8b 45 08 mov 0x8(%ebp),%eax
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
10745f: 8b 70 18 mov 0x18(%eax),%esi
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
107462: 50 push %eax
107463: ff 75 10 pushl 0x10(%ebp)
107466: ff 75 0c pushl 0xc(%ebp)
107469: ff 76 50 pushl 0x50(%esi)
10746c: e8 af 84 00 00 call 10f920 <pipe_write>
107471: 89 c3 mov %eax,%ebx
if (err > 0) {
107473: 83 c4 10 add $0x10,%esp
107476: 83 f8 00 cmp $0x0,%eax
107479: 7e 1b jle 107496 <IMFS_fifo_write+0x42>
IMFS_mtime_ctime_update(jnode);
10747b: 50 push %eax
10747c: 50 push %eax
10747d: 6a 00 push $0x0
10747f: 8d 45 f0 lea -0x10(%ebp),%eax
107482: 50 push %eax
107483: e8 74 0d 00 00 call 1081fc <gettimeofday>
107488: 8b 45 f0 mov -0x10(%ebp),%eax
10748b: 89 46 44 mov %eax,0x44(%esi)
10748e: 89 46 48 mov %eax,0x48(%esi)
107491: 83 c4 10 add $0x10,%esp
107494: eb 0e jmp 1074a4 <IMFS_fifo_write+0x50>
}
IMFS_FIFO_RETURN(err);
107496: 74 0c je 1074a4 <IMFS_fifo_write+0x50> <== NEVER TAKEN
107498: e8 43 b5 00 00 call 1129e0 <__errno>
10749d: f7 db neg %ebx
10749f: 89 18 mov %ebx,(%eax)
1074a1: 83 cb ff or $0xffffffff,%ebx
}
1074a4: 89 d8 mov %ebx,%eax
1074a6: 8d 65 f8 lea -0x8(%ebp),%esp
1074a9: 5b pop %ebx
1074aa: 5e pop %esi
1074ab: c9 leave
1074ac: c3 ret
0010dc94 <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
10dc94: 55 push %ebp
10dc95: 89 e5 mov %esp,%ebp
10dc97: 57 push %edi
10dc98: 56 push %esi
10dc99: 53 push %ebx
10dc9a: 83 ec 0c sub $0xc,%esp
10dc9d: 8b 5d 08 mov 0x8(%ebp),%ebx
10dca0: 8b 7d 0c mov 0xc(%ebp),%edi
#if defined(RTEMS_DEBUG)
assert( directory );
assert( name );
#endif
if ( !name )
10dca3: 85 ff test %edi,%edi
10dca5: 74 52 je 10dcf9 <IMFS_find_match_in_dir+0x65><== NEVER TAKEN
return 0;
if ( !directory )
10dca7: 85 db test %ebx,%ebx
10dca9: 74 54 je 10dcff <IMFS_find_match_in_dir+0x6b><== NEVER TAKEN
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
10dcab: 56 push %esi
10dcac: 56 push %esi
10dcad: 68 bc ec 11 00 push $0x11ecbc
10dcb2: 57 push %edi
10dcb3: e8 60 40 00 00 call 111d18 <strcmp>
10dcb8: 83 c4 10 add $0x10,%esp
10dcbb: 85 c0 test %eax,%eax
10dcbd: 74 40 je 10dcff <IMFS_find_match_in_dir+0x6b><== NEVER TAKEN
return directory;
if ( !strcmp( name, dotdotname ) )
10dcbf: 51 push %ecx
10dcc0: 51 push %ecx
10dcc1: 68 be ec 11 00 push $0x11ecbe
10dcc6: 57 push %edi
10dcc7: e8 4c 40 00 00 call 111d18 <strcmp>
10dccc: 83 c4 10 add $0x10,%esp
10dccf: 85 c0 test %eax,%eax
10dcd1: 75 05 jne 10dcd8 <IMFS_find_match_in_dir+0x44><== ALWAYS TAKEN
return directory->Parent;
10dcd3: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED
10dcd6: eb 27 jmp 10dcff <IMFS_find_match_in_dir+0x6b><== NOT EXECUTED
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
10dcd8: 8b 73 50 mov 0x50(%ebx),%esi
10dcdb: 83 c3 54 add $0x54,%ebx
10dcde: eb 15 jmp 10dcf5 <IMFS_find_match_in_dir+0x61>
!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 ) )
10dce0: 8d 46 0c lea 0xc(%esi),%eax
10dce3: 52 push %edx
10dce4: 52 push %edx
10dce5: 50 push %eax
10dce6: 57 push %edi
10dce7: e8 2c 40 00 00 call 111d18 <strcmp>
10dcec: 83 c4 10 add $0x10,%esp
10dcef: 85 c0 test %eax,%eax
10dcf1: 74 0a je 10dcfd <IMFS_find_match_in_dir+0x69>
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 ) {
10dcf3: 8b 36 mov (%esi),%esi
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
10dcf5: 39 de cmp %ebx,%esi
10dcf7: 75 e7 jne 10dce0 <IMFS_find_match_in_dir+0x4c>
#if defined(RTEMS_DEBUG)
assert( directory );
assert( name );
#endif
if ( !name )
return 0;
10dcf9: 31 db xor %ebx,%ebx
10dcfb: eb 02 jmp 10dcff <IMFS_find_match_in_dir+0x6b>
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;
10dcfd: 89 f3 mov %esi,%ebx
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
10dcff: 89 d8 mov %ebx,%eax
10dd01: 8d 65 f4 lea -0xc(%ebp),%esp
10dd04: 5b pop %ebx
10dd05: 5e pop %esi
10dd06: 5f pop %edi
10dd07: c9 leave
10dd08: c3 ret
0010dc10 <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
)
{
10dc10: 55 push %ebp
10dc11: 89 e5 mov %esp,%ebp
10dc13: 57 push %edi
10dc14: 56 push %esi
10dc15: 53 push %ebx
10dc16: 83 ec 2c sub $0x2c,%esp
10dc19: 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;
10dc1c: 8b 58 1c mov 0x1c(%eax),%ebx
loc = temp_mt_entry->mt_fs_root;
10dc1f: 8d 7d d4 lea -0x2c(%ebp),%edi
10dc22: 8d 70 1c lea 0x1c(%eax),%esi
10dc25: b9 05 00 00 00 mov $0x5,%ecx
10dc2a: 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;
10dc2c: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
10dc33: 8d 75 d4 lea -0x2c(%ebp),%esi
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
10dc36: 8b 7b 08 mov 0x8(%ebx),%edi
loc.node_access = (void *)jnode;
10dc39: 89 5d d4 mov %ebx,-0x2c(%ebp)
IMFS_Set_handlers( &loc );
10dc3c: 83 ec 0c sub $0xc,%esp
10dc3f: 56 push %esi
10dc40: e8 cb f9 ff ff call 10d610 <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
10dc45: 83 c4 10 add $0x10,%esp
10dc48: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10dc4c: 75 08 jne 10dc56 <IMFS_fsunmount+0x46>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10dc4e: 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 ) ) {
10dc51: 39 43 50 cmp %eax,0x50(%ebx)
10dc54: 75 13 jne 10dc69 <IMFS_fsunmount+0x59>
result = IMFS_unlink( NULL, &loc );
10dc56: 50 push %eax
10dc57: 50 push %eax
10dc58: 56 push %esi
10dc59: 6a 00 push $0x0
10dc5b: e8 d0 91 ff ff call 106e30 <IMFS_unlink>
if (result != 0)
10dc60: 83 c4 10 add $0x10,%esp
10dc63: 85 c0 test %eax,%eax
10dc65: 75 1d jne 10dc84 <IMFS_fsunmount+0x74> <== NEVER TAKEN
return -1;
jnode = next;
10dc67: 89 fb mov %edi,%ebx
}
if ( jnode != NULL ) {
10dc69: 85 db test %ebx,%ebx
10dc6b: 74 1c je 10dc89 <IMFS_fsunmount+0x79>
if ( jnode->type == IMFS_DIRECTORY ) {
10dc6d: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10dc71: 75 c3 jne 10dc36 <IMFS_fsunmount+0x26> <== NEVER TAKEN
10dc73: 8d 43 54 lea 0x54(%ebx),%eax
if ( jnode_has_children( jnode ) )
10dc76: 39 43 50 cmp %eax,0x50(%ebx)
10dc79: 74 bb je 10dc36 <IMFS_fsunmount+0x26>
jnode = jnode_get_first_child( jnode );
10dc7b: 8b 5b 50 mov 0x50(%ebx),%ebx
}
}
} while (jnode != NULL);
10dc7e: 85 db test %ebx,%ebx
10dc80: 75 b4 jne 10dc36 <IMFS_fsunmount+0x26> <== ALWAYS TAKEN
10dc82: eb 05 jmp 10dc89 <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;
10dc84: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10dc87: eb 02 jmp 10dc8b <IMFS_fsunmount+0x7b> <== NOT EXECUTED
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
return 0;
10dc89: 31 c0 xor %eax,%eax
}
10dc8b: 8d 65 f4 lea -0xc(%ebp),%esp
10dc8e: 5b pop %ebx
10dc8f: 5e pop %esi
10dc90: 5f pop %edi
10dc91: c9 leave
10dc92: c3 ret
0010dd0c <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
10dd0c: 55 push %ebp
10dd0d: 89 e5 mov %esp,%ebp
10dd0f: 57 push %edi
10dd10: 56 push %esi
10dd11: 53 push %ebx
10dd12: 83 ec 1c sub $0x1c,%esp
10dd15: 8b 7d 08 mov 0x8(%ebp),%edi
10dd18: 8b 75 10 mov 0x10(%ebp),%esi
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
10dd1b: 8a 17 mov (%edi),%dl
int pathlen,
char *token,
int *token_len
)
{
register int i = 0;
10dd1d: 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) ) {
10dd1f: eb 10 jmp 10dd31 <IMFS_get_token+0x25>
token[i] = c;
10dd21: 88 14 1e mov %dl,(%esi,%ebx,1)
if ( i == IMFS_NAME_MAX )
10dd24: 83 fb 20 cmp $0x20,%ebx
10dd27: 0f 84 86 00 00 00 je 10ddb3 <IMFS_get_token+0xa7>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
10dd2d: 43 inc %ebx
10dd2e: 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) ) {
10dd31: 83 ec 0c sub $0xc,%esp
10dd34: 0f be c2 movsbl %dl,%eax
10dd37: 50 push %eax
10dd38: 88 55 e4 mov %dl,-0x1c(%ebp)
10dd3b: e8 70 a2 ff ff call 107fb0 <rtems_filesystem_is_separator>
10dd40: 83 c4 10 add $0x10,%esp
10dd43: 85 c0 test %eax,%eax
10dd45: 8a 55 e4 mov -0x1c(%ebp),%dl
10dd48: 75 05 jne 10dd4f <IMFS_get_token+0x43>
10dd4a: 3b 5d 0c cmp 0xc(%ebp),%ebx
10dd4d: 7c d2 jl 10dd21 <IMFS_get_token+0x15>
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
10dd4f: 85 db test %ebx,%ebx
10dd51: 75 10 jne 10dd63 <IMFS_get_token+0x57>
token[i] = c;
10dd53: 88 16 mov %dl,(%esi)
if ( (token[i] != '\0') && pathlen ) {
10dd55: 84 d2 test %dl,%dl
10dd57: 74 06 je 10dd5f <IMFS_get_token+0x53>
10dd59: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10dd5d: 75 16 jne 10dd75 <IMFS_get_token+0x69>
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
10dd5f: 31 ff xor %edi,%edi
10dd61: eb 1c jmp 10dd7f <IMFS_get_token+0x73>
char *token,
int *token_len
)
{
register int i = 0;
IMFS_token_types type = IMFS_NAME;
10dd63: 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') {
10dd68: 80 7c 1e ff 00 cmpb $0x0,-0x1(%esi,%ebx,1)
10dd6d: 74 10 je 10dd7f <IMFS_get_token+0x73> <== NEVER TAKEN
token[i] = '\0';
10dd6f: c6 04 1e 00 movb $0x0,(%esi,%ebx,1)
10dd73: eb 0a jmp 10dd7f <IMFS_get_token+0x73>
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
type = IMFS_CURRENT_DIR;
10dd75: bf 01 00 00 00 mov $0x1,%edi
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
10dd7a: bb 01 00 00 00 mov $0x1,%ebx
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
10dd7f: 8b 45 14 mov 0x14(%ebp),%eax
10dd82: 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 ) {
10dd84: 83 ff 03 cmp $0x3,%edi
10dd87: 75 3d jne 10ddc6 <IMFS_get_token+0xba>
if ( strcmp( token, "..") == 0 )
10dd89: 52 push %edx
10dd8a: 52 push %edx
10dd8b: 68 c1 ec 11 00 push $0x11ecc1
10dd90: 56 push %esi
10dd91: e8 82 3f 00 00 call 111d18 <strcmp>
10dd96: 83 c4 10 add $0x10,%esp
10dd99: 85 c0 test %eax,%eax
10dd9b: 74 1d je 10ddba <IMFS_get_token+0xae>
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
10dd9d: 50 push %eax
10dd9e: 50 push %eax
10dd9f: 68 c2 ec 11 00 push $0x11ecc2
10dda4: 56 push %esi
10dda5: e8 6e 3f 00 00 call 111d18 <strcmp>
10ddaa: 83 c4 10 add $0x10,%esp
10ddad: 85 c0 test %eax,%eax
10ddaf: 74 10 je 10ddc1 <IMFS_get_token+0xb5>
10ddb1: eb 13 jmp 10ddc6 <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;
10ddb3: bf 04 00 00 00 mov $0x4,%edi
10ddb8: eb 0c jmp 10ddc6 <IMFS_get_token+0xba>
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
10ddba: bf 02 00 00 00 mov $0x2,%edi
10ddbf: eb 05 jmp 10ddc6 <IMFS_get_token+0xba>
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
10ddc1: bf 01 00 00 00 mov $0x1,%edi
}
return type;
}
10ddc6: 89 f8 mov %edi,%eax
10ddc8: 8d 65 f4 lea -0xc(%ebp),%esp
10ddcb: 5b pop %ebx
10ddcc: 5e pop %esi
10ddcd: 5f pop %edi
10ddce: c9 leave
10ddcf: c3 ret
00106aac <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
)
{
106aac: 55 push %ebp
106aad: 89 e5 mov %esp,%ebp
106aaf: 57 push %edi
106ab0: 56 push %esi
106ab1: 53 push %ebx
106ab2: 83 ec 1c sub $0x1c,%esp
106ab5: 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,
106ab8: a1 48 01 12 00 mov 0x120148,%eax
106abd: 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) {
106ac2: ba 10 00 00 00 mov $0x10,%edx
106ac7: 39 c2 cmp %eax,%edx
106ac9: 74 0a je 106ad5 <IMFS_initialize_support+0x29>
106acb: d1 e2 shl %edx
106acd: 49 dec %ecx
106ace: 75 f7 jne 106ac7 <IMFS_initialize_support+0x1b><== ALWAYS TAKEN
is_valid = true;
}
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
106ad0: b8 80 00 00 00 mov $0x80,%eax <== NOT EXECUTED
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
is_valid = true;
}
}
*dest_bytes_per_block = ((is_valid)
106ad5: a3 8c 3d 12 00 mov %eax,0x123d8c
/*
* 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();
106ada: e8 fc 6a 00 00 call 10d5db <IMFS_create_root_node>
106adf: 89 c2 mov %eax,%edx
106ae1: 89 43 1c mov %eax,0x1c(%ebx)
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
106ae4: 8b 45 14 mov 0x14(%ebp),%eax
106ae7: 89 43 24 mov %eax,0x24(%ebx)
temp_mt_entry->mt_fs_root.ops = op_table;
106aea: 8b 45 0c mov 0xc(%ebp),%eax
106aed: 89 43 28 mov %eax,0x28(%ebx)
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
106af0: 8d 7b 38 lea 0x38(%ebx),%edi
106af3: be 54 ec 11 00 mov $0x11ec54,%esi
106af8: b9 0c 00 00 00 mov $0xc,%ecx
106afd: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
106aff: 50 push %eax
106b00: 50 push %eax
106b01: 6a 14 push $0x14
106b03: 6a 01 push $0x1
106b05: 89 55 e4 mov %edx,-0x1c(%ebp)
106b08: e8 1b 06 00 00 call 107128 <calloc>
if ( !fs_info ) {
106b0d: 83 c4 10 add $0x10,%esp
106b10: 85 c0 test %eax,%eax
106b12: 8b 55 e4 mov -0x1c(%ebp),%edx
106b15: 75 1c jne 106b33 <IMFS_initialize_support+0x87><== ALWAYS TAKEN
free(temp_mt_entry->mt_fs_root.node_access);
106b17: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106b1a: 52 push %edx <== NOT EXECUTED
106b1b: e8 c4 07 00 00 call 1072e4 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
106b20: e8 2f a6 00 00 call 111154 <__errno> <== NOT EXECUTED
106b25: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
106b2b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106b2e: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106b31: eb 34 jmp 106b67 <IMFS_initialize_support+0xbb><== NOT EXECUTED
}
temp_mt_entry->fs_info = fs_info;
106b33: 89 43 34 mov %eax,0x34(%ebx)
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
106b36: 8b 0d 90 3d 12 00 mov 0x123d90,%ecx
106b3c: 89 08 mov %ecx,(%eax)
106b3e: 41 inc %ecx
106b3f: 89 0d 90 3d 12 00 mov %ecx,0x123d90
fs_info->ino_count = 1;
106b45: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
fs_info->memfile_handlers = memfile_handlers;
106b4c: 8b 4d 10 mov 0x10(%ebp),%ecx
106b4f: 89 48 08 mov %ecx,0x8(%eax)
fs_info->directory_handlers = directory_handlers;
106b52: 8b 4d 14 mov 0x14(%ebp),%ecx
106b55: 89 48 0c mov %ecx,0xc(%eax)
fs_info->fifo_handlers = fifo_handlers;
106b58: 8b 4d 18 mov 0x18(%ebp),%ecx
106b5b: 89 48 10 mov %ecx,0x10(%eax)
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
106b5e: c7 42 38 01 00 00 00 movl $0x1,0x38(%edx)
return 0;
106b65: 31 c0 xor %eax,%eax
}
106b67: 8d 65 f4 lea -0xc(%ebp),%esp
106b6a: 5b pop %ebx
106b6b: 5e pop %esi
106b6c: 5f pop %edi
106b6d: c9 leave
106b6e: c3 ret
00106b70 <IMFS_link>:
int IMFS_link(
rtems_filesystem_location_info_t *to_loc, /* IN */
rtems_filesystem_location_info_t *parent_loc, /* IN */
const char *token /* IN */
)
{
106b70: 55 push %ebp
106b71: 89 e5 mov %esp,%ebp
106b73: 57 push %edi
106b74: 53 push %ebx
106b75: 83 ec 50 sub $0x50,%esp
106b78: 8b 55 10 mov 0x10(%ebp),%edx
int i;
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
106b7b: 8b 45 08 mov 0x8(%ebp),%eax
106b7e: 8b 00 mov (%eax),%eax
106b80: 89 45 d8 mov %eax,-0x28(%ebp)
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
106b83: 66 83 78 34 07 cmpw $0x7,0x34(%eax)
106b88: 76 0d jbe 106b97 <IMFS_link+0x27>
rtems_set_errno_and_return_minus_one( EMLINK );
106b8a: e8 c5 a5 00 00 call 111154 <__errno>
106b8f: c7 00 1f 00 00 00 movl $0x1f,(%eax)
106b95: eb 43 jmp 106bda <IMFS_link+0x6a>
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( token, strlen( token ), new_name, &i );
106b97: 31 c0 xor %eax,%eax
106b99: 83 c9 ff or $0xffffffff,%ecx
106b9c: 89 d7 mov %edx,%edi
106b9e: f2 ae repnz scas %es:(%edi),%al
106ba0: f7 d1 not %ecx
106ba2: 49 dec %ecx
106ba3: 8d 45 f4 lea -0xc(%ebp),%eax
106ba6: 50 push %eax
106ba7: 8d 5d b7 lea -0x49(%ebp),%ebx
106baa: 53 push %ebx
106bab: 51 push %ecx
106bac: 52 push %edx
106bad: e8 5a 71 00 00 call 10dd0c <IMFS_get_token>
new_node = IMFS_create_node(
parent_loc,
IMFS_HARD_LINK,
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
106bb2: 8d 45 d8 lea -0x28(%ebp),%eax
* 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.
*/
new_node = IMFS_create_node(
106bb5: 89 04 24 mov %eax,(%esp)
106bb8: 68 ff a1 00 00 push $0xa1ff
106bbd: 53 push %ebx
106bbe: 6a 03 push $0x3
106bc0: ff 75 0c pushl 0xc(%ebp)
106bc3: e8 13 69 00 00 call 10d4db <IMFS_create_node>
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if ( !new_node )
106bc8: 83 c4 20 add $0x20,%esp
106bcb: 85 c0 test %eax,%eax
106bcd: 75 10 jne 106bdf <IMFS_link+0x6f> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOMEM );
106bcf: e8 80 a5 00 00 call 111154 <__errno> <== NOT EXECUTED
106bd4: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
106bda: 83 c8 ff or $0xffffffff,%eax
106bdd: eb 22 jmp 106c01 <IMFS_link+0x91>
/*
* Increment the link count of the node being pointed to.
*/
info.hard_link.link_node->st_nlink++;
106bdf: 8b 45 d8 mov -0x28(%ebp),%eax
106be2: 66 ff 40 34 incw 0x34(%eax)
IMFS_update_ctime( info.hard_link.link_node );
106be6: 50 push %eax
106be7: 50 push %eax
106be8: 6a 00 push $0x0
106bea: 8d 45 ec lea -0x14(%ebp),%eax
106bed: 50 push %eax
106bee: e8 69 07 00 00 call 10735c <gettimeofday>
106bf3: 8b 55 ec mov -0x14(%ebp),%edx
106bf6: 8b 45 d8 mov -0x28(%ebp),%eax
106bf9: 89 50 48 mov %edx,0x48(%eax)
return 0;
106bfc: 83 c4 10 add $0x10,%esp
106bff: 31 c0 xor %eax,%eax
}
106c01: 8d 65 f8 lea -0x8(%ebp),%esp
106c04: 5b pop %ebx
106c05: 5f pop %edi
106c06: c9 leave
106c07: c3 ret
0010feb4 <IMFS_memfile_addblock>:
MEMFILE_STATIC int IMFS_memfile_addblock(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
10feb4: 55 push %ebp
10feb5: 89 e5 mov %esp,%ebp
10feb7: 53 push %ebx
10feb8: 83 ec 08 sub $0x8,%esp
#if defined(RTEMS_DEBUG)
assert( the_jnode );
assert( the_jnode->type == IMFS_MEMORY_FILE );
#endif
block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
10febb: 6a 01 push $0x1
10febd: ff 75 0c pushl 0xc(%ebp)
10fec0: ff 75 08 pushl 0x8(%ebp)
10fec3: e8 cc fc ff ff call 10fb94 <IMFS_memfile_get_block_pointer>
10fec8: 89 c3 mov %eax,%ebx
if ( *block_entry_ptr )
10feca: 83 c4 10 add $0x10,%esp
return 0;
10fecd: 31 c0 xor %eax,%eax
assert( the_jnode );
assert( the_jnode->type == IMFS_MEMORY_FILE );
#endif
block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
if ( *block_entry_ptr )
10fecf: 83 3b 00 cmpl $0x0,(%ebx)
10fed2: 75 14 jne 10fee8 <IMFS_memfile_addblock+0x34>
#if 0
fprintf(stdout, "%d %p", block, block_entry_ptr );
fflush(stdout);
#endif
memory = memfile_alloc_block();
10fed4: e8 99 fc ff ff call 10fb72 <memfile_alloc_block>
10fed9: 89 c2 mov %eax,%edx
if ( !memory )
return 1;
10fedb: b8 01 00 00 00 mov $0x1,%eax
fprintf(stdout, "%d %p", block, block_entry_ptr );
fflush(stdout);
#endif
memory = memfile_alloc_block();
if ( !memory )
10fee0: 85 d2 test %edx,%edx
10fee2: 74 04 je 10fee8 <IMFS_memfile_addblock+0x34><== NEVER TAKEN
return 1;
*block_entry_ptr = memory;
10fee4: 89 13 mov %edx,(%ebx)
return 0;
10fee6: 30 c0 xor %al,%al
}
10fee8: 8b 5d fc mov -0x4(%ebp),%ebx
10feeb: c9 leave
10feec: c3 ret
00110082 <IMFS_memfile_extend>:
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
110082: 55 push %ebp
110083: 89 e5 mov %esp,%ebp
110085: 57 push %edi
110086: 56 push %esi
110087: 53 push %ebx
110088: 83 ec 2c sub $0x2c,%esp
11008b: 8b 7d 08 mov 0x8(%ebp),%edi
11008e: 8b 5d 0c mov 0xc(%ebp),%ebx
110091: 8b 75 10 mov 0x10(%ebp),%esi
#if defined(RTEMS_DEBUG)
assert( the_jnode );
assert( the_jnode->type == IMFS_MEMORY_FILE );
#endif
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
110094: a1 8c 3d 12 00 mov 0x123d8c,%eax
110099: 89 c1 mov %eax,%ecx
11009b: c1 e9 02 shr $0x2,%ecx
11009e: 8d 51 01 lea 0x1(%ecx),%edx
1100a1: 0f af d1 imul %ecx,%edx
1100a4: 42 inc %edx
1100a5: 0f af d1 imul %ecx,%edx
1100a8: 4a dec %edx
1100a9: 0f af d0 imul %eax,%edx
1100ac: 83 fe 00 cmp $0x0,%esi
1100af: 7c 16 jl 1100c7 <IMFS_memfile_extend+0x45><== NEVER TAKEN
1100b1: 7f 04 jg 1100b7 <IMFS_memfile_extend+0x35><== NEVER TAKEN
1100b3: 39 d3 cmp %edx,%ebx
1100b5: 72 10 jb 1100c7 <IMFS_memfile_extend+0x45>
rtems_set_errno_and_return_minus_one( EINVAL );
1100b7: e8 98 10 00 00 call 111154 <__errno>
1100bc: c7 00 16 00 00 00 movl $0x16,(%eax)
1100c2: e9 92 00 00 00 jmp 110159 <IMFS_memfile_extend+0xd7>
if ( new_length <= the_jnode->info.file.size )
1100c7: 8b 57 50 mov 0x50(%edi),%edx
1100ca: 8b 4f 54 mov 0x54(%edi),%ecx
1100cd: 89 55 e0 mov %edx,-0x20(%ebp)
1100d0: 89 4d e4 mov %ecx,-0x1c(%ebp)
1100d3: 39 ce cmp %ecx,%esi
1100d5: 0f 8c 8f 00 00 00 jl 11016a <IMFS_memfile_extend+0xe8><== NEVER TAKEN
1100db: 7f 08 jg 1100e5 <IMFS_memfile_extend+0x63><== NEVER TAKEN
1100dd: 39 d3 cmp %edx,%ebx
1100df: 0f 86 85 00 00 00 jbe 11016a <IMFS_memfile_extend+0xe8>
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
1100e5: 89 45 d8 mov %eax,-0x28(%ebp)
1100e8: 89 c1 mov %eax,%ecx
1100ea: c1 f9 1f sar $0x1f,%ecx
1100ed: 89 4d dc mov %ecx,-0x24(%ebp)
1100f0: ff 75 dc pushl -0x24(%ebp)
1100f3: ff 75 d8 pushl -0x28(%ebp)
1100f6: 56 push %esi
1100f7: 53 push %ebx
1100f8: e8 0b c2 00 00 call 11c308 <__divdi3>
1100fd: 83 c4 10 add $0x10,%esp
110100: 89 45 d4 mov %eax,-0x2c(%ebp)
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
110103: ff 75 dc pushl -0x24(%ebp)
110106: ff 75 d8 pushl -0x28(%ebp)
110109: ff 75 e4 pushl -0x1c(%ebp)
11010c: ff 75 e0 pushl -0x20(%ebp)
11010f: e8 f4 c1 00 00 call 11c308 <__divdi3>
110114: 83 c4 10 add $0x10,%esp
110117: 89 45 e0 mov %eax,-0x20(%ebp)
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
11011a: 89 c2 mov %eax,%edx
11011c: eb 41 jmp 11015f <IMFS_memfile_extend+0xdd>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
11011e: 51 push %ecx
11011f: 51 push %ecx
110120: 52 push %edx
110121: 57 push %edi
110122: 89 55 d0 mov %edx,-0x30(%ebp)
110125: e8 8a fd ff ff call 10feb4 <IMFS_memfile_addblock>
11012a: 83 c4 10 add $0x10,%esp
11012d: 85 c0 test %eax,%eax
11012f: 8b 55 d0 mov -0x30(%ebp),%edx
110132: 74 2a je 11015e <IMFS_memfile_extend+0xdc><== ALWAYS TAKEN
110134: eb 13 jmp 110149 <IMFS_memfile_extend+0xc7><== NOT EXECUTED
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
110136: 50 push %eax <== NOT EXECUTED
110137: 50 push %eax <== NOT EXECUTED
110138: 52 push %edx <== NOT EXECUTED
110139: 57 push %edi <== NOT EXECUTED
11013a: 89 55 d0 mov %edx,-0x30(%ebp) <== NOT EXECUTED
11013d: e8 0b ff ff ff call 11004d <IMFS_memfile_remove_block><== NOT EXECUTED
* 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-- ) {
110142: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED
110145: 4a dec %edx <== NOT EXECUTED
110146: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
110149: 3b 55 e0 cmp -0x20(%ebp),%edx <== NOT EXECUTED
11014c: 73 e8 jae 110136 <IMFS_memfile_extend+0xb4><== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
11014e: e8 01 10 00 00 call 111154 <__errno> <== NOT EXECUTED
110153: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED
110159: 83 c8 ff or $0xffffffff,%eax
11015c: eb 0e jmp 11016c <IMFS_memfile_extend+0xea>
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
11015e: 42 inc %edx
11015f: 3b 55 d4 cmp -0x2c(%ebp),%edx
110162: 76 ba jbe 11011e <IMFS_memfile_extend+0x9c>
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
110164: 89 5f 50 mov %ebx,0x50(%edi)
110167: 89 77 54 mov %esi,0x54(%edi)
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( new_length <= the_jnode->info.file.size )
return 0;
11016a: 31 c0 xor %eax,%eax
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
return 0;
}
11016c: 8d 65 f4 lea -0xc(%ebp),%esp
11016f: 5b pop %ebx
110170: 5e pop %esi
110171: 5f pop %edi
110172: c9 leave
110173: c3 ret
0010fb94 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
10fb94: 55 push %ebp
10fb95: 89 e5 mov %esp,%ebp
10fb97: 57 push %edi
10fb98: 56 push %esi
10fb99: 53 push %ebx
10fb9a: 83 ec 1c sub $0x1c,%esp
10fb9d: 8b 75 08 mov 0x8(%ebp),%esi
10fba0: 8b 7d 0c mov 0xc(%ebp),%edi
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
10fba3: 8b 0d 8c 3d 12 00 mov 0x123d8c,%ecx
10fba9: c1 e9 02 shr $0x2,%ecx
10fbac: 8d 41 ff lea -0x1(%ecx),%eax
10fbaf: 39 c7 cmp %eax,%edi
10fbb1: 77 40 ja 10fbf3 <IMFS_memfile_get_block_pointer+0x5f>
p = info->indirect;
10fbb3: 8b 46 58 mov 0x58(%esi),%eax
if ( malloc_it ) {
10fbb6: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10fbba: 74 25 je 10fbe1 <IMFS_memfile_get_block_pointer+0x4d>
if ( !p ) {
10fbbc: 85 c0 test %eax,%eax
10fbbe: 75 12 jne 10fbd2 <IMFS_memfile_get_block_pointer+0x3e>
p = memfile_alloc_block();
10fbc0: e8 ad ff ff ff call 10fb72 <memfile_alloc_block>
if ( !p )
return 0;
10fbc5: 31 db xor %ebx,%ebx
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
10fbc7: 85 c0 test %eax,%eax
10fbc9: 0f 84 04 01 00 00 je 10fcd3 <IMFS_memfile_get_block_pointer+0x13f><== NEVER TAKEN
return 0;
info->indirect = p;
10fbcf: 89 46 58 mov %eax,0x58(%esi)
}
return &info->indirect[ my_block ];
10fbd2: 8d 1c bd 00 00 00 00 lea 0x0(,%edi,4),%ebx
10fbd9: 03 5e 58 add 0x58(%esi),%ebx
10fbdc: e9 f2 00 00 00 jmp 10fcd3 <IMFS_memfile_get_block_pointer+0x13f>
}
if ( !p )
return 0;
10fbe1: 31 db xor %ebx,%ebx
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
10fbe3: 85 c0 test %eax,%eax
10fbe5: 0f 84 e8 00 00 00 je 10fcd3 <IMFS_memfile_get_block_pointer+0x13f><== NEVER TAKEN
return 0;
return &info->indirect[ my_block ];
10fbeb: 8d 1c b8 lea (%eax,%edi,4),%ebx
10fbee: e9 e0 00 00 00 jmp 10fcd3 <IMFS_memfile_get_block_pointer+0x13f>
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
10fbf3: 8d 41 01 lea 0x1(%ecx),%eax
10fbf6: 0f af c1 imul %ecx,%eax
10fbf9: 8d 50 ff lea -0x1(%eax),%edx
10fbfc: 39 d7 cmp %edx,%edi
10fbfe: 77 47 ja 10fc47 <IMFS_memfile_get_block_pointer+0xb3>
#if 0
fprintf(stdout, "(d %d) ", block );
fflush(stdout);
#endif
my_block -= FIRST_DOUBLY_INDIRECT;
10fc00: 29 cf sub %ecx,%edi
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
10fc02: 89 f8 mov %edi,%eax
10fc04: 31 d2 xor %edx,%edx
10fc06: f7 f1 div %ecx
10fc08: 89 55 e4 mov %edx,-0x1c(%ebp)
10fc0b: 89 c7 mov %eax,%edi
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
10fc0d: 8b 46 5c mov 0x5c(%esi),%eax
if ( malloc_it ) {
10fc10: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10fc14: 74 1b je 10fc31 <IMFS_memfile_get_block_pointer+0x9d>
if ( !p ) {
10fc16: 85 c0 test %eax,%eax
10fc18: 75 12 jne 10fc2c <IMFS_memfile_get_block_pointer+0x98>
p = memfile_alloc_block();
10fc1a: e8 53 ff ff ff call 10fb72 <memfile_alloc_block>
if ( !p )
return 0;
10fc1f: 31 db xor %ebx,%ebx
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
10fc21: 85 c0 test %eax,%eax
10fc23: 0f 84 aa 00 00 00 je 10fcd3 <IMFS_memfile_get_block_pointer+0x13f><== NEVER TAKEN
return 0;
info->doubly_indirect = p;
10fc29: 89 46 5c mov %eax,0x5c(%esi)
}
p1 = (block_p *)p[ doubly ];
10fc2c: 8d 34 b8 lea (%eax,%edi,4),%esi
10fc2f: eb 6c jmp 10fc9d <IMFS_memfile_get_block_pointer+0x109>
return (block_p *)&p1[ singly ];
}
if ( !p )
return 0;
10fc31: 31 db xor %ebx,%ebx
}
return (block_p *)&p1[ singly ];
}
if ( !p )
10fc33: 85 c0 test %eax,%eax
10fc35: 0f 84 98 00 00 00 je 10fcd3 <IMFS_memfile_get_block_pointer+0x13f><== NEVER TAKEN
return 0;
p = (block_p *)p[ doubly ];
10fc3b: 8b 04 b8 mov (%eax,%edi,4),%eax
if ( !p )
10fc3e: 85 c0 test %eax,%eax
10fc40: 75 6e jne 10fcb0 <IMFS_memfile_get_block_pointer+0x11c><== ALWAYS TAKEN
10fc42: e9 8c 00 00 00 jmp 10fcd3 <IMFS_memfile_get_block_pointer+0x13f><== NOT EXECUTED
#endif
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
10fc47: 8d 50 01 lea 0x1(%eax),%edx
10fc4a: 0f af d1 imul %ecx,%edx
10fc4d: 4a dec %edx
/*
* This means the requested block number is out of range.
*/
return 0;
10fc4e: 31 db xor %ebx,%ebx
#endif
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
10fc50: 39 d7 cmp %edx,%edi
10fc52: 77 7f ja 10fcd3 <IMFS_memfile_get_block_pointer+0x13f><== NEVER TAKEN
my_block -= FIRST_TRIPLY_INDIRECT;
10fc54: 29 c7 sub %eax,%edi
10fc56: 89 f8 mov %edi,%eax
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
10fc58: 31 d2 xor %edx,%edx
10fc5a: f7 f1 div %ecx
10fc5c: 89 55 e4 mov %edx,-0x1c(%ebp)
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
10fc5f: 31 d2 xor %edx,%edx
10fc61: f7 f1 div %ecx
10fc63: 89 55 e0 mov %edx,-0x20(%ebp)
10fc66: 89 c7 mov %eax,%edi
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
p = info->triply_indirect;
10fc68: 8b 46 60 mov 0x60(%esi),%eax
if ( malloc_it ) {
10fc6b: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10fc6f: 74 47 je 10fcb8 <IMFS_memfile_get_block_pointer+0x124>
if ( !p ) {
10fc71: 85 c0 test %eax,%eax
10fc73: 75 0c jne 10fc81 <IMFS_memfile_get_block_pointer+0xed>
p = memfile_alloc_block();
10fc75: e8 f8 fe ff ff call 10fb72 <memfile_alloc_block>
if ( !p )
10fc7a: 85 c0 test %eax,%eax
10fc7c: 74 55 je 10fcd3 <IMFS_memfile_get_block_pointer+0x13f><== NEVER TAKEN
return 0;
info->triply_indirect = p;
10fc7e: 89 46 60 mov %eax,0x60(%esi)
}
p1 = (block_p *) p[ triply ];
10fc81: 8d 34 b8 lea (%eax,%edi,4),%esi
10fc84: 8b 06 mov (%esi),%eax
if ( !p1 ) {
10fc86: 85 c0 test %eax,%eax
10fc88: 75 0d jne 10fc97 <IMFS_memfile_get_block_pointer+0x103>
p1 = memfile_alloc_block();
10fc8a: e8 e3 fe ff ff call 10fb72 <memfile_alloc_block>
if ( !p1 )
return 0;
10fc8f: 31 db xor %ebx,%ebx
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
10fc91: 85 c0 test %eax,%eax
10fc93: 74 3e je 10fcd3 <IMFS_memfile_get_block_pointer+0x13f><== NEVER TAKEN
return 0;
p[ triply ] = (block_p) p1;
10fc95: 89 06 mov %eax,(%esi)
}
p2 = (block_p *)p1[ doubly ];
10fc97: 8b 55 e0 mov -0x20(%ebp),%edx
10fc9a: 8d 34 90 lea (%eax,%edx,4),%esi
10fc9d: 8b 06 mov (%esi),%eax
if ( !p2 ) {
10fc9f: 85 c0 test %eax,%eax
10fca1: 75 0d jne 10fcb0 <IMFS_memfile_get_block_pointer+0x11c>
p2 = memfile_alloc_block();
10fca3: e8 ca fe ff ff call 10fb72 <memfile_alloc_block>
if ( !p2 )
return 0;
10fca8: 31 db xor %ebx,%ebx
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
if ( !p2 )
10fcaa: 85 c0 test %eax,%eax
10fcac: 74 25 je 10fcd3 <IMFS_memfile_get_block_pointer+0x13f><== NEVER TAKEN
return 0;
p1[ doubly ] = (block_p) p2;
10fcae: 89 06 mov %eax,(%esi)
}
return (block_p *)&p2[ singly ];
10fcb0: 8b 55 e4 mov -0x1c(%ebp),%edx
10fcb3: 8d 1c 90 lea (%eax,%edx,4),%ebx
10fcb6: eb 1b jmp 10fcd3 <IMFS_memfile_get_block_pointer+0x13f>
}
if ( !p )
10fcb8: 85 c0 test %eax,%eax
10fcba: 74 17 je 10fcd3 <IMFS_memfile_get_block_pointer+0x13f><== NEVER TAKEN
#if 0
fprintf(stdout, "(t %d %d %d %d %d) ", block, my_block, triply, doubly, singly );
fflush(stdout);
#endif
p1 = (block_p *) p[ triply ];
10fcbc: 8b 04 b8 mov (%eax,%edi,4),%eax
if ( !p1 )
10fcbf: 85 c0 test %eax,%eax
10fcc1: 74 10 je 10fcd3 <IMFS_memfile_get_block_pointer+0x13f><== NEVER TAKEN
p2 = (block_p *)p1[ doubly ];
if ( !p )
return 0;
return (block_p *)&p2[ singly ];
10fcc3: 8b 55 e4 mov -0x1c(%ebp),%edx
10fcc6: 8d 1c 95 00 00 00 00 lea 0x0(,%edx,4),%ebx
10fccd: 8b 55 e0 mov -0x20(%ebp),%edx
10fcd0: 03 1c 90 add (%eax,%edx,4),%ebx
/*
* This means the requested block number is out of range.
*/
return 0;
}
10fcd3: 89 d8 mov %ebx,%eax
10fcd5: 83 c4 1c add $0x1c,%esp
10fcd8: 5b pop %ebx
10fcd9: 5e pop %esi
10fcda: 5f pop %edi
10fcdb: c9 leave
10fcdc: c3 ret
0010fcdd <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
10fcdd: 55 push %ebp
10fcde: 89 e5 mov %esp,%ebp
10fce0: 57 push %edi
10fce1: 56 push %esi
10fce2: 53 push %ebx
10fce3: 83 ec 3c sub $0x3c,%esp
10fce6: 8b 75 0c mov 0xc(%ebp),%esi
10fce9: 8b 7d 10 mov 0x10(%ebp),%edi
/*
* Error checks on arguments
*/
if ( !dest )
10fcec: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10fcf0: 74 06 je 10fcf8 <IMFS_memfile_read+0x1b><== NEVER TAKEN
/*
* If there is nothing to read, then quick exit.
*/
my_length = length;
if ( !my_length )
10fcf2: 83 7d 18 00 cmpl $0x0,0x18(%ebp)
10fcf6: 75 13 jne 10fd0b <IMFS_memfile_read+0x2e><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10fcf8: e8 57 14 00 00 call 111154 <__errno> <== NOT EXECUTED
10fcfd: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
10fd03: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
10fd06: e9 80 01 00 00 jmp 10fe8b <IMFS_memfile_read+0x1ae><== NOT EXECUTED
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
if (the_jnode->type == IMFS_LINEAR_FILE) {
10fd0b: 8b 45 08 mov 0x8(%ebp),%eax
10fd0e: 83 78 4c 06 cmpl $0x6,0x4c(%eax)
10fd12: 75 42 jne 10fd56 <IMFS_memfile_read+0x79>
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
10fd14: 8b 50 58 mov 0x58(%eax),%edx
10fd17: 89 55 cc mov %edx,-0x34(%ebp)
if (my_length > (the_jnode->info.linearfile.size - start))
10fd1a: 8b 48 50 mov 0x50(%eax),%ecx
10fd1d: 8b 58 54 mov 0x54(%eax),%ebx
10fd20: 89 c8 mov %ecx,%eax
10fd22: 89 da mov %ebx,%edx
10fd24: 29 f0 sub %esi,%eax
10fd26: 19 fa sbb %edi,%edx
10fd28: 89 45 d0 mov %eax,-0x30(%ebp)
10fd2b: 89 55 d4 mov %edx,-0x2c(%ebp)
10fd2e: 31 c0 xor %eax,%eax
10fd30: 39 d0 cmp %edx,%eax
10fd32: 7c 10 jl 10fd44 <IMFS_memfile_read+0x67><== NEVER TAKEN
10fd34: 7f 08 jg 10fd3e <IMFS_memfile_read+0x61><== NEVER TAKEN
10fd36: 8b 55 d0 mov -0x30(%ebp),%edx
10fd39: 39 55 18 cmp %edx,0x18(%ebp)
10fd3c: 76 06 jbe 10fd44 <IMFS_memfile_read+0x67><== NEVER TAKEN
my_length = the_jnode->info.linearfile.size - start;
10fd3e: 89 ca mov %ecx,%edx
10fd40: 29 f2 sub %esi,%edx
10fd42: eb 03 jmp 10fd47 <IMFS_memfile_read+0x6a>
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
10fd44: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED
my_length = the_jnode->info.linearfile.size - start;
memcpy(dest, &file_ptr[start], my_length);
10fd47: 03 75 cc add -0x34(%ebp),%esi
10fd4a: 8b 7d 14 mov 0x14(%ebp),%edi
10fd4d: 89 d1 mov %edx,%ecx
10fd4f: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10fd51: e9 16 01 00 00 jmp 10fe6c <IMFS_memfile_read+0x18f>
/*
* 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;
10fd56: 89 f0 mov %esi,%eax
if ( last_byte > the_jnode->info.file.size )
10fd58: 8b 55 08 mov 0x8(%ebp),%edx
10fd5b: 8b 5a 50 mov 0x50(%edx),%ebx
/*
* 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;
10fd5e: 8b 4d 18 mov 0x18(%ebp),%ecx
10fd61: 01 f1 add %esi,%ecx
10fd63: 89 4d d0 mov %ecx,-0x30(%ebp)
if ( last_byte > the_jnode->info.file.size )
10fd66: 31 c9 xor %ecx,%ecx
10fd68: 3b 4a 54 cmp 0x54(%edx),%ecx
10fd6b: 7c 0e jl 10fd7b <IMFS_memfile_read+0x9e><== NEVER TAKEN
10fd6d: 7f 05 jg 10fd74 <IMFS_memfile_read+0x97><== NEVER TAKEN
10fd6f: 39 5d d0 cmp %ebx,-0x30(%ebp)
10fd72: 76 07 jbe 10fd7b <IMFS_memfile_read+0x9e>
my_length = the_jnode->info.file.size - start;
10fd74: 29 c3 sub %eax,%ebx
10fd76: 89 5d d0 mov %ebx,-0x30(%ebp)
10fd79: eb 06 jmp 10fd81 <IMFS_memfile_read+0xa4>
* 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;
if ( last_byte > the_jnode->info.file.size )
10fd7b: 8b 45 18 mov 0x18(%ebp),%eax
10fd7e: 89 45 d0 mov %eax,-0x30(%ebp)
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
10fd81: 8b 15 8c 3d 12 00 mov 0x123d8c,%edx
10fd87: 89 55 c4 mov %edx,-0x3c(%ebp)
10fd8a: 89 d0 mov %edx,%eax
10fd8c: 99 cltd
10fd8d: 89 d3 mov %edx,%ebx
10fd8f: 52 push %edx
10fd90: 50 push %eax
10fd91: 57 push %edi
10fd92: 56 push %esi
10fd93: 89 45 c0 mov %eax,-0x40(%ebp)
10fd96: e8 cd c6 00 00 call 11c468 <__moddi3>
10fd9b: 83 c4 10 add $0x10,%esp
10fd9e: 89 45 cc mov %eax,-0x34(%ebp)
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
10fda1: 8b 4d c0 mov -0x40(%ebp),%ecx
10fda4: 53 push %ebx
10fda5: 51 push %ecx
10fda6: 57 push %edi
10fda7: 56 push %esi
10fda8: e8 5b c5 00 00 call 11c308 <__divdi3>
10fdad: 83 c4 10 add $0x10,%esp
10fdb0: 89 c3 mov %eax,%ebx
if ( start_offset ) {
10fdb2: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
10fdb6: 74 3d je 10fdf5 <IMFS_memfile_read+0x118>
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 );
10fdb8: 57 push %edi
10fdb9: 6a 00 push $0x0
10fdbb: 50 push %eax
10fdbc: ff 75 08 pushl 0x8(%ebp)
10fdbf: e8 d0 fd ff ff call 10fb94 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
10fdc4: 83 c4 10 add $0x10,%esp
return copied;
10fdc7: 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 )
10fdc9: 85 c0 test %eax,%eax
10fdcb: 0f 84 ba 00 00 00 je 10fe8b <IMFS_memfile_read+0x1ae><== NEVER TAKEN
*/
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;
10fdd1: 8b 4d c4 mov -0x3c(%ebp),%ecx
10fdd4: 2b 4d cc sub -0x34(%ebp),%ecx
10fdd7: 8b 55 d0 mov -0x30(%ebp),%edx
10fdda: 39 ca cmp %ecx,%edx
10fddc: 76 02 jbe 10fde0 <IMFS_memfile_read+0x103>
10fdde: 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 );
10fde0: 8b 75 cc mov -0x34(%ebp),%esi
10fde3: 03 30 add (%eax),%esi
dest += to_copy;
10fde5: 8b 7d 14 mov 0x14(%ebp),%edi
10fde8: 89 d1 mov %edx,%ecx
10fdea: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10fdec: 89 7d cc mov %edi,-0x34(%ebp)
block++;
10fdef: 43 inc %ebx
my_length -= to_copy;
10fdf0: 29 55 d0 sub %edx,-0x30(%ebp)
10fdf3: eb 08 jmp 10fdfd <IMFS_memfile_read+0x120>
* 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 ) {
10fdf5: 8b 45 14 mov 0x14(%ebp),%eax
10fdf8: 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;
10fdfb: 31 d2 xor %edx,%edx
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
10fdfd: 8b 0d 8c 3d 12 00 mov 0x123d8c,%ecx
10fe03: 89 4d c8 mov %ecx,-0x38(%ebp)
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
10fe06: eb 2f jmp 10fe37 <IMFS_memfile_read+0x15a>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
10fe08: 56 push %esi
10fe09: 6a 00 push $0x0
10fe0b: 53 push %ebx
10fe0c: ff 75 08 pushl 0x8(%ebp)
10fe0f: 89 55 c0 mov %edx,-0x40(%ebp)
10fe12: e8 7d fd ff ff call 10fb94 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
10fe17: 83 c4 10 add $0x10,%esp
10fe1a: 85 c0 test %eax,%eax
10fe1c: 8b 55 c0 mov -0x40(%ebp),%edx
10fe1f: 74 6a je 10fe8b <IMFS_memfile_read+0x1ae><== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
10fe21: 8b 30 mov (%eax),%esi
10fe23: 8b 7d cc mov -0x34(%ebp),%edi
10fe26: 8b 4d c8 mov -0x38(%ebp),%ecx
10fe29: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
dest += to_copy;
10fe2b: 89 7d cc mov %edi,-0x34(%ebp)
block++;
10fe2e: 43 inc %ebx
my_length -= to_copy;
10fe2f: 8b 7d c8 mov -0x38(%ebp),%edi
10fe32: 29 7d d0 sub %edi,-0x30(%ebp)
copied += to_copy;
10fe35: 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 ) {
10fe37: 8b 45 d0 mov -0x30(%ebp),%eax
10fe3a: 3b 05 8c 3d 12 00 cmp 0x123d8c,%eax
10fe40: 73 c6 jae 10fe08 <IMFS_memfile_read+0x12b>
#if defined(RTEMS_DEBUG)
assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
#endif
if ( my_length ) {
10fe42: 85 c0 test %eax,%eax
10fe44: 74 26 je 10fe6c <IMFS_memfile_read+0x18f>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
10fe46: 51 push %ecx
10fe47: 6a 00 push $0x0
10fe49: 53 push %ebx
10fe4a: ff 75 08 pushl 0x8(%ebp)
10fe4d: 89 55 c0 mov %edx,-0x40(%ebp)
10fe50: e8 3f fd ff ff call 10fb94 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
10fe55: 83 c4 10 add $0x10,%esp
10fe58: 85 c0 test %eax,%eax
10fe5a: 8b 55 c0 mov -0x40(%ebp),%edx
10fe5d: 74 2c je 10fe8b <IMFS_memfile_read+0x1ae><== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
10fe5f: 8b 30 mov (%eax),%esi
10fe61: 8b 7d cc mov -0x34(%ebp),%edi
10fe64: 8b 4d d0 mov -0x30(%ebp),%ecx
10fe67: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
copied += my_length;
10fe69: 03 55 d0 add -0x30(%ebp),%edx
}
IMFS_update_atime( the_jnode );
10fe6c: 50 push %eax
10fe6d: 50 push %eax
10fe6e: 6a 00 push $0x0
10fe70: 8d 45 e0 lea -0x20(%ebp),%eax
10fe73: 50 push %eax
10fe74: 89 55 c0 mov %edx,-0x40(%ebp)
10fe77: e8 e0 74 ff ff call 10735c <gettimeofday>
10fe7c: 8b 45 e0 mov -0x20(%ebp),%eax
10fe7f: 8b 4d 08 mov 0x8(%ebp),%ecx
10fe82: 89 41 40 mov %eax,0x40(%ecx)
return copied;
10fe85: 8b 55 c0 mov -0x40(%ebp),%edx
10fe88: 83 c4 10 add $0x10,%esp
}
10fe8b: 89 d0 mov %edx,%eax
10fe8d: 8d 65 f4 lea -0xc(%ebp),%esp
10fe90: 5b pop %ebx
10fe91: 5e pop %esi
10fe92: 5f pop %edi
10fe93: c9 leave
10fe94: c3 ret
0010ff57 <IMFS_memfile_remove>:
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
10ff57: 55 push %ebp
10ff58: 89 e5 mov %esp,%ebp
10ff5a: 57 push %edi
10ff5b: 56 push %esi
10ff5c: 53 push %ebx
10ff5d: 83 ec 1c sub $0x1c,%esp
10ff60: 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;
10ff63: 8b 35 8c 3d 12 00 mov 0x123d8c,%esi
10ff69: c1 ee 02 shr $0x2,%esi
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
10ff6c: 83 7b 58 00 cmpl $0x0,0x58(%ebx)
10ff70: 74 0f je 10ff81 <IMFS_memfile_remove+0x2a>
memfile_free_blocks_in_table( &info->indirect, to_free );
10ff72: 57 push %edi
10ff73: 57 push %edi
10ff74: 56 push %esi
10ff75: 8d 43 58 lea 0x58(%ebx),%eax
10ff78: 50 push %eax
10ff79: e8 88 ff ff ff call 10ff06 <memfile_free_blocks_in_table>
10ff7e: 83 c4 10 add $0x10,%esp
}
if ( info->doubly_indirect ) {
10ff81: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx)
10ff85: 74 3e je 10ffc5 <IMFS_memfile_remove+0x6e><== ALWAYS TAKEN
10ff87: 31 ff xor %edi,%edi <== NOT EXECUTED
10ff89: eb 1f jmp 10ffaa <IMFS_memfile_remove+0x53><== NOT EXECUTED
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
10ff8b: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED
10ff8e: 8d 14 bd 00 00 00 00 lea 0x0(,%edi,4),%edx <== NOT EXECUTED
10ff95: 83 3c b8 00 cmpl $0x0,(%eax,%edi,4) <== NOT EXECUTED
10ff99: 74 0e je 10ffa9 <IMFS_memfile_remove+0x52><== NOT EXECUTED
memfile_free_blocks_in_table(
10ff9b: 51 push %ecx <== NOT EXECUTED
10ff9c: 51 push %ecx <== NOT EXECUTED
10ff9d: 56 push %esi <== NOT EXECUTED
10ff9e: 01 d0 add %edx,%eax <== NOT EXECUTED
10ffa0: 50 push %eax <== NOT EXECUTED
10ffa1: e8 60 ff ff ff call 10ff06 <memfile_free_blocks_in_table><== NOT EXECUTED
10ffa6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
10ffa9: 47 inc %edi <== NOT EXECUTED
10ffaa: a1 8c 3d 12 00 mov 0x123d8c,%eax <== NOT EXECUTED
10ffaf: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED
10ffb2: 39 c7 cmp %eax,%edi <== NOT EXECUTED
10ffb4: 72 d5 jb 10ff8b <IMFS_memfile_remove+0x34><== NOT EXECUTED
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 );
10ffb6: 57 push %edi <== NOT EXECUTED
10ffb7: 57 push %edi <== NOT EXECUTED
10ffb8: 56 push %esi <== NOT EXECUTED
10ffb9: 8d 43 5c lea 0x5c(%ebx),%eax <== NOT EXECUTED
10ffbc: 50 push %eax <== NOT EXECUTED
10ffbd: e8 44 ff ff ff call 10ff06 <memfile_free_blocks_in_table><== NOT EXECUTED
10ffc2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
if ( info->triply_indirect ) {
10ffc5: 83 7b 60 00 cmpl $0x0,0x60(%ebx)
10ffc9: 74 78 je 110043 <IMFS_memfile_remove+0xec><== ALWAYS TAKEN
10ffcb: 31 ff xor %edi,%edi <== NOT EXECUTED
10ffcd: eb 59 jmp 110028 <IMFS_memfile_remove+0xd1><== NOT EXECUTED
10ffcf: 8d 04 bd 00 00 00 00 lea 0x0(,%edi,4),%eax <== NOT EXECUTED
10ffd6: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
10ffd9: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED
10ffdc: 8b 04 b8 mov (%eax,%edi,4),%eax <== NOT EXECUTED
if ( !p ) /* ensure we have a valid pointer */
10ffdf: 85 c0 test %eax,%eax <== NOT EXECUTED
10ffe1: 74 51 je 110034 <IMFS_memfile_remove+0xdd><== NOT EXECUTED
10ffe3: 31 d2 xor %edx,%edx <== NOT EXECUTED
10ffe5: eb 21 jmp 110008 <IMFS_memfile_remove+0xb1><== NOT EXECUTED
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
10ffe7: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED
10ffea: 74 18 je 110004 <IMFS_memfile_remove+0xad><== NOT EXECUTED
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
10ffec: 51 push %ecx <== NOT EXECUTED
10ffed: 51 push %ecx <== NOT EXECUTED
10ffee: 56 push %esi <== NOT EXECUTED
10ffef: 50 push %eax <== NOT EXECUTED
10fff0: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED
10fff3: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED
10fff6: e8 0b ff ff ff call 10ff06 <memfile_free_blocks_in_table><== NOT EXECUTED
10fffb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10fffe: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
110001: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED
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++ ) {
110004: 42 inc %edx <== NOT EXECUTED
110005: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
110008: 8b 0d 8c 3d 12 00 mov 0x123d8c,%ecx <== NOT EXECUTED
11000e: c1 e9 02 shr $0x2,%ecx <== NOT EXECUTED
110011: 39 ca cmp %ecx,%edx <== NOT EXECUTED
110013: 72 d2 jb 10ffe7 <IMFS_memfile_remove+0x90><== NOT EXECUTED
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
110015: 52 push %edx <== NOT EXECUTED
110016: 52 push %edx <== NOT EXECUTED
110017: 56 push %esi <== NOT EXECUTED
110018: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
11001b: 03 43 60 add 0x60(%ebx),%eax <== NOT EXECUTED
11001e: 50 push %eax <== NOT EXECUTED
11001f: e8 e2 fe ff ff call 10ff06 <memfile_free_blocks_in_table><== NOT EXECUTED
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
110024: 47 inc %edi <== NOT EXECUTED
110025: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
110028: a1 8c 3d 12 00 mov 0x123d8c,%eax <== NOT EXECUTED
11002d: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED
110030: 39 c7 cmp %eax,%edi <== NOT EXECUTED
110032: 72 9b jb 10ffcf <IMFS_memfile_remove+0x78><== NOT EXECUTED
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
110034: 50 push %eax <== NOT EXECUTED
110035: 50 push %eax <== NOT EXECUTED
110036: 56 push %esi <== NOT EXECUTED
(block_p **)&info->triply_indirect, to_free );
110037: 83 c3 60 add $0x60,%ebx <== NOT EXECUTED
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
11003a: 53 push %ebx <== NOT EXECUTED
11003b: e8 c6 fe ff ff call 10ff06 <memfile_free_blocks_in_table><== NOT EXECUTED
110040: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
110043: 31 c0 xor %eax,%eax
110045: 8d 65 f4 lea -0xc(%ebp),%esp
110048: 5b pop %ebx
110049: 5e pop %esi
11004a: 5f pop %edi
11004b: c9 leave
11004c: c3 ret
0011004d <IMFS_memfile_remove_block>:
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
11004d: 55 push %ebp <== NOT EXECUTED
11004e: 89 e5 mov %esp,%ebp <== NOT EXECUTED
110050: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
block_p *block_ptr;
block_p ptr;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
110053: 6a 00 push $0x0 <== NOT EXECUTED
110055: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
110058: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
11005b: e8 34 fb ff ff call 10fb94 <IMFS_memfile_get_block_pointer><== NOT EXECUTED
#if defined(RTEMS_DEBUG)
assert( block_ptr );
#endif
if ( block_ptr ) {
110060: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
110063: 85 c0 test %eax,%eax <== NOT EXECUTED
110065: 74 14 je 11007b <IMFS_memfile_remove_block+0x2e><== NOT EXECUTED
ptr = *block_ptr;
110067: 8b 10 mov (%eax),%edx <== NOT EXECUTED
*block_ptr = 0;
110069: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
memfile_free_block( ptr );
11006f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
110072: 52 push %edx <== NOT EXECUTED
110073: e8 75 fe ff ff call 10feed <memfile_free_block> <== NOT EXECUTED
110078: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return 1;
}
11007b: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
110080: c9 leave <== NOT EXECUTED
110081: c3 ret <== NOT EXECUTED
00110174 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
110174: 55 push %ebp
110175: 89 e5 mov %esp,%ebp
110177: 57 push %edi
110178: 56 push %esi
110179: 53 push %ebx
11017a: 83 ec 3c sub $0x3c,%esp
11017d: 8b 5d 0c mov 0xc(%ebp),%ebx
110180: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Error check arguments
*/
if ( !source )
110183: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
110187: 74 06 je 11018f <IMFS_memfile_write+0x1b><== NEVER TAKEN
/*
* If there is nothing to write, then quick exit.
*/
my_length = length;
if ( !my_length )
110189: 83 7d 18 00 cmpl $0x0,0x18(%ebp)
11018d: 75 0d jne 11019c <IMFS_memfile_write+0x28><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
11018f: e8 c0 0f 00 00 call 111154 <__errno> <== NOT EXECUTED
110194: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
11019a: eb 35 jmp 1101d1 <IMFS_memfile_write+0x5d><== NOT EXECUTED
/*
* 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 + length;
11019c: 8b 4d 18 mov 0x18(%ebp),%ecx
11019f: 01 d9 add %ebx,%ecx
if ( last_byte > the_jnode->info.file.size ) {
1101a1: 89 c8 mov %ecx,%eax
1101a3: 31 d2 xor %edx,%edx
1101a5: 8b 7d 08 mov 0x8(%ebp),%edi
1101a8: 3b 57 54 cmp 0x54(%edi),%edx
1101ab: 7c 2c jl 1101d9 <IMFS_memfile_write+0x65><== NEVER TAKEN
1101ad: 7f 05 jg 1101b4 <IMFS_memfile_write+0x40><== NEVER TAKEN
1101af: 3b 4f 50 cmp 0x50(%edi),%ecx
1101b2: 76 25 jbe 1101d9 <IMFS_memfile_write+0x65><== NEVER TAKEN
status = IMFS_memfile_extend( the_jnode, last_byte );
1101b4: 57 push %edi
1101b5: 52 push %edx
1101b6: 50 push %eax
1101b7: ff 75 08 pushl 0x8(%ebp)
1101ba: e8 c3 fe ff ff call 110082 <IMFS_memfile_extend>
if ( status )
1101bf: 83 c4 10 add $0x10,%esp
1101c2: 85 c0 test %eax,%eax
1101c4: 74 13 je 1101d9 <IMFS_memfile_write+0x65>
rtems_set_errno_and_return_minus_one( ENOSPC );
1101c6: e8 89 0f 00 00 call 111154 <__errno>
1101cb: c7 00 1c 00 00 00 movl $0x1c,(%eax)
1101d1: 83 cb ff or $0xffffffff,%ebx
1101d4: e9 fe 00 00 00 jmp 1102d7 <IMFS_memfile_write+0x163>
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
1101d9: a1 8c 3d 12 00 mov 0x123d8c,%eax
1101de: 89 45 cc mov %eax,-0x34(%ebp)
1101e1: 99 cltd
1101e2: 89 45 c0 mov %eax,-0x40(%ebp)
1101e5: 89 55 c4 mov %edx,-0x3c(%ebp)
1101e8: 52 push %edx
1101e9: 50 push %eax
1101ea: 56 push %esi
1101eb: 53 push %ebx
1101ec: e8 77 c2 00 00 call 11c468 <__moddi3>
1101f1: 83 c4 10 add $0x10,%esp
1101f4: 89 c7 mov %eax,%edi
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
1101f6: ff 75 c4 pushl -0x3c(%ebp)
1101f9: ff 75 c0 pushl -0x40(%ebp)
1101fc: 56 push %esi
1101fd: 53 push %ebx
1101fe: e8 05 c1 00 00 call 11c308 <__divdi3>
110203: 83 c4 10 add $0x10,%esp
110206: 89 c2 mov %eax,%edx
if ( start_offset ) {
110208: 85 ff test %edi,%edi
11020a: 74 40 je 11024c <IMFS_memfile_write+0xd8>
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 );
11020c: 51 push %ecx
11020d: 6a 00 push $0x0
11020f: 50 push %eax
110210: ff 75 08 pushl 0x8(%ebp)
110213: 89 45 bc mov %eax,-0x44(%ebp)
110216: e8 79 f9 ff ff call 10fb94 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
11021b: 83 c4 10 add $0x10,%esp
return copied;
11021e: 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 )
110220: 85 c0 test %eax,%eax
110222: 8b 55 bc mov -0x44(%ebp),%edx
110225: 0f 84 ac 00 00 00 je 1102d7 <IMFS_memfile_write+0x163><== NEVER TAKEN
*/
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;
11022b: 8b 5d cc mov -0x34(%ebp),%ebx
11022e: 29 fb sub %edi,%ebx
110230: 3b 5d 18 cmp 0x18(%ebp),%ebx
110233: 76 03 jbe 110238 <IMFS_memfile_write+0xc4><== ALWAYS TAKEN
110235: 8b 5d 18 mov 0x18(%ebp),%ebx <== NOT EXECUTED
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
110238: 03 38 add (%eax),%edi
src += to_copy;
11023a: 8b 75 14 mov 0x14(%ebp),%esi
11023d: 89 d9 mov %ebx,%ecx
11023f: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
110241: 42 inc %edx
my_length -= to_copy;
110242: 8b 7d 18 mov 0x18(%ebp),%edi
110245: 29 df sub %ebx,%edi
110247: 89 7d d4 mov %edi,-0x2c(%ebp)
11024a: eb 0b jmp 110257 <IMFS_memfile_write+0xe3>
* 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 ) {
11024c: 8b 75 14 mov 0x14(%ebp),%esi
11024f: 8b 45 18 mov 0x18(%ebp),%eax
110252: 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;
110255: 31 db xor %ebx,%ebx
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
110257: 8b 3d 8c 3d 12 00 mov 0x123d8c,%edi
11025d: 89 7d d0 mov %edi,-0x30(%ebp)
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
110260: eb 2b jmp 11028d <IMFS_memfile_write+0x119>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
110262: 50 push %eax
110263: 6a 00 push $0x0
110265: 52 push %edx
110266: ff 75 08 pushl 0x8(%ebp)
110269: 89 55 bc mov %edx,-0x44(%ebp)
11026c: e8 23 f9 ff ff call 10fb94 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
110271: 83 c4 10 add $0x10,%esp
110274: 85 c0 test %eax,%eax
110276: 8b 55 bc mov -0x44(%ebp),%edx
110279: 74 5c je 1102d7 <IMFS_memfile_write+0x163><== 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 );
11027b: 8b 00 mov (%eax),%eax
src += to_copy;
11027d: 89 c7 mov %eax,%edi
11027f: 8b 4d d0 mov -0x30(%ebp),%ecx
110282: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
110284: 42 inc %edx
my_length -= to_copy;
110285: 8b 45 d0 mov -0x30(%ebp),%eax
110288: 29 45 d4 sub %eax,-0x2c(%ebp)
*
* 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(
11028b: 01 c3 add %eax,%ebx
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
11028d: 8b 7d d4 mov -0x2c(%ebp),%edi
110290: 3b 3d 8c 3d 12 00 cmp 0x123d8c,%edi
110296: 73 ca jae 110262 <IMFS_memfile_write+0xee>
#if defined(RTEMS_DEBUG)
assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
#endif
to_copy = my_length;
if ( my_length ) {
110298: 85 ff test %edi,%edi
11029a: 74 1f je 1102bb <IMFS_memfile_write+0x147>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
11029c: 57 push %edi
11029d: 6a 00 push $0x0
11029f: 52 push %edx
1102a0: ff 75 08 pushl 0x8(%ebp)
1102a3: e8 ec f8 ff ff call 10fb94 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
1102a8: 83 c4 10 add $0x10,%esp
1102ab: 85 c0 test %eax,%eax
1102ad: 74 28 je 1102d7 <IMFS_memfile_write+0x163><== 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 );
1102af: 8b 00 mov (%eax),%eax
1102b1: 89 c7 mov %eax,%edi
1102b3: 8b 4d d4 mov -0x2c(%ebp),%ecx
1102b6: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
my_length = 0;
copied += to_copy;
1102b8: 03 5d d4 add -0x2c(%ebp),%ebx
}
IMFS_mtime_ctime_update( the_jnode );
1102bb: 56 push %esi
1102bc: 56 push %esi
1102bd: 6a 00 push $0x0
1102bf: 8d 45 e0 lea -0x20(%ebp),%eax
1102c2: 50 push %eax
1102c3: e8 94 70 ff ff call 10735c <gettimeofday>
1102c8: 8b 45 e0 mov -0x20(%ebp),%eax
1102cb: 8b 55 08 mov 0x8(%ebp),%edx
1102ce: 89 42 44 mov %eax,0x44(%edx)
1102d1: 89 42 48 mov %eax,0x48(%edx)
return copied;
1102d4: 83 c4 10 add $0x10,%esp
}
1102d7: 89 d8 mov %ebx,%eax
1102d9: 8d 65 f4 lea -0xc(%ebp),%esp
1102dc: 5b pop %ebx
1102dd: 5e pop %esi
1102de: 5f pop %edi
1102df: c9 leave
1102e0: c3 ret
00106c08 <IMFS_mknod>:
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
106c08: 55 push %ebp
106c09: 89 e5 mov %esp,%ebp
106c0b: 57 push %edi
106c0c: 56 push %esi
106c0d: 53 push %ebx
106c0e: 83 ec 4c sub $0x4c,%esp
106c11: 8b 55 08 mov 0x8(%ebp),%edx
106c14: 8b 5d 10 mov 0x10(%ebp),%ebx
106c17: 8b 75 14 mov 0x14(%ebp),%esi
IMFS_jnode_t *new_node;
int result;
char new_name[ IMFS_NAME_MAX + 1 ];
IMFS_types_union info;
IMFS_get_token( token, strlen( token ), new_name, &result );
106c1a: 31 c0 xor %eax,%eax
106c1c: 83 c9 ff or $0xffffffff,%ecx
106c1f: 89 d7 mov %edx,%edi
106c21: f2 ae repnz scas %es:(%edi),%al
106c23: f7 d1 not %ecx
106c25: 49 dec %ecx
106c26: 8d 45 e4 lea -0x1c(%ebp),%eax
106c29: 50 push %eax
106c2a: 8d 45 af lea -0x51(%ebp),%eax
106c2d: 50 push %eax
106c2e: 51 push %ecx
106c2f: 52 push %edx
106c30: e8 d7 70 00 00 call 10dd0c <IMFS_get_token>
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
106c35: 8b 45 0c mov 0xc(%ebp),%eax
106c38: 25 00 f0 00 00 and $0xf000,%eax
106c3d: 83 c4 10 add $0x10,%esp
106c40: 3d 00 40 00 00 cmp $0x4000,%eax
106c45: 74 3b je 106c82 <IMFS_mknod+0x7a>
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
106c47: 3d 00 80 00 00 cmp $0x8000,%eax
106c4c: 74 3b je 106c89 <IMFS_mknod+0x81>
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
106c4e: 3d 00 20 00 00 cmp $0x2000,%eax
106c53: 74 07 je 106c5c <IMFS_mknod+0x54>
106c55: 3d 00 60 00 00 cmp $0x6000,%eax
106c5a: 75 0d jne 106c69 <IMFS_mknod+0x61>
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
106c5c: 89 5d d0 mov %ebx,-0x30(%ebp)
106c5f: 89 75 d4 mov %esi,-0x2c(%ebp)
if ( S_ISDIR(mode) )
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
type = IMFS_DEVICE;
106c62: ba 02 00 00 00 mov $0x2,%edx
106c67: eb 25 jmp 106c8e <IMFS_mknod+0x86>
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
}
else if (S_ISFIFO(mode))
type = IMFS_FIFO;
106c69: ba 07 00 00 00 mov $0x7,%edx
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
}
else if (S_ISFIFO(mode))
106c6e: 3d 00 10 00 00 cmp $0x1000,%eax
106c73: 74 19 je 106c8e <IMFS_mknod+0x86> <== ALWAYS TAKEN
type = IMFS_FIFO;
else {
rtems_set_errno_and_return_minus_one( EINVAL );
106c75: e8 da a4 00 00 call 111154 <__errno> <== NOT EXECUTED
106c7a: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
106c80: eb 39 jmp 106cbb <IMFS_mknod+0xb3> <== NOT EXECUTED
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
type = IMFS_DIRECTORY;
106c82: ba 01 00 00 00 mov $0x1,%edx
106c87: eb 05 jmp 106c8e <IMFS_mknod+0x86>
else if ( S_ISREG(mode) )
type = IMFS_MEMORY_FILE;
106c89: ba 05 00 00 00 mov $0x5,%edx
* 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.
*/
new_node = IMFS_create_node(
106c8e: 83 ec 0c sub $0xc,%esp
pathloc,
type,
new_name,
mode,
&info
106c91: 8d 45 d0 lea -0x30(%ebp),%eax
* 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.
*/
new_node = IMFS_create_node(
106c94: 50 push %eax
106c95: ff 75 0c pushl 0xc(%ebp)
106c98: 8d 45 af lea -0x51(%ebp),%eax
106c9b: 50 push %eax
106c9c: 52 push %edx
106c9d: ff 75 18 pushl 0x18(%ebp)
106ca0: e8 36 68 00 00 call 10d4db <IMFS_create_node>
106ca5: 89 c2 mov %eax,%edx
new_name,
mode,
&info
);
if ( !new_node )
106ca7: 83 c4 20 add $0x20,%esp
rtems_set_errno_and_return_minus_one( ENOMEM );
return 0;
106caa: 31 c0 xor %eax,%eax
new_name,
mode,
&info
);
if ( !new_node )
106cac: 85 d2 test %edx,%edx
106cae: 75 0e jne 106cbe <IMFS_mknod+0xb6>
rtems_set_errno_and_return_minus_one( ENOMEM );
106cb0: e8 9f a4 00 00 call 111154 <__errno>
106cb5: c7 00 0c 00 00 00 movl $0xc,(%eax)
106cbb: 83 c8 ff or $0xffffffff,%eax
return 0;
}
106cbe: 8d 65 f4 lea -0xc(%ebp),%esp
106cc1: 5b pop %ebx
106cc2: 5e pop %esi
106cc3: 5f pop %edi
106cc4: c9 leave
106cc5: c3 ret
00106cc8 <IMFS_mount>:
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
106cc8: 55 push %ebp
106cc9: 89 e5 mov %esp,%ebp
106ccb: 83 ec 08 sub $0x8,%esp
106cce: 8b 55 08 mov 0x8(%ebp),%edx
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
106cd1: 8b 42 08 mov 0x8(%edx),%eax
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
106cd4: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
106cd8: 74 10 je 106cea <IMFS_mount+0x22> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
106cda: e8 75 a4 00 00 call 111154 <__errno> <== NOT EXECUTED
106cdf: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
106ce5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106ce8: eb 05 jmp 106cef <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;
106cea: 89 50 5c mov %edx,0x5c(%eax)
return 0;
106ced: 31 c0 xor %eax,%eax
}
106cef: c9 leave
106cf0: c3 ret
00108698 <IMFS_print_jnode>:
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
108698: 55 push %ebp
108699: 89 e5 mov %esp,%ebp
10869b: 53 push %ebx
10869c: 83 ec 0c sub $0xc,%esp
10869f: 8b 5d 08 mov 0x8(%ebp),%ebx
#if defined(RTEMS_DEBUG)
assert( the_jnode );
#endif
fprintf(stdout, "%s", the_jnode->name );
1086a2: a1 20 80 12 00 mov 0x128020,%eax
1086a7: ff 70 08 pushl 0x8(%eax)
1086aa: 8d 43 0c lea 0xc(%ebx),%eax
1086ad: 50 push %eax
1086ae: e8 05 be 00 00 call 1144b8 <fputs>
switch( the_jnode->type ) {
1086b3: 8b 43 4c mov 0x4c(%ebx),%eax
1086b6: 83 c4 10 add $0x10,%esp
1086b9: 8d 50 ff lea -0x1(%eax),%edx
1086bc: 83 fa 06 cmp $0x6,%edx
1086bf: 77 75 ja 108736 <IMFS_print_jnode+0x9e> <== NEVER TAKEN
1086c1: a1 20 80 12 00 mov 0x128020,%eax
1086c6: ff 24 95 94 31 12 00 jmp *0x123194(,%edx,4)
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
1086cd: 51 push %ecx
1086ce: 51 push %ecx
1086cf: ff 70 08 pushl 0x8(%eax)
1086d2: 6a 2f push $0x2f
1086d4: e8 33 bd 00 00 call 11440c <fputc>
1086d9: eb 2b jmp 108706 <IMFS_print_jnode+0x6e>
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
1086db: ff 73 54 pushl 0x54(%ebx)
1086de: ff 73 50 pushl 0x50(%ebx)
1086e1: 68 b8 30 12 00 push $0x1230b8
1086e6: eb 16 jmp 1086fe <IMFS_print_jnode+0x66>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
1086e8: ff 73 58 pushl 0x58(%ebx) <== NOT EXECUTED
1086eb: ff 73 50 pushl 0x50(%ebx) <== NOT EXECUTED
1086ee: 68 cb 30 12 00 push $0x1230cb <== NOT EXECUTED
1086f3: eb 09 jmp 1086fe <IMFS_print_jnode+0x66> <== NOT EXECUTED
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
1086f5: 52 push %edx <== NOT EXECUTED
1086f6: ff 73 50 pushl 0x50(%ebx) <== NOT EXECUTED
1086f9: 68 da 30 12 00 push $0x1230da <== NOT EXECUTED
1086fe: ff 70 08 pushl 0x8(%eax)
108701: e8 a6 bc 00 00 call 1143ac <fprintf>
(uint32_t)the_jnode->info.file.size );
#endif
break;
108706: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
108709: c7 45 08 29 33 12 00 movl $0x123329,0x8(%ebp)
}
108710: 8b 5d fc mov -0x4(%ebp),%ebx
108713: c9 leave
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
108714: e9 7b d5 00 00 jmp 115c94 <puts>
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
108719: 53 push %ebx <== NOT EXECUTED
10871a: 53 push %ebx <== NOT EXECUTED
10871b: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
10871e: 68 e6 30 12 00 push $0x1230e6 <== NOT EXECUTED
108723: eb 0a jmp 10872f <IMFS_print_jnode+0x97> <== NOT EXECUTED
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
108725: 51 push %ecx <== NOT EXECUTED
108726: 51 push %ecx <== NOT EXECUTED
108727: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
10872a: 68 fa 30 12 00 push $0x1230fa <== NOT EXECUTED
10872f: e8 84 bd 00 00 call 1144b8 <fputs> <== NOT EXECUTED
108734: eb 14 jmp 10874a <IMFS_print_jnode+0xb2> <== NOT EXECUTED
return;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
108736: 52 push %edx <== NOT EXECUTED
108737: 50 push %eax <== NOT EXECUTED
108738: 68 0d 31 12 00 push $0x12310d <== NOT EXECUTED
10873d: a1 20 80 12 00 mov 0x128020,%eax <== NOT EXECUTED
108742: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
108745: e8 62 bc 00 00 call 1143ac <fprintf> <== NOT EXECUTED
return;
10874a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
puts("");
}
10874d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
108750: c9 leave <== NOT EXECUTED
108751: c3 ret <== NOT EXECUTED
00106d04 <IMFS_readlink>:
int IMFS_readlink(
rtems_filesystem_location_info_t *loc,
char *buf, /* OUT */
size_t bufsize
)
{
106d04: 55 push %ebp
106d05: 89 e5 mov %esp,%ebp
106d07: 56 push %esi
106d08: 53 push %ebx
106d09: 8b 5d 0c mov 0xc(%ebp),%ebx
106d0c: 8b 75 10 mov 0x10(%ebp),%esi
IMFS_jnode_t *node;
int i;
node = loc->node_access;
106d0f: 8b 45 08 mov 0x8(%ebp),%eax
106d12: 8b 10 mov (%eax),%edx
if ( node->type != IMFS_SYM_LINK )
106d14: 83 7a 4c 04 cmpl $0x4,0x4c(%edx)
106d18: 75 04 jne 106d1e <IMFS_readlink+0x1a> <== NEVER TAKEN
106d1a: 31 c0 xor %eax,%eax
106d1c: eb 14 jmp 106d32 <IMFS_readlink+0x2e>
rtems_set_errno_and_return_minus_one( EINVAL );
106d1e: e8 31 a4 00 00 call 111154 <__errno> <== NOT EXECUTED
106d23: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
106d29: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106d2c: eb 12 jmp 106d40 <IMFS_readlink+0x3c> <== NOT EXECUTED
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
buf[i] = node->info.sym_link.name[i];
106d2e: 88 0c 03 mov %cl,(%ebx,%eax,1)
node = loc->node_access;
if ( node->type != IMFS_SYM_LINK )
rtems_set_errno_and_return_minus_one( EINVAL );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
106d31: 40 inc %eax
106d32: 39 f0 cmp %esi,%eax
106d34: 73 0a jae 106d40 <IMFS_readlink+0x3c>
106d36: 8b 4a 50 mov 0x50(%edx),%ecx
106d39: 8a 0c 01 mov (%ecx,%eax,1),%cl
106d3c: 84 c9 test %cl,%cl
106d3e: 75 ee jne 106d2e <IMFS_readlink+0x2a>
buf[i] = node->info.sym_link.name[i];
return i;
}
106d40: 5b pop %ebx
106d41: 5e pop %esi
106d42: c9 leave
106d43: c3 ret
00106d44 <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 */
)
{
106d44: 55 push %ebp <== NOT EXECUTED
106d45: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106d47: 53 push %ebx <== NOT EXECUTED
106d48: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
106d4b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
106d4e: 8b 18 mov (%eax),%ebx <== NOT EXECUTED
strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
106d50: 6a 20 push $0x20 <== NOT EXECUTED
106d52: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED
106d55: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED
106d58: 50 push %eax <== NOT EXECUTED
106d59: e8 ce b1 00 00 call 111f2c <strncpy> <== NOT EXECUTED
if ( the_jnode->Parent != NULL )
106d5e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106d61: 83 7b 08 00 cmpl $0x0,0x8(%ebx) <== NOT EXECUTED
106d65: 74 0c je 106d73 <IMFS_rename+0x2f> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
106d67: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106d6a: 53 push %ebx <== NOT EXECUTED
106d6b: e8 e8 3c 00 00 call 10aa58 <_Chain_Extract> <== NOT EXECUTED
106d70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_chain_extract( (rtems_chain_node *) the_jnode );
new_parent = new_parent_loc->node_access;
106d73: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
106d76: 8b 00 mov (%eax),%eax <== NOT EXECUTED
the_jnode->Parent = new_parent;
106d78: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
106d7b: 51 push %ecx <== NOT EXECUTED
106d7c: 51 push %ecx <== NOT EXECUTED
106d7d: 53 push %ebx <== NOT EXECUTED
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
106d7e: 83 c0 50 add $0x50,%eax <== NOT EXECUTED
106d81: 50 push %eax <== NOT EXECUTED
106d82: e8 ad 3c 00 00 call 10aa34 <_Chain_Append> <== NOT EXECUTED
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
106d87: 58 pop %eax <== NOT EXECUTED
106d88: 5a pop %edx <== NOT EXECUTED
106d89: 6a 00 push $0x0 <== NOT EXECUTED
106d8b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED
106d8e: 50 push %eax <== NOT EXECUTED
106d8f: e8 c8 05 00 00 call 10735c <gettimeofday> <== NOT EXECUTED
106d94: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
106d97: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED
return 0;
}
106d9a: 31 c0 xor %eax,%eax <== NOT EXECUTED
106d9c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
106d9f: c9 leave <== NOT EXECUTED
106da0: c3 ret <== NOT EXECUTED
0010de9c <IMFS_stat>:
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
10de9c: 55 push %ebp
10de9d: 89 e5 mov %esp,%ebp
10de9f: 56 push %esi
10dea0: 53 push %ebx
10dea1: 8b 4d 08 mov 0x8(%ebp),%ecx
10dea4: 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;
10dea7: 8b 11 mov (%ecx),%edx
switch ( the_jnode->type ) {
10dea9: 8b 5a 4c mov 0x4c(%edx),%ebx
10deac: 83 eb 02 sub $0x2,%ebx
10deaf: 83 fb 05 cmp $0x5,%ebx
10deb2: 77 33 ja 10dee7 <IMFS_stat+0x4b> <== NEVER TAKEN
10deb4: ff 24 9d a4 ed 11 00 jmp *0x11eda4(,%ebx,4)
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
10debb: 8b 5a 54 mov 0x54(%edx),%ebx
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
10debe: 8b 72 50 mov 0x50(%edx),%esi
10dec1: 89 70 18 mov %esi,0x18(%eax)
10dec4: 89 58 1c mov %ebx,0x1c(%eax)
break;
10dec7: eb 2e jmp 10def7 <IMFS_stat+0x5b>
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
10dec9: 8b 5a 50 mov 0x50(%edx),%ebx
10decc: 8b 72 54 mov 0x54(%edx),%esi
10decf: 89 58 20 mov %ebx,0x20(%eax)
10ded2: 89 70 24 mov %esi,0x24(%eax)
break;
10ded5: eb 20 jmp 10def7 <IMFS_stat+0x5b>
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
10ded7: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
10dede: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
break;
10dee5: eb 10 jmp 10def7 <IMFS_stat+0x5b>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
10dee7: e8 68 32 00 00 call 111154 <__errno> <== NOT EXECUTED
10deec: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10def2: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10def5: eb 47 jmp 10df3e <IMFS_stat+0xa2> <== NOT EXECUTED
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
10def7: 8b 49 10 mov 0x10(%ecx),%ecx
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
10defa: 8b 49 34 mov 0x34(%ecx),%ecx
10defd: 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 =
10deff: c7 00 fe ff 00 00 movl $0xfffe,(%eax)
10df05: 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;
10df08: 8b 4a 30 mov 0x30(%edx),%ecx
10df0b: 89 48 0c mov %ecx,0xc(%eax)
buf->st_nlink = the_jnode->st_nlink;
10df0e: 8b 4a 34 mov 0x34(%edx),%ecx
10df11: 66 89 48 10 mov %cx,0x10(%eax)
buf->st_ino = the_jnode->st_ino;
10df15: 8b 4a 38 mov 0x38(%edx),%ecx
10df18: 89 48 08 mov %ecx,0x8(%eax)
buf->st_uid = the_jnode->st_uid;
10df1b: 8b 4a 3c mov 0x3c(%edx),%ecx
10df1e: 66 89 48 12 mov %cx,0x12(%eax)
buf->st_gid = the_jnode->st_gid;
10df22: 66 8b 4a 3e mov 0x3e(%edx),%cx
10df26: 66 89 48 14 mov %cx,0x14(%eax)
buf->st_atime = the_jnode->stat_atime;
10df2a: 8b 4a 40 mov 0x40(%edx),%ecx
10df2d: 89 48 28 mov %ecx,0x28(%eax)
buf->st_mtime = the_jnode->stat_mtime;
10df30: 8b 4a 44 mov 0x44(%edx),%ecx
10df33: 89 48 30 mov %ecx,0x30(%eax)
buf->st_ctime = the_jnode->stat_ctime;
10df36: 8b 52 48 mov 0x48(%edx),%edx
10df39: 89 50 38 mov %edx,0x38(%eax)
return 0;
10df3c: 31 c0 xor %eax,%eax
}
10df3e: 5b pop %ebx
10df3f: 5e pop %esi
10df40: c9 leave
10df41: c3 ret
00106da4 <IMFS_symlink>:
int IMFS_symlink(
rtems_filesystem_location_info_t *parent_loc,
const char *link_name,
const char *node_name
)
{
106da4: 55 push %ebp
106da5: 89 e5 mov %esp,%ebp
106da7: 57 push %edi
106da8: 53 push %ebx
106da9: 83 ec 40 sub $0x40,%esp
106dac: 8b 55 10 mov 0x10(%ebp),%edx
int i;
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( node_name, strlen( node_name ), new_name, &i );
106daf: 31 c0 xor %eax,%eax
106db1: 83 c9 ff or $0xffffffff,%ecx
106db4: 89 d7 mov %edx,%edi
106db6: f2 ae repnz scas %es:(%edi),%al
106db8: f7 d1 not %ecx
106dba: 49 dec %ecx
106dbb: 8d 45 f4 lea -0xc(%ebp),%eax
106dbe: 50 push %eax
106dbf: 8d 5d bf lea -0x41(%ebp),%ebx
106dc2: 53 push %ebx
106dc3: 51 push %ecx
106dc4: 52 push %edx
106dc5: e8 42 6f 00 00 call 10dd0c <IMFS_get_token>
/*
* Duplicate link name
*/
info.sym_link.name = strdup(link_name);
106dca: 58 pop %eax
106dcb: ff 75 0c pushl 0xc(%ebp)
106dce: e8 ed af 00 00 call 111dc0 <strdup>
106dd3: 89 45 e0 mov %eax,-0x20(%ebp)
if (info.sym_link.name == NULL) {
106dd6: 83 c4 10 add $0x10,%esp
106dd9: 85 c0 test %eax,%eax
106ddb: 75 0d jne 106dea <IMFS_symlink+0x46> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(ENOMEM);
106ddd: e8 72 a3 00 00 call 111154 <__errno> <== NOT EXECUTED
106de2: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
106de8: eb 3b jmp 106e25 <IMFS_symlink+0x81> <== NOT EXECUTED
* 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.
*/
new_node = IMFS_create_node(
106dea: 83 ec 0c sub $0xc,%esp
parent_loc,
IMFS_SYM_LINK,
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
106ded: 8d 45 e0 lea -0x20(%ebp),%eax
* 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.
*/
new_node = IMFS_create_node(
106df0: 50 push %eax
106df1: 68 ff a1 00 00 push $0xa1ff
106df6: 53 push %ebx
106df7: 6a 04 push $0x4
106df9: ff 75 08 pushl 0x8(%ebp)
106dfc: e8 da 66 00 00 call 10d4db <IMFS_create_node>
106e01: 89 c2 mov %eax,%edx
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if (new_node == NULL) {
106e03: 83 c4 20 add $0x20,%esp
free(info.sym_link.name);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
return 0;
106e06: 31 c0 xor %eax,%eax
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if (new_node == NULL) {
106e08: 85 d2 test %edx,%edx
106e0a: 75 1c jne 106e28 <IMFS_symlink+0x84> <== ALWAYS TAKEN
free(info.sym_link.name);
106e0c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106e0f: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
106e12: e8 cd 04 00 00 call 1072e4 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
106e17: e8 38 a3 00 00 call 111154 <__errno> <== NOT EXECUTED
106e1c: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
106e22: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106e25: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
}
return 0;
}
106e28: 8d 65 f8 lea -0x8(%ebp),%esp
106e2b: 5b pop %ebx
106e2c: 5f pop %edi
106e2d: c9 leave
106e2e: c3 ret
00106e30 <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
106e30: 55 push %ebp
106e31: 89 e5 mov %esp,%ebp
106e33: 57 push %edi
106e34: 56 push %esi
106e35: 53 push %ebx
106e36: 83 ec 2c sub $0x2c,%esp
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
106e39: 8b 45 0c mov 0xc(%ebp),%eax
106e3c: 8b 18 mov (%eax),%ebx
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
106e3e: 83 7b 4c 03 cmpl $0x3,0x4c(%ebx)
106e42: 75 7a jne 106ebe <IMFS_unlink+0x8e>
if ( !node->info.hard_link.link_node )
106e44: 8b 43 50 mov 0x50(%ebx),%eax
106e47: 85 c0 test %eax,%eax
106e49: 75 10 jne 106e5b <IMFS_unlink+0x2b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
106e4b: e8 04 a3 00 00 call 111154 <__errno> <== NOT EXECUTED
106e50: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
106e56: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106e59: eb 75 jmp 106ed0 <IMFS_unlink+0xa0> <== NOT EXECUTED
the_link = *loc;
106e5b: 8d 7d cc lea -0x34(%ebp),%edi
106e5e: b9 05 00 00 00 mov $0x5,%ecx
106e63: 8b 75 0c mov 0xc(%ebp),%esi
106e66: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_link.node_access = node->info.hard_link.link_node;
106e68: 89 45 cc mov %eax,-0x34(%ebp)
IMFS_Set_handlers( &the_link );
106e6b: 83 ec 0c sub $0xc,%esp
106e6e: 8d 75 cc lea -0x34(%ebp),%esi
106e71: 56 push %esi
106e72: e8 99 67 00 00 call 10d610 <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)
106e77: 8b 43 50 mov 0x50(%ebx),%eax
106e7a: 8b 50 34 mov 0x34(%eax),%edx
106e7d: 83 c4 10 add $0x10,%esp
106e80: 66 83 fa 01 cmp $0x1,%dx
106e84: 75 1a jne 106ea0 <IMFS_unlink+0x70>
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
106e86: 51 push %ecx
106e87: 51 push %ecx
106e88: 56 push %esi
106e89: ff 75 08 pushl 0x8(%ebp)
106e8c: 8b 45 d4 mov -0x2c(%ebp),%eax
106e8f: ff 50 34 call *0x34(%eax)
106e92: 89 c2 mov %eax,%edx
if ( result != 0 )
106e94: 83 c4 10 add $0x10,%esp
return -1;
106e97: 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 )
106e9a: 85 d2 test %edx,%edx
106e9c: 74 20 je 106ebe <IMFS_unlink+0x8e>
106e9e: eb 30 jmp 106ed0 <IMFS_unlink+0xa0>
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
106ea0: 4a dec %edx
106ea1: 66 89 50 34 mov %dx,0x34(%eax)
IMFS_update_ctime( node->info.hard_link.link_node );
106ea5: 52 push %edx
106ea6: 52 push %edx
106ea7: 6a 00 push $0x0
106ea9: 8d 45 e0 lea -0x20(%ebp),%eax
106eac: 50 push %eax
106ead: e8 aa 04 00 00 call 10735c <gettimeofday>
106eb2: 8b 43 50 mov 0x50(%ebx),%eax
106eb5: 8b 55 e0 mov -0x20(%ebp),%edx
106eb8: 89 50 48 mov %edx,0x48(%eax)
106ebb: 83 c4 10 add $0x10,%esp
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
106ebe: 50 push %eax
106ebf: 50 push %eax
106ec0: 8b 55 0c mov 0xc(%ebp),%edx
106ec3: 8b 42 08 mov 0x8(%edx),%eax
106ec6: 52 push %edx
106ec7: ff 75 08 pushl 0x8(%ebp)
106eca: ff 50 34 call *0x34(%eax)
return result;
106ecd: 83 c4 10 add $0x10,%esp
}
106ed0: 8d 65 f4 lea -0xc(%ebp),%esp
106ed3: 5b pop %ebx
106ed4: 5e pop %esi
106ed5: 5f pop %edi
106ed6: c9 leave
106ed7: c3 ret
00106ed8 <IMFS_unmount>:
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
106ed8: 55 push %ebp
106ed9: 89 e5 mov %esp,%ebp
106edb: 83 ec 08 sub $0x8,%esp
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
106ede: 8b 45 08 mov 0x8(%ebp),%eax
106ee1: 8b 40 08 mov 0x8(%eax),%eax
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
106ee4: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
106ee8: 74 0d je 106ef7 <IMFS_unmount+0x1f> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
106eea: e8 65 a2 00 00 call 111154 <__errno> <== NOT EXECUTED
106eef: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
106ef5: eb 11 jmp 106f08 <IMFS_unmount+0x30> <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
106ef7: 83 78 5c 00 cmpl $0x0,0x5c(%eax)
106efb: 75 10 jne 106f0d <IMFS_unmount+0x35> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
106efd: e8 52 a2 00 00 call 111154 <__errno> <== NOT EXECUTED
106f02: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
106f08: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106f0b: eb 09 jmp 106f16 <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;
106f0d: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
return 0;
106f14: 31 c0 xor %eax,%eax
}
106f16: c9 leave
106f17: c3 ret
00106a68 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
106a68: 55 push %ebp <== NOT EXECUTED
106a69: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106a6b: 57 push %edi <== NOT EXECUTED
106a6c: 56 push %esi <== NOT EXECUTED
106a6d: 53 push %ebx <== NOT EXECUTED
106a6e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
106a71: 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) {
106a74: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED
106a77: 75 0f jne 106a88 <Stack_check_Dump_threads_usage+0x20><== NOT EXECUTED
if (!Stack_check_Interrupt_stack.area)
106a79: 83 3d f4 51 12 00 00 cmpl $0x0,0x1251f4 <== NOT EXECUTED
106a80: 0f 84 8b 00 00 00 je 106b11 <Stack_check_Dump_threads_usage+0xa9><== NOT EXECUTED
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
106a86: 31 db xor %ebx,%ebx <== NOT EXECUTED
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
#endif
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
106a88: 8b 3d f0 51 12 00 mov 0x1251f0,%edi <== NOT EXECUTED
106a8e: 83 ef 10 sub $0x10,%edi <== NOT EXECUTED
if ( high_water_mark )
used = Stack_check_Calculate_used( low, size, high_water_mark );
else
used = 0;
if ( the_thread ) {
106a91: 85 db test %ebx,%ebx <== NOT EXECUTED
106a93: 8b 35 d0 4e 12 00 mov 0x124ed0,%esi <== NOT EXECUTED
106a99: 74 25 je 106ac0 <Stack_check_Dump_threads_usage+0x58><== NOT EXECUTED
(*print_handler)(
106a9b: 50 push %eax <== NOT EXECUTED
106a9c: 8d 45 e3 lea -0x1d(%ebp),%eax <== NOT EXECUTED
106a9f: 50 push %eax <== NOT EXECUTED
106aa0: 6a 05 push $0x5 <== NOT EXECUTED
106aa2: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
106aa5: e8 aa 37 00 00 call 10a254 <rtems_object_get_name> <== NOT EXECUTED
106aaa: 50 push %eax <== NOT EXECUTED
106aab: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
106aae: 68 1d eb 11 00 push $0x11eb1d <== NOT EXECUTED
106ab3: ff 35 cc 4e 12 00 pushl 0x124ecc <== NOT EXECUTED
106ab9: ff d6 call *%esi <== NOT EXECUTED
106abb: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
106abe: eb 13 jmp 106ad3 <Stack_check_Dump_threads_usage+0x6b><== NOT EXECUTED
"0x%08" PRIx32 " %4s",
the_thread->Object.id,
rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
);
} else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
106ac0: 51 push %ecx <== NOT EXECUTED
106ac1: 6a ff push $0xffffffff <== NOT EXECUTED
106ac3: 68 2a eb 11 00 push $0x11eb2a <== NOT EXECUTED
106ac8: ff 35 cc 4e 12 00 pushl 0x124ecc <== NOT EXECUTED
106ace: ff d6 call *%esi <== NOT EXECUTED
106ad0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
106ad3: a1 f4 51 12 00 mov 0x1251f4,%eax <== NOT EXECUTED
);
} else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
(*print_handler)(
106ad8: 52 push %edx <== NOT EXECUTED
106ad9: 52 push %edx <== NOT EXECUTED
106ada: 57 push %edi <== NOT EXECUTED
106adb: 6a 00 push $0x0 <== NOT EXECUTED
106add: 8b 15 f0 51 12 00 mov 0x1251f0,%edx <== NOT EXECUTED
106ae3: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED
106ae7: 52 push %edx <== NOT EXECUTED
106ae8: 50 push %eax <== NOT EXECUTED
106ae9: 68 38 eb 11 00 push $0x11eb38 <== NOT EXECUTED
106aee: ff 35 cc 4e 12 00 pushl 0x124ecc <== NOT EXECUTED
106af4: ff 15 d0 4e 12 00 call *0x124ed0 <== NOT EXECUTED
current,
size
);
if (Stack_check_Initialized == 0) {
(*print_handler)( print_context, "Unavailable\n" );
106afa: 83 c4 18 add $0x18,%esp <== NOT EXECUTED
106afd: 68 56 eb 11 00 push $0x11eb56 <== NOT EXECUTED
106b02: ff 35 cc 4e 12 00 pushl 0x124ecc <== NOT EXECUTED
106b08: ff 15 d0 4e 12 00 call *0x124ed0 <== NOT EXECUTED
106b0e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
}
}
106b11: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
106b14: 5b pop %ebx <== NOT EXECUTED
106b15: 5e pop %esi <== NOT EXECUTED
106b16: 5f pop %edi <== NOT EXECUTED
106b17: c9 leave <== NOT EXECUTED
106b18: c3 ret <== NOT EXECUTED
00106b19 <Stack_check_Initialize>:
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
{
106b19: 55 push %ebp <== NOT EXECUTED
106b1a: 89 e5 mov %esp,%ebp <== NOT EXECUTED
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
}
#endif
Stack_check_Initialized = 1;
}
106b1c: c9 leave <== NOT EXECUTED
106b1d: c3 ret <== NOT EXECUTED
00106b67 <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)
{
106b67: 55 push %ebp <== NOT EXECUTED
106b68: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106b6a: 56 push %esi <== NOT EXECUTED
106b6b: 53 push %ebx <== NOT EXECUTED
106b6c: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED
106b6f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
106b72: 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);
106b75: 8b b3 c8 00 00 00 mov 0xc8(%ebx),%esi <== NOT EXECUTED
char name [32];
printk("BLOWN STACK!!!\n");
106b7b: 68 63 eb 11 00 push $0x11eb63 <== NOT EXECUTED
106b80: 88 55 d4 mov %dl,-0x2c(%ebp) <== NOT EXECUTED
106b83: e8 54 16 00 00 call 1081dc <printk> <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
106b88: 5a pop %edx <== NOT EXECUTED
106b89: 59 pop %ecx <== NOT EXECUTED
106b8a: 53 push %ebx <== NOT EXECUTED
106b8b: 68 73 eb 11 00 push $0x11eb73 <== NOT EXECUTED
106b90: e8 47 16 00 00 call 1081dc <printk> <== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
106b95: 59 pop %ecx <== NOT EXECUTED
106b96: 58 pop %eax <== NOT EXECUTED
106b97: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
106b9a: 68 90 eb 11 00 push $0x11eb90 <== NOT EXECUTED
106b9f: e8 38 16 00 00 call 1081dc <printk> <== NOT EXECUTED
printk(
106ba4: 58 pop %eax <== NOT EXECUTED
106ba5: 5a pop %edx <== NOT EXECUTED
106ba6: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED
106ba9: 68 a2 eb 11 00 push $0x11eba2 <== NOT EXECUTED
106bae: e8 29 16 00 00 call 1081dc <printk> <== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
106bb3: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
106bb6: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED
106bb9: 50 push %eax <== NOT EXECUTED
106bba: 6a 20 push $0x20 <== NOT EXECUTED
106bbc: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
106bbf: e8 90 36 00 00 call 10a254 <rtems_object_get_name> <== NOT EXECUTED
106bc4: 5a pop %edx <== NOT EXECUTED
106bc5: 59 pop %ecx <== NOT EXECUTED
106bc6: 50 push %eax <== NOT EXECUTED
106bc7: 68 b6 eb 11 00 push $0x11ebb6 <== NOT EXECUTED
106bcc: e8 0b 16 00 00 call 1081dc <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)
106bd1: 8b 8b c8 00 00 00 mov 0xc8(%ebx),%ecx <== NOT EXECUTED
106bd7: 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(
106bdd: 8d 1c 01 lea (%ecx,%eax,1),%ebx <== NOT EXECUTED
106be0: 53 push %ebx <== NOT EXECUTED
106be1: 51 push %ecx <== NOT EXECUTED
106be2: 50 push %eax <== NOT EXECUTED
106be3: 68 cc eb 11 00 push $0x11ebcc <== NOT EXECUTED
106be8: e8 ef 15 00 00 call 1081dc <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) {
106bed: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
106bf0: 8a 55 d4 mov -0x2c(%ebp),%dl <== NOT EXECUTED
106bf3: 84 d2 test %dl,%dl <== NOT EXECUTED
106bf5: 75 17 jne 106c0e <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);
106bf7: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
printk(
106bfa: 83 c6 18 add $0x18,%esi <== NOT EXECUTED
106bfd: 56 push %esi <== NOT EXECUTED
106bfe: 50 push %eax <== NOT EXECUTED
106bff: 6a 10 push $0x10 <== NOT EXECUTED
106c01: 68 fd eb 11 00 push $0x11ebfd <== NOT EXECUTED
106c06: e8 d1 15 00 00 call 1081dc <printk> <== NOT EXECUTED
106c0b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
106c0e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106c11: 68 81 00 00 00 push $0x81 <== NOT EXECUTED
106c16: e8 f1 3d 00 00 call 10aa0c <rtems_fatal_error_occurred><== NOT EXECUTED
0010cb5c <_CORE_RWLock_Obtain_for_reading>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
10cb5c: 55 push %ebp
10cb5d: 89 e5 mov %esp,%ebp
10cb5f: 57 push %edi
10cb60: 56 push %esi
10cb61: 53 push %ebx
10cb62: 83 ec 1c sub $0x1c,%esp
10cb65: 8b 5d 08 mov 0x8(%ebp),%ebx
10cb68: 8b 4d 0c mov 0xc(%ebp),%ecx
10cb6b: 8b 45 14 mov 0x14(%ebp),%eax
10cb6e: 89 45 e4 mov %eax,-0x1c(%ebp)
10cb71: 8a 55 10 mov 0x10(%ebp),%dl
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10cb74: 8b 35 44 77 12 00 mov 0x127744,%esi
* If unlocked, then OK to read.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
10cb7a: 9c pushf
10cb7b: fa cli
10cb7c: 5f pop %edi
switch ( the_rwlock->current_state ) {
10cb7d: 8b 43 44 mov 0x44(%ebx),%eax
10cb80: 85 c0 test %eax,%eax
10cb82: 74 05 je 10cb89 <_CORE_RWLock_Obtain_for_reading+0x2d>
10cb84: 48 dec %eax
10cb85: 75 3a jne 10cbc1 <_CORE_RWLock_Obtain_for_reading+0x65>
10cb87: eb 0e jmp 10cb97 <_CORE_RWLock_Obtain_for_reading+0x3b>
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10cb89: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx)
the_rwlock->number_of_readers += 1;
10cb90: ff 43 48 incl 0x48(%ebx)
_ISR_Enable( level );
10cb93: 57 push %edi
10cb94: 9d popf
10cb95: eb 21 jmp 10cbb8 <_CORE_RWLock_Obtain_for_reading+0x5c>
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
return;
case CORE_RWLOCK_LOCKED_FOR_READING: {
Thread_Control *waiter;
waiter = _Thread_queue_First( &the_rwlock->Wait_queue );
10cb97: 83 ec 0c sub $0xc,%esp
10cb9a: 53 push %ebx
10cb9b: 88 55 dc mov %dl,-0x24(%ebp)
10cb9e: 89 4d e0 mov %ecx,-0x20(%ebp)
10cba1: e8 9e 1a 00 00 call 10e644 <_Thread_queue_First>
if ( !waiter ) {
10cba6: 83 c4 10 add $0x10,%esp
10cba9: 85 c0 test %eax,%eax
10cbab: 8a 55 dc mov -0x24(%ebp),%dl
10cbae: 8b 4d e0 mov -0x20(%ebp),%ecx
10cbb1: 75 0e jne 10cbc1 <_CORE_RWLock_Obtain_for_reading+0x65><== NEVER TAKEN
the_rwlock->number_of_readers += 1;
10cbb3: ff 43 48 incl 0x48(%ebx)
_ISR_Enable( level );
10cbb6: 57 push %edi
10cbb7: 9d popf
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10cbb8: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
return;
10cbbf: eb 48 jmp 10cc09 <_CORE_RWLock_Obtain_for_reading+0xad>
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
10cbc1: 84 d2 test %dl,%dl
10cbc3: 75 0b jne 10cbd0 <_CORE_RWLock_Obtain_for_reading+0x74>
_ISR_Enable( level );
10cbc5: 57 push %edi
10cbc6: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10cbc7: c7 46 34 02 00 00 00 movl $0x2,0x34(%esi)
10cbce: eb 39 jmp 10cc09 <_CORE_RWLock_Obtain_for_reading+0xad>
10cbd0: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
/*
* We need to wait to enter this critical section
*/
_Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue );
executing->Wait.queue = &the_rwlock->Wait_queue;
10cbd7: 89 5e 44 mov %ebx,0x44(%esi)
executing->Wait.id = id;
10cbda: 89 4e 20 mov %ecx,0x20(%esi)
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
10cbdd: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi)
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10cbe4: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
_ISR_Enable( level );
10cbeb: 57 push %edi
10cbec: 9d popf
_Thread_queue_Enqueue_with_handler(
10cbed: c7 45 10 38 cd 10 00 movl $0x10cd38,0x10(%ebp)
10cbf4: 8b 45 e4 mov -0x1c(%ebp),%eax
10cbf7: 89 45 0c mov %eax,0xc(%ebp)
10cbfa: 89 5d 08 mov %ebx,0x8(%ebp)
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10cbfd: 8d 65 f4 lea -0xc(%ebp),%esp
10cc00: 5b pop %ebx
10cc01: 5e pop %esi
10cc02: 5f pop %edi
10cc03: c9 leave
executing->Wait.id = id;
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
_ISR_Enable( level );
_Thread_queue_Enqueue_with_handler(
10cc04: e9 57 17 00 00 jmp 10e360 <_Thread_queue_Enqueue_with_handler>
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10cc09: 8d 65 f4 lea -0xc(%ebp),%esp
10cc0c: 5b pop %ebx
10cc0d: 5e pop %esi
10cc0e: 5f pop %edi
10cc0f: c9 leave
10cc10: c3 ret
0010cc98 <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
10cc98: 55 push %ebp
10cc99: 89 e5 mov %esp,%ebp
10cc9b: 53 push %ebx
10cc9c: 83 ec 04 sub $0x4,%esp
10cc9f: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10cca2: 8b 15 44 77 12 00 mov 0x127744,%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 );
10cca8: 9c pushf
10cca9: fa cli
10ccaa: 58 pop %eax
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
10ccab: 8b 4b 44 mov 0x44(%ebx),%ecx
10ccae: 85 c9 test %ecx,%ecx
10ccb0: 75 0b jne 10ccbd <_CORE_RWLock_Release+0x25>
_ISR_Enable( level );
10ccb2: 50 push %eax
10ccb3: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10ccb4: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx)
return CORE_RWLOCK_SUCCESSFUL;
10ccbb: eb 72 jmp 10cd2f <_CORE_RWLock_Release+0x97>
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
10ccbd: 49 dec %ecx
10ccbe: 75 0f jne 10cccf <_CORE_RWLock_Release+0x37>
the_rwlock->number_of_readers -= 1;
10ccc0: 8b 4b 48 mov 0x48(%ebx),%ecx
10ccc3: 49 dec %ecx
10ccc4: 89 4b 48 mov %ecx,0x48(%ebx)
if ( the_rwlock->number_of_readers != 0 ) {
10ccc7: 85 c9 test %ecx,%ecx
10ccc9: 74 04 je 10cccf <_CORE_RWLock_Release+0x37>
/* must be unlocked again */
_ISR_Enable( level );
10cccb: 50 push %eax
10cccc: 9d popf
return CORE_RWLOCK_SUCCESSFUL;
10cccd: eb 60 jmp 10cd2f <_CORE_RWLock_Release+0x97>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10cccf: 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;
10ccd6: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
_ISR_Enable( level );
10ccdd: 50 push %eax
10ccde: 9d popf
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
10ccdf: 83 ec 0c sub $0xc,%esp
10cce2: 53 push %ebx
10cce3: e8 70 15 00 00 call 10e258 <_Thread_queue_Dequeue>
if ( next ) {
10cce8: 83 c4 10 add $0x10,%esp
10cceb: 85 c0 test %eax,%eax
10cced: 74 40 je 10cd2f <_CORE_RWLock_Release+0x97>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
10ccef: 83 78 30 01 cmpl $0x1,0x30(%eax)
10ccf3: 75 09 jne 10ccfe <_CORE_RWLock_Release+0x66>
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
10ccf5: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx)
return CORE_RWLOCK_SUCCESSFUL;
10ccfc: eb 31 jmp 10cd2f <_CORE_RWLock_Release+0x97>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
10ccfe: ff 43 48 incl 0x48(%ebx)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10cd01: 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 );
10cd08: 83 ec 0c sub $0xc,%esp
10cd0b: 53 push %ebx
10cd0c: e8 33 19 00 00 call 10e644 <_Thread_queue_First>
if ( !next ||
10cd11: 83 c4 10 add $0x10,%esp
10cd14: 85 c0 test %eax,%eax
10cd16: 74 17 je 10cd2f <_CORE_RWLock_Release+0x97>
10cd18: 83 78 30 01 cmpl $0x1,0x30(%eax)
10cd1c: 74 11 je 10cd2f <_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;
10cd1e: ff 43 48 incl 0x48(%ebx)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
10cd21: 52 push %edx
10cd22: 52 push %edx
10cd23: 50 push %eax
10cd24: 53 push %ebx
10cd25: e8 0e 18 00 00 call 10e538 <_Thread_queue_Extract>
}
10cd2a: 83 c4 10 add $0x10,%esp
10cd2d: eb d9 jmp 10cd08 <_CORE_RWLock_Release+0x70>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10cd2f: 31 c0 xor %eax,%eax
10cd31: 8b 5d fc mov -0x4(%ebp),%ebx
10cd34: c9 leave
10cd35: c3 ret
0010cd38 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
10cd38: 55 push %ebp
10cd39: 89 e5 mov %esp,%ebp
10cd3b: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10cd3e: 8d 45 f4 lea -0xc(%ebp),%eax
10cd41: 50 push %eax
10cd42: ff 75 08 pushl 0x8(%ebp)
10cd45: e8 ae 11 00 00 call 10def8 <_Thread_Get>
switch ( location ) {
10cd4a: 83 c4 10 add $0x10,%esp
10cd4d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10cd51: 75 17 jne 10cd6a <_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 );
10cd53: 83 ec 0c sub $0xc,%esp
10cd56: 50 push %eax
10cd57: e8 b4 19 00 00 call 10e710 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10cd5c: a1 f4 71 12 00 mov 0x1271f4,%eax
10cd61: 48 dec %eax
10cd62: a3 f4 71 12 00 mov %eax,0x1271f4
10cd67: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10cd6a: c9 leave
10cd6b: c3 ret
00117458 <_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
)
{
117458: 55 push %ebp
117459: 89 e5 mov %esp,%ebp
11745b: 57 push %edi
11745c: 56 push %esi
11745d: 53 push %ebx
11745e: 83 ec 1c sub $0x1c,%esp
117461: 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;
117464: 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 ) {
117469: 8b 55 10 mov 0x10(%ebp),%edx
11746c: 3b 53 4c cmp 0x4c(%ebx),%edx
11746f: 77 4e ja 1174bf <_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 ) {
117471: 83 7b 48 00 cmpl $0x0,0x48(%ebx)
117475: 75 09 jne 117480 <_CORE_message_queue_Broadcast+0x28>
117477: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
11747e: eb 23 jmp 1174a3 <_CORE_message_queue_Broadcast+0x4b>
*count = 0;
117480: 8b 45 1c mov 0x1c(%ebp),%eax
117483: c7 00 00 00 00 00 movl $0x0,(%eax)
117489: eb 32 jmp 1174bd <_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;
11748b: ff 45 e4 incl -0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
11748e: 8b 42 2c mov 0x2c(%edx),%eax
117491: 89 c7 mov %eax,%edi
117493: 8b 75 0c mov 0xc(%ebp),%esi
117496: 8b 4d 10 mov 0x10(%ebp),%ecx
117499: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
11749b: 8b 42 28 mov 0x28(%edx),%eax
11749e: 8b 55 10 mov 0x10(%ebp),%edx
1174a1: 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 =
1174a3: 83 ec 0c sub $0xc,%esp
1174a6: 53 push %ebx
1174a7: e8 94 22 00 00 call 119740 <_Thread_queue_Dequeue>
1174ac: 89 c2 mov %eax,%edx
1174ae: 83 c4 10 add $0x10,%esp
1174b1: 85 c0 test %eax,%eax
1174b3: 75 d6 jne 11748b <_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;
1174b5: 8b 55 e4 mov -0x1c(%ebp),%edx
1174b8: 8b 45 1c mov 0x1c(%ebp),%eax
1174bb: 89 10 mov %edx,(%eax)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
1174bd: 31 c0 xor %eax,%eax
}
1174bf: 8d 65 f4 lea -0xc(%ebp),%esp
1174c2: 5b pop %ebx
1174c3: 5e pop %esi
1174c4: 5f pop %edi
1174c5: c9 leave
1174c6: c3 ret
00112278 <_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
)
{
112278: 55 push %ebp
112279: 89 e5 mov %esp,%ebp
11227b: 57 push %edi
11227c: 56 push %esi
11227d: 53 push %ebx
11227e: 83 ec 1c sub $0x1c,%esp
112281: 8b 5d 08 mov 0x8(%ebp),%ebx
112284: 8b 7d 10 mov 0x10(%ebp),%edi
112287: 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;
11228a: 89 7b 44 mov %edi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
11228d: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
112294: 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;
112297: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
the_message_queue->notify_argument = the_argument;
11229e: 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)) {
1122a5: 89 d0 mov %edx,%eax
1122a7: f6 c2 03 test $0x3,%dl
1122aa: 74 0c je 1122b8 <_CORE_message_queue_Initialize+0x40>
allocated_message_size += sizeof(uint32_t);
1122ac: 83 c0 04 add $0x4,%eax
allocated_message_size &= ~(sizeof(uint32_t) - 1);
1122af: 83 e0 fc and $0xfffffffc,%eax
}
if (allocated_message_size < maximum_message_size)
return false;
1122b2: 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)
1122b4: 39 d0 cmp %edx,%eax
1122b6: 72 68 jb 112320 <_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));
1122b8: 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 *
1122bb: 89 d1 mov %edx,%ecx
1122bd: 0f af cf imul %edi,%ecx
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
return false;
1122c0: 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)
1122c2: 39 c1 cmp %eax,%ecx
1122c4: 72 5a jb 112320 <_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 );
1122c6: 83 ec 0c sub $0xc,%esp
1122c9: 51 push %ecx
1122ca: 89 55 e4 mov %edx,-0x1c(%ebp)
1122cd: e8 a8 26 00 00 call 11497a <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
1122d2: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
1122d5: 83 c4 10 add $0x10,%esp
1122d8: 85 c0 test %eax,%eax
1122da: 8b 55 e4 mov -0x1c(%ebp),%edx
1122dd: 74 41 je 112320 <_CORE_message_queue_Initialize+0xa8>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
1122df: 52 push %edx
1122e0: 57 push %edi
1122e1: 50 push %eax
1122e2: 8d 43 68 lea 0x68(%ebx),%eax
1122e5: 50 push %eax
1122e6: e8 7d 49 00 00 call 116c68 <_Chain_Initialize>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
1122eb: 8d 43 54 lea 0x54(%ebx),%eax
1122ee: 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;
1122f1: 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 );
1122f8: 8d 43 50 lea 0x50(%ebx),%eax
1122fb: 89 43 58 mov %eax,0x58(%ebx)
_Thread_queue_Initialize(
1122fe: 6a 06 push $0x6
112300: 68 80 00 00 00 push $0x80
112305: 8b 45 0c mov 0xc(%ebp),%eax
112308: 83 38 01 cmpl $0x1,(%eax)
11230b: 0f 94 c0 sete %al
11230e: 0f b6 c0 movzbl %al,%eax
112311: 50 push %eax
112312: 53 push %ebx
112313: e8 0c 1d 00 00 call 114024 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
112318: 83 c4 20 add $0x20,%esp
11231b: be 01 00 00 00 mov $0x1,%esi
}
112320: 89 f0 mov %esi,%eax
112322: 8d 65 f4 lea -0xc(%ebp),%esp
112325: 5b pop %ebx
112326: 5e pop %esi
112327: 5f pop %edi
112328: c9 leave
112329: c3 ret
0011232c <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
11232c: 55 push %ebp
11232d: 89 e5 mov %esp,%ebp
11232f: 57 push %edi
112330: 56 push %esi
112331: 53 push %ebx
112332: 83 ec 2c sub $0x2c,%esp
112335: 8b 55 08 mov 0x8(%ebp),%edx
112338: 8b 45 0c mov 0xc(%ebp),%eax
11233b: 89 45 dc mov %eax,-0x24(%ebp)
11233e: 8b 5d 10 mov 0x10(%ebp),%ebx
112341: 89 5d e0 mov %ebx,-0x20(%ebp)
112344: 8b 4d 14 mov 0x14(%ebp),%ecx
112347: 8b 75 1c mov 0x1c(%ebp),%esi
11234a: 89 75 d4 mov %esi,-0x2c(%ebp)
11234d: 8a 45 18 mov 0x18(%ebp),%al
112350: 88 45 db mov %al,-0x25(%ebp)
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
112353: a1 9c c8 12 00 mov 0x12c89c,%eax
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
112358: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_ISR_Disable( level );
11235f: 9c pushf
112360: fa cli
112361: 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));
112364: 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;
112367: 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))
11236a: 39 f3 cmp %esi,%ebx
11236c: 0f 84 8a 00 00 00 je 1123fc <_CORE_message_queue_Seize+0xd0>
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
112372: 8b 33 mov (%ebx),%esi
the_chain->first = new_first;
112374: 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 );
112377: 8d 7a 50 lea 0x50(%edx),%edi
11237a: 89 7e 04 mov %edi,0x4(%esi)
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
11237d: 85 db test %ebx,%ebx
11237f: 74 7b je 1123fc <_CORE_message_queue_Seize+0xd0><== NEVER TAKEN
the_message_queue->number_of_pending_messages -= 1;
112381: ff 4a 48 decl 0x48(%edx)
_ISR_Enable( level );
112384: ff 75 e4 pushl -0x1c(%ebp)
112387: 9d popf
*size_p = the_message->Contents.size;
112388: 8b 43 0c mov 0xc(%ebx),%eax
11238b: 89 01 mov %eax,(%ecx)
_Thread_Executing->Wait.count =
11238d: 8b 73 08 mov 0x8(%ebx),%esi
112390: a1 9c c8 12 00 mov 0x12c89c,%eax
112395: 89 70 24 mov %esi,0x24(%eax)
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
112398: 8d 73 10 lea 0x10(%ebx),%esi
11239b: 89 75 e4 mov %esi,-0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
11239e: 8b 09 mov (%ecx),%ecx
1123a0: 8b 7d e0 mov -0x20(%ebp),%edi
1123a3: 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 );
1123a5: 83 ec 0c sub $0xc,%esp
1123a8: 52 push %edx
1123a9: 89 55 d0 mov %edx,-0x30(%ebp)
1123ac: e8 43 19 00 00 call 113cf4 <_Thread_queue_Dequeue>
if ( !the_thread ) {
1123b1: 83 c4 10 add $0x10,%esp
1123b4: 85 c0 test %eax,%eax
1123b6: 8b 55 d0 mov -0x30(%ebp),%edx
1123b9: 75 15 jne 1123d0 <_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 );
1123bb: 89 5d 0c mov %ebx,0xc(%ebp)
1123be: 83 c2 68 add $0x68,%edx
1123c1: 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 );
}
1123c4: 8d 65 f4 lea -0xc(%ebp),%esp
1123c7: 5b pop %ebx
1123c8: 5e pop %esi
1123c9: 5f pop %edi
1123ca: c9 leave
1123cb: e9 28 fe ff ff jmp 1121f8 <_Chain_Append>
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
1123d0: 8b 48 24 mov 0x24(%eax),%ecx
1123d3: 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;
1123d6: 8b 48 30 mov 0x30(%eax),%ecx
1123d9: 89 4b 0c mov %ecx,0xc(%ebx)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
1123dc: 8b 70 2c mov 0x2c(%eax),%esi
1123df: 8b 7d e4 mov -0x1c(%ebp),%edi
1123e2: 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(
1123e4: 8b 43 08 mov 0x8(%ebx),%eax
1123e7: 89 45 10 mov %eax,0x10(%ebp)
1123ea: 89 5d 0c mov %ebx,0xc(%ebp)
1123ed: 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 );
}
1123f0: 8d 65 f4 lea -0xc(%ebp),%esp
1123f3: 5b pop %ebx
1123f4: 5e pop %esi
1123f5: 5f pop %edi
1123f6: c9 leave
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
1123f7: e9 a4 48 00 00 jmp 116ca0 <_CORE_message_queue_Insert_message>
return;
}
#endif
}
if ( !wait ) {
1123fc: 80 7d db 00 cmpb $0x0,-0x25(%ebp)
112400: 75 13 jne 112415 <_CORE_message_queue_Seize+0xe9>
_ISR_Enable( level );
112402: ff 75 e4 pushl -0x1c(%ebp)
112405: 9d popf
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
112406: 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 );
}
11240d: 8d 65 f4 lea -0xc(%ebp),%esp
112410: 5b pop %ebx
112411: 5e pop %esi
112412: 5f pop %edi
112413: c9 leave
112414: 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;
112415: 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;
11241c: 89 50 44 mov %edx,0x44(%eax)
executing->Wait.id = id;
11241f: 8b 5d dc mov -0x24(%ebp),%ebx
112422: 89 58 20 mov %ebx,0x20(%eax)
executing->Wait.return_argument_second.mutable_object = buffer;
112425: 8b 75 e0 mov -0x20(%ebp),%esi
112428: 89 70 2c mov %esi,0x2c(%eax)
executing->Wait.return_argument = size_p;
11242b: 89 48 28 mov %ecx,0x28(%eax)
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
11242e: ff 75 e4 pushl -0x1c(%ebp)
112431: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
112432: c7 45 10 d4 40 11 00 movl $0x1140d4,0x10(%ebp)
112439: 8b 45 d4 mov -0x2c(%ebp),%eax
11243c: 89 45 0c mov %eax,0xc(%ebp)
11243f: 89 55 08 mov %edx,0x8(%ebp)
}
112442: 8d 65 f4 lea -0xc(%ebp),%esp
112445: 5b pop %ebx
112446: 5e pop %esi
112447: 5f pop %edi
112448: 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 );
112449: e9 ae 19 00 00 jmp 113dfc <_Thread_queue_Enqueue_with_handler>
0010ab98 <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
10ab98: 55 push %ebp
10ab99: 89 e5 mov %esp,%ebp
10ab9b: 57 push %edi
10ab9c: 56 push %esi
10ab9d: 53 push %ebx
10ab9e: 83 ec 0c sub $0xc,%esp
10aba1: 8b 55 08 mov 0x8(%ebp),%edx
10aba4: 8b 5d 0c mov 0xc(%ebp),%ebx
10aba7: 8b 45 10 mov 0x10(%ebp),%eax
/* Add this to the RTEMS environment later ?????????
rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||
initial_lock == CORE_MUTEX_UNLOCKED );
*/
the_mutex->Attributes = *the_mutex_attributes;
10abaa: 8d 7a 40 lea 0x40(%edx),%edi
10abad: b9 04 00 00 00 mov $0x4,%ecx
10abb2: 89 de mov %ebx,%esi
10abb4: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_mutex->lock = initial_lock;
10abb6: 89 42 50 mov %eax,0x50(%edx)
the_mutex->blocked_count = 0;
10abb9: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx)
if ( initial_lock == CORE_MUTEX_LOCKED ) {
10abc0: 85 c0 test %eax,%eax
10abc2: 75 35 jne 10abf9 <_CORE_mutex_Initialize+0x61>
the_mutex->nest_count = 1;
10abc4: c7 42 54 01 00 00 00 movl $0x1,0x54(%edx)
the_mutex->holder = _Thread_Executing;
10abcb: 8b 0d 34 47 12 00 mov 0x124734,%ecx
10abd1: 89 4a 5c mov %ecx,0x5c(%edx)
the_mutex->holder_id = _Thread_Executing->Object.id;
10abd4: 8b 41 08 mov 0x8(%ecx),%eax
10abd7: 89 42 60 mov %eax,0x60(%edx)
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10abda: 8b 42 48 mov 0x48(%edx),%eax
if ( initial_lock == CORE_MUTEX_LOCKED ) {
the_mutex->nest_count = 1;
the_mutex->holder = _Thread_Executing;
the_mutex->holder_id = _Thread_Executing->Object.id;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
10abdd: 83 f8 02 cmp $0x2,%eax
10abe0: 74 05 je 10abe7 <_CORE_mutex_Initialize+0x4f>
10abe2: 83 f8 03 cmp $0x3,%eax
10abe5: 75 27 jne 10ac0e <_CORE_mutex_Initialize+0x76>
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
the_mutex->Attributes.priority_ceiling )
return CORE_MUTEX_STATUS_CEILING_VIOLATED;
10abe7: b8 06 00 00 00 mov $0x6,%eax
the_mutex->holder = _Thread_Executing;
the_mutex->holder_id = _Thread_Executing->Object.id;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
10abec: 8b 72 4c mov 0x4c(%edx),%esi
10abef: 39 71 14 cmp %esi,0x14(%ecx)
10abf2: 72 36 jb 10ac2a <_CORE_mutex_Initialize+0x92><== NEVER TAKEN
_Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = _Thread_Executing->current_priority;
#endif
_Thread_Executing->resource_count++;
10abf4: ff 41 1c incl 0x1c(%ecx)
10abf7: eb 15 jmp 10ac0e <_CORE_mutex_Initialize+0x76>
}
} else {
the_mutex->nest_count = 0;
10abf9: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx)
the_mutex->holder = NULL;
10ac00: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx)
the_mutex->holder_id = 0;
10ac07: c7 42 60 00 00 00 00 movl $0x0,0x60(%edx)
}
_Thread_queue_Initialize(
10ac0e: 6a 05 push $0x5
10ac10: 68 00 04 00 00 push $0x400
10ac15: 31 c0 xor %eax,%eax
10ac17: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10ac1b: 0f 95 c0 setne %al
10ac1e: 50 push %eax
10ac1f: 52 push %edx
10ac20: e8 c3 19 00 00 call 10c5e8 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY,
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
10ac25: 83 c4 10 add $0x10,%esp
10ac28: 31 c0 xor %eax,%eax
}
10ac2a: 8d 65 f4 lea -0xc(%ebp),%esp
10ac2d: 5b pop %ebx
10ac2e: 5e pop %esi
10ac2f: 5f pop %edi
10ac30: c9 leave
10ac31: c3 ret
0010ac81 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10ac81: 55 push %ebp
10ac82: 89 e5 mov %esp,%ebp
10ac84: 53 push %ebx
10ac85: 83 ec 14 sub $0x14,%esp
10ac88: 8b 5d 08 mov 0x8(%ebp),%ebx
10ac8b: 8a 55 10 mov 0x10(%ebp),%dl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10ac8e: a1 e4 41 12 00 mov 0x1241e4,%eax
10ac93: 85 c0 test %eax,%eax
10ac95: 74 19 je 10acb0 <_CORE_mutex_Seize+0x2f>
10ac97: 84 d2 test %dl,%dl
10ac99: 74 15 je 10acb0 <_CORE_mutex_Seize+0x2f><== NEVER TAKEN
10ac9b: 83 3d 64 43 12 00 01 cmpl $0x1,0x124364
10aca2: 76 0c jbe 10acb0 <_CORE_mutex_Seize+0x2f>
10aca4: 53 push %ebx
10aca5: 6a 12 push $0x12
10aca7: 6a 00 push $0x0
10aca9: 6a 00 push $0x0
10acab: e8 f0 05 00 00 call 10b2a0 <_Internal_error_Occurred>
10acb0: 51 push %ecx
10acb1: 51 push %ecx
10acb2: 8d 45 18 lea 0x18(%ebp),%eax
10acb5: 50 push %eax
10acb6: 53 push %ebx
10acb7: 88 55 f4 mov %dl,-0xc(%ebp)
10acba: e8 25 46 00 00 call 10f2e4 <_CORE_mutex_Seize_interrupt_trylock>
10acbf: 83 c4 10 add $0x10,%esp
10acc2: 85 c0 test %eax,%eax
10acc4: 8a 55 f4 mov -0xc(%ebp),%dl
10acc7: 74 48 je 10ad11 <_CORE_mutex_Seize+0x90>
10acc9: 84 d2 test %dl,%dl
10accb: 75 12 jne 10acdf <_CORE_mutex_Seize+0x5e>
10accd: ff 75 18 pushl 0x18(%ebp)
10acd0: 9d popf
10acd1: a1 34 47 12 00 mov 0x124734,%eax
10acd6: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
10acdd: eb 32 jmp 10ad11 <_CORE_mutex_Seize+0x90>
10acdf: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
10ace6: a1 34 47 12 00 mov 0x124734,%eax
10aceb: 89 58 44 mov %ebx,0x44(%eax)
10acee: 8b 55 0c mov 0xc(%ebp),%edx
10acf1: 89 50 20 mov %edx,0x20(%eax)
10acf4: a1 e4 41 12 00 mov 0x1241e4,%eax
10acf9: 40 inc %eax
10acfa: a3 e4 41 12 00 mov %eax,0x1241e4
10acff: ff 75 18 pushl 0x18(%ebp)
10ad02: 9d popf
10ad03: 50 push %eax
10ad04: 50 push %eax
10ad05: ff 75 14 pushl 0x14(%ebp)
10ad08: 53 push %ebx
10ad09: e8 26 ff ff ff call 10ac34 <_CORE_mutex_Seize_interrupt_blocking>
10ad0e: 83 c4 10 add $0x10,%esp
}
10ad11: 8b 5d fc mov -0x4(%ebp),%ebx
10ad14: c9 leave
10ad15: c3 ret
0010ae3c <_CORE_semaphore_Surrender>:
CORE_semaphore_Status _CORE_semaphore_Surrender(
CORE_semaphore_Control *the_semaphore,
Objects_Id id,
CORE_semaphore_API_mp_support_callout api_semaphore_mp_support
)
{
10ae3c: 55 push %ebp
10ae3d: 89 e5 mov %esp,%ebp
10ae3f: 53 push %ebx
10ae40: 83 ec 10 sub $0x10,%esp
10ae43: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
10ae46: 53 push %ebx
10ae47: e8 6c 14 00 00 call 10c2b8 <_Thread_queue_Dequeue>
10ae4c: 89 c2 mov %eax,%edx
10ae4e: 83 c4 10 add $0x10,%esp
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10ae51: 31 c0 xor %eax,%eax
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
10ae53: 85 d2 test %edx,%edx
10ae55: 75 15 jne 10ae6c <_CORE_semaphore_Surrender+0x30>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
10ae57: 9c pushf
10ae58: fa cli
10ae59: 59 pop %ecx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10ae5a: 8b 53 48 mov 0x48(%ebx),%edx
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
10ae5d: b0 04 mov $0x4,%al
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10ae5f: 3b 53 40 cmp 0x40(%ebx),%edx
10ae62: 73 06 jae 10ae6a <_CORE_semaphore_Surrender+0x2e><== NEVER TAKEN
the_semaphore->count += 1;
10ae64: 42 inc %edx
10ae65: 89 53 48 mov %edx,0x48(%ebx)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10ae68: 30 c0 xor %al,%al
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
10ae6a: 51 push %ecx
10ae6b: 9d popf
}
return status;
}
10ae6c: 8b 5d fc mov -0x4(%ebp),%ebx
10ae6f: c9 leave
10ae70: c3 ret
00109c58 <_Event_Seize>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
109c58: 55 push %ebp
109c59: 89 e5 mov %esp,%ebp
109c5b: 57 push %edi
109c5c: 56 push %esi
109c5d: 53 push %ebx
109c5e: 83 ec 1c sub $0x1c,%esp
109c61: 8b 45 08 mov 0x8(%ebp),%eax
109c64: 8b 75 0c mov 0xc(%ebp),%esi
109c67: 8b 55 10 mov 0x10(%ebp),%edx
109c6a: 89 55 dc mov %edx,-0x24(%ebp)
109c6d: 8b 4d 14 mov 0x14(%ebp),%ecx
rtems_event_set pending_events;
ISR_Level level;
RTEMS_API_Control *api;
Thread_blocking_operation_States sync_state;
executing = _Thread_Executing;
109c70: 8b 1d 34 47 12 00 mov 0x124734,%ebx
executing->Wait.return_code = RTEMS_SUCCESSFUL;
109c76: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
109c7d: 8b bb f4 00 00 00 mov 0xf4(%ebx),%edi
_ISR_Disable( level );
109c83: 9c pushf
109c84: fa cli
109c85: 8f 45 e0 popl -0x20(%ebp)
pending_events = api->pending_events;
109c88: 8b 17 mov (%edi),%edx
109c8a: 89 55 e4 mov %edx,-0x1c(%ebp)
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
109c8d: 21 c2 and %eax,%edx
109c8f: 74 1b je 109cac <_Event_Seize+0x54>
109c91: 39 c2 cmp %eax,%edx
109c93: 74 08 je 109c9d <_Event_Seize+0x45>
(seized_events == event_in || _Options_Is_any( option_set )) ) {
109c95: f7 c6 02 00 00 00 test $0x2,%esi
109c9b: 74 0f je 109cac <_Event_Seize+0x54> <== 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) );
109c9d: 89 d0 mov %edx,%eax
109c9f: f7 d0 not %eax
109ca1: 23 45 e4 and -0x1c(%ebp),%eax
109ca4: 89 07 mov %eax,(%edi)
api->pending_events =
_Event_sets_Clear( pending_events, seized_events );
_ISR_Enable( level );
109ca6: ff 75 e0 pushl -0x20(%ebp)
109ca9: 9d popf
109caa: eb 13 jmp 109cbf <_Event_Seize+0x67>
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
109cac: f7 c6 01 00 00 00 test $0x1,%esi
109cb2: 74 12 je 109cc6 <_Event_Seize+0x6e>
_ISR_Enable( level );
109cb4: ff 75 e0 pushl -0x20(%ebp)
109cb7: 9d popf
executing->Wait.return_code = RTEMS_UNSATISFIED;
109cb8: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx)
*event_out = seized_events;
109cbf: 89 11 mov %edx,(%ecx)
return;
109cc1: e9 91 00 00 00 jmp 109d57 <_Event_Seize+0xff>
* set properly when we are marked as in the event critical section.
*
* NOTE: Since interrupts are disabled, this isn't that much of an
* issue but better safe than sorry.
*/
executing->Wait.option = (uint32_t) option_set;
109cc6: 89 73 30 mov %esi,0x30(%ebx)
executing->Wait.count = (uint32_t) event_in;
109cc9: 89 43 24 mov %eax,0x24(%ebx)
executing->Wait.return_argument = event_out;
109ccc: 89 4b 28 mov %ecx,0x28(%ebx)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
109ccf: c7 05 e4 4a 12 00 01 movl $0x1,0x124ae4
109cd6: 00 00 00
_ISR_Enable( level );
109cd9: ff 75 e0 pushl -0x20(%ebp)
109cdc: 9d popf
if ( ticks ) {
109cdd: 83 7d dc 00 cmpl $0x0,-0x24(%ebp)
109ce1: 74 34 je 109d17 <_Event_Seize+0xbf>
_Watchdog_Initialize(
109ce3: 8b 43 08 mov 0x8(%ebx),%eax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
109ce6: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
109ced: c7 43 64 94 9e 10 00 movl $0x109e94,0x64(%ebx)
the_watchdog->id = id;
109cf4: 89 43 68 mov %eax,0x68(%ebx)
the_watchdog->user_data = user_data;
109cf7: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
109cfe: 8b 45 dc mov -0x24(%ebp),%eax
109d01: 89 43 54 mov %eax,0x54(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
109d04: 52 push %edx
109d05: 52 push %edx
&executing->Timer,
_Event_Timeout,
executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
109d06: 8d 43 48 lea 0x48(%ebx),%eax
109d09: 50 push %eax
109d0a: 68 ac 42 12 00 push $0x1242ac
109d0f: e8 f8 2f 00 00 call 10cd0c <_Watchdog_Insert>
109d14: 83 c4 10 add $0x10,%esp
}
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
109d17: 50 push %eax
109d18: 50 push %eax
109d19: 68 00 01 00 00 push $0x100
109d1e: 53 push %ebx
109d1f: e8 10 2a 00 00 call 10c734 <_Thread_Set_state>
_ISR_Disable( level );
109d24: 9c pushf
109d25: fa cli
109d26: 5a pop %edx
sync_state = _Event_Sync_state;
109d27: a1 e4 4a 12 00 mov 0x124ae4,%eax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
109d2c: c7 05 e4 4a 12 00 00 movl $0x0,0x124ae4
109d33: 00 00 00
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
109d36: 83 c4 10 add $0x10,%esp
109d39: 83 f8 01 cmp $0x1,%eax
109d3c: 75 04 jne 109d42 <_Event_Seize+0xea>
_ISR_Enable( level );
109d3e: 52 push %edx
109d3f: 9d popf
109d40: eb 15 jmp 109d57 <_Event_Seize+0xff>
* An interrupt completed the thread's blocking request.
* The blocking thread was satisfied by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
_Thread_blocking_operation_Cancel( sync_state, executing, level );
109d42: 89 55 10 mov %edx,0x10(%ebp)
109d45: 89 5d 0c mov %ebx,0xc(%ebp)
109d48: 89 45 08 mov %eax,0x8(%ebp)
}
109d4b: 8d 65 f4 lea -0xc(%ebp),%esp
109d4e: 5b pop %ebx
109d4f: 5e pop %esi
109d50: 5f pop %edi
109d51: c9 leave
* An interrupt completed the thread's blocking request.
* The blocking thread was satisfied by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
_Thread_blocking_operation_Cancel( sync_state, executing, level );
109d52: e9 01 1d 00 00 jmp 10ba58 <_Thread_blocking_operation_Cancel>
}
109d57: 8d 65 f4 lea -0xc(%ebp),%esp
109d5a: 5b pop %ebx
109d5b: 5e pop %esi
109d5c: 5f pop %edi
109d5d: c9 leave
109d5e: c3 ret
00109dac <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
109dac: 55 push %ebp
109dad: 89 e5 mov %esp,%ebp
109daf: 57 push %edi
109db0: 56 push %esi
109db1: 53 push %ebx
109db2: 83 ec 2c sub $0x2c,%esp
109db5: 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 ];
109db8: 8b bb f4 00 00 00 mov 0xf4(%ebx),%edi
option_set = (rtems_option) the_thread->Wait.option;
109dbe: 8b 43 30 mov 0x30(%ebx),%eax
109dc1: 89 45 e0 mov %eax,-0x20(%ebp)
_ISR_Disable( level );
109dc4: 9c pushf
109dc5: fa cli
109dc6: 58 pop %eax
pending_events = api->pending_events;
109dc7: 8b 17 mov (%edi),%edx
109dc9: 89 55 d4 mov %edx,-0x2c(%ebp)
event_condition = (rtems_event_set) the_thread->Wait.count;
109dcc: 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 ) ) {
109dcf: 21 f2 and %esi,%edx
109dd1: 75 07 jne 109dda <_Event_Surrender+0x2e>
_ISR_Enable( level );
109dd3: 50 push %eax
109dd4: 9d popf
return;
109dd5: e9 af 00 00 00 jmp 109e89 <_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() &&
109dda: 83 3d 30 47 12 00 00 cmpl $0x0,0x124730
109de1: 74 49 je 109e2c <_Event_Surrender+0x80>
109de3: 3b 1d 34 47 12 00 cmp 0x124734,%ebx
109de9: 75 41 jne 109e2c <_Event_Surrender+0x80>
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
109deb: 8b 0d e4 4a 12 00 mov 0x124ae4,%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 ) &&
109df1: 83 f9 02 cmp $0x2,%ecx
109df4: 74 09 je 109dff <_Event_Surrender+0x53> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
109df6: 8b 0d e4 4a 12 00 mov 0x124ae4,%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) ||
109dfc: 49 dec %ecx
109dfd: 75 2d jne 109e2c <_Event_Surrender+0x80>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
109dff: 39 f2 cmp %esi,%edx
109e01: 74 06 je 109e09 <_Event_Surrender+0x5d>
109e03: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109e07: 74 1f je 109e28 <_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) );
109e09: 89 d6 mov %edx,%esi
109e0b: f7 d6 not %esi
109e0d: 23 75 d4 and -0x2c(%ebp),%esi
109e10: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
109e12: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109e19: 8b 4b 28 mov 0x28(%ebx),%ecx
109e1c: 89 11 mov %edx,(%ecx)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
109e1e: c7 05 e4 4a 12 00 03 movl $0x3,0x124ae4
109e25: 00 00 00
}
_ISR_Enable( level );
109e28: 50 push %eax
109e29: 9d popf
return;
109e2a: eb 5d jmp 109e89 <_Event_Surrender+0xdd>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
109e2c: f6 43 11 01 testb $0x1,0x11(%ebx)
109e30: 74 55 je 109e87 <_Event_Surrender+0xdb>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
109e32: 39 f2 cmp %esi,%edx
109e34: 74 06 je 109e3c <_Event_Surrender+0x90>
109e36: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109e3a: 74 4b je 109e87 <_Event_Surrender+0xdb> <== NEVER TAKEN
109e3c: 89 d6 mov %edx,%esi
109e3e: f7 d6 not %esi
109e40: 23 75 d4 and -0x2c(%ebp),%esi
109e43: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
109e45: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109e4c: 8b 4b 28 mov 0x28(%ebx),%ecx
109e4f: 89 11 mov %edx,(%ecx)
_ISR_Flash( level );
109e51: 50 push %eax
109e52: 9d popf
109e53: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
109e54: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
109e58: 74 06 je 109e60 <_Event_Surrender+0xb4>
_ISR_Enable( level );
109e5a: 50 push %eax
109e5b: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
109e5c: 51 push %ecx
109e5d: 51 push %ecx
109e5e: eb 17 jmp 109e77 <_Event_Surrender+0xcb>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
109e60: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
109e67: 50 push %eax
109e68: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
109e69: 83 ec 0c sub $0xc,%esp
109e6c: 8d 43 48 lea 0x48(%ebx),%eax
109e6f: 50 push %eax
109e70: e8 af 2f 00 00 call 10ce24 <_Watchdog_Remove>
109e75: 58 pop %eax
109e76: 5a pop %edx
109e77: 68 f8 ff 03 10 push $0x1003fff8
109e7c: 53 push %ebx
109e7d: e8 42 1d 00 00 call 10bbc4 <_Thread_Clear_state>
109e82: 83 c4 10 add $0x10,%esp
109e85: eb 02 jmp 109e89 <_Event_Surrender+0xdd>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
109e87: 50 push %eax
109e88: 9d popf
}
109e89: 8d 65 f4 lea -0xc(%ebp),%esp
109e8c: 5b pop %ebx
109e8d: 5e pop %esi
109e8e: 5f pop %edi
109e8f: c9 leave
109e90: c3 ret
00109e94 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
109e94: 55 push %ebp
109e95: 89 e5 mov %esp,%ebp
109e97: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
109e9a: 8d 45 f4 lea -0xc(%ebp),%eax
109e9d: 50 push %eax
109e9e: ff 75 08 pushl 0x8(%ebp)
109ea1: e8 b2 20 00 00 call 10bf58 <_Thread_Get>
switch ( location ) {
109ea6: 83 c4 10 add $0x10,%esp
109ea9: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
109ead: 75 49 jne 109ef8 <_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 );
109eaf: 9c pushf
109eb0: fa cli
109eb1: 5a pop %edx
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
109eb2: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
109eb9: 3b 05 34 47 12 00 cmp 0x124734,%eax
109ebf: 75 13 jne 109ed4 <_Event_Timeout+0x40>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
109ec1: 8b 0d e4 4a 12 00 mov 0x124ae4,%ecx
109ec7: 49 dec %ecx
109ec8: 75 0a jne 109ed4 <_Event_Timeout+0x40>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
109eca: c7 05 e4 4a 12 00 02 movl $0x2,0x124ae4
109ed1: 00 00 00
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
109ed4: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax)
_ISR_Enable( level );
109edb: 52 push %edx
109edc: 9d popf
109edd: 52 push %edx
109ede: 52 push %edx
109edf: 68 f8 ff 03 10 push $0x1003fff8
109ee4: 50 push %eax
109ee5: e8 da 1c 00 00 call 10bbc4 <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
109eea: a1 e4 41 12 00 mov 0x1241e4,%eax
109eef: 48 dec %eax
109ef0: a3 e4 41 12 00 mov %eax,0x1241e4
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
109ef5: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
109ef8: c9 leave
109ef9: c3 ret
0010f424 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
10f424: 55 push %ebp
10f425: 89 e5 mov %esp,%ebp
10f427: 57 push %edi
10f428: 56 push %esi
10f429: 53 push %ebx
10f42a: 83 ec 3c sub $0x3c,%esp
10f42d: 8b 75 08 mov 0x8(%ebp),%esi
10f430: 8b 7d 0c mov 0xc(%ebp),%edi
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
10f433: 8b 4e 08 mov 0x8(%esi),%ecx
)
{
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
Heap_Block *block = _Heap_Free_list_first( heap );
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
10f436: 8d 47 04 lea 0x4(%edi),%eax
10f439: 89 45 d0 mov %eax,-0x30(%ebp)
- HEAP_BLOCK_SIZE_OFFSET;
uintptr_t const page_size = heap->page_size;
10f43c: 8b 46 10 mov 0x10(%esi),%eax
10f43f: 89 45 e0 mov %eax,-0x20(%ebp)
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
if ( block_size_floor < alloc_size ) {
/* Integer overflow occured */
return NULL;
10f442: 31 c0 xor %eax,%eax
- HEAP_BLOCK_SIZE_OFFSET;
uintptr_t const page_size = heap->page_size;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
if ( block_size_floor < alloc_size ) {
10f444: 39 7d d0 cmp %edi,-0x30(%ebp)
10f447: 0f 82 22 01 00 00 jb 10f56f <_Heap_Allocate_aligned_with_boundary+0x14b>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
10f44d: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10f451: 74 15 je 10f468 <_Heap_Allocate_aligned_with_boundary+0x44>
if ( boundary < alloc_size ) {
10f453: 39 7d 14 cmp %edi,0x14(%ebp)
10f456: 0f 82 13 01 00 00 jb 10f56f <_Heap_Allocate_aligned_with_boundary+0x14b>
return NULL;
}
if ( alignment == 0 ) {
10f45c: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10f460: 75 06 jne 10f468 <_Heap_Allocate_aligned_with_boundary+0x44>
alignment = page_size;
10f462: 8b 45 e0 mov -0x20(%ebp),%eax
10f465: 89 45 10 mov %eax,0x10(%ebp)
10f468: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
10f46f: 8b 45 e0 mov -0x20(%ebp),%eax
10f472: 83 c0 07 add $0x7,%eax
10f475: 89 45 c4 mov %eax,-0x3c(%ebp)
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_BLOCK_SIZE_OFFSET;
10f478: c7 45 d4 04 00 00 00 movl $0x4,-0x2c(%ebp)
10f47f: 29 7d d4 sub %edi,-0x2c(%ebp)
10f482: 89 75 dc mov %esi,-0x24(%ebp)
10f485: e9 ca 00 00 00 jmp 10f554 <_Heap_Allocate_aligned_with_boundary+0x130>
while ( block != free_list_tail ) {
_HAssert( _Heap_Is_prev_used( block ) );
/* Statistics */
++search_count;
10f48a: ff 45 e4 incl -0x1c(%ebp)
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
10f48d: 8b 59 04 mov 0x4(%ecx),%ebx
10f490: 3b 5d d0 cmp -0x30(%ebp),%ebx
10f493: 0f 86 b8 00 00 00 jbe 10f551 <_Heap_Allocate_aligned_with_boundary+0x12d>
if ( alignment == 0 ) {
10f499: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10f49d: 8d 41 08 lea 0x8(%ecx),%eax
10f4a0: 89 45 d8 mov %eax,-0x28(%ebp)
10f4a3: 75 07 jne 10f4ac <_Heap_Allocate_aligned_with_boundary+0x88>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10f4a5: 89 c3 mov %eax,%ebx
10f4a7: e9 8a 00 00 00 jmp 10f536 <_Heap_Allocate_aligned_with_boundary+0x112>
uintptr_t alignment,
uintptr_t boundary
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
10f4ac: 8b 45 dc mov -0x24(%ebp),%eax
10f4af: 8b 40 14 mov 0x14(%eax),%eax
10f4b2: 89 45 cc mov %eax,-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;
10f4b5: 83 e3 fe and $0xfffffffe,%ebx
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
10f4b8: 8d 1c 19 lea (%ecx,%ebx,1),%ebx
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
10f4bb: 8b 75 c4 mov -0x3c(%ebp),%esi
10f4be: 29 c6 sub %eax,%esi
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
10f4c0: 01 de add %ebx,%esi
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_BLOCK_SIZE_OFFSET;
uintptr_t alloc_begin = alloc_end - alloc_size;
10f4c2: 03 5d d4 add -0x2c(%ebp),%ebx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10f4c5: 89 d8 mov %ebx,%eax
10f4c7: 31 d2 xor %edx,%edx
10f4c9: f7 75 10 divl 0x10(%ebp)
10f4cc: 29 d3 sub %edx,%ebx
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
10f4ce: 39 f3 cmp %esi,%ebx
10f4d0: 76 0b jbe 10f4dd <_Heap_Allocate_aligned_with_boundary+0xb9>
10f4d2: 89 f0 mov %esi,%eax
10f4d4: 31 d2 xor %edx,%edx
10f4d6: f7 75 10 divl 0x10(%ebp)
10f4d9: 89 f3 mov %esi,%ebx
10f4db: 29 d3 sub %edx,%ebx
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
10f4dd: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10f4e1: 74 35 je 10f518 <_Heap_Allocate_aligned_with_boundary+0xf4>
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment );
}
alloc_end = alloc_begin + alloc_size;
10f4e3: 8d 34 3b lea (%ebx,%edi,1),%esi
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
10f4e6: 8b 45 d8 mov -0x28(%ebp),%eax
10f4e9: 01 f8 add %edi,%eax
10f4eb: 89 45 c8 mov %eax,-0x38(%ebp)
10f4ee: eb 15 jmp 10f505 <_Heap_Allocate_aligned_with_boundary+0xe1>
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
10f4f0: 3b 45 c8 cmp -0x38(%ebp),%eax
10f4f3: 72 5c jb 10f551 <_Heap_Allocate_aligned_with_boundary+0x12d>
return 0;
}
alloc_begin = boundary_line - alloc_size;
10f4f5: 89 c3 mov %eax,%ebx
10f4f7: 29 fb sub %edi,%ebx
10f4f9: 89 d8 mov %ebx,%eax
10f4fb: 31 d2 xor %edx,%edx
10f4fd: f7 75 10 divl 0x10(%ebp)
10f500: 29 d3 sub %edx,%ebx
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
10f502: 8d 34 3b lea (%ebx,%edi,1),%esi
10f505: 89 f0 mov %esi,%eax
10f507: 31 d2 xor %edx,%edx
10f509: f7 75 14 divl 0x14(%ebp)
10f50c: 89 f0 mov %esi,%eax
10f50e: 29 d0 sub %edx,%eax
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
10f510: 39 f0 cmp %esi,%eax
10f512: 73 04 jae 10f518 <_Heap_Allocate_aligned_with_boundary+0xf4>
10f514: 39 c3 cmp %eax,%ebx
10f516: 72 d8 jb 10f4f0 <_Heap_Allocate_aligned_with_boundary+0xcc>
boundary_line = _Heap_Align_down( alloc_end, boundary );
}
}
/* Ensure that the we have a valid new block at the beginning */
if ( alloc_begin >= alloc_begin_floor ) {
10f518: 3b 5d d8 cmp -0x28(%ebp),%ebx
10f51b: 72 34 jb 10f551 <_Heap_Allocate_aligned_with_boundary+0x12d>
10f51d: be f8 ff ff ff mov $0xfffffff8,%esi
10f522: 29 ce sub %ecx,%esi
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
10f524: 01 de add %ebx,%esi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10f526: 89 d8 mov %ebx,%eax
10f528: 31 d2 xor %edx,%edx
10f52a: f7 75 e0 divl -0x20(%ebp)
uintptr_t const alloc_block_begin =
(uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size );
uintptr_t const free_size = alloc_block_begin - block_begin;
if ( free_size >= min_block_size || free_size == 0 ) {
10f52d: 29 d6 sub %edx,%esi
10f52f: 74 05 je 10f536 <_Heap_Allocate_aligned_with_boundary+0x112>
10f531: 3b 75 cc cmp -0x34(%ebp),%esi
10f534: 72 1b jb 10f551 <_Heap_Allocate_aligned_with_boundary+0x12d>
boundary
);
}
}
if ( alloc_begin != 0 ) {
10f536: 85 db test %ebx,%ebx
10f538: 74 17 je 10f551 <_Heap_Allocate_aligned_with_boundary+0x12d><== NEVER TAKEN
10f53a: 8b 75 dc mov -0x24(%ebp),%esi
block = block->next;
}
if ( alloc_begin != 0 ) {
/* Statistics */
stats->searches += search_count;
10f53d: 8b 45 e4 mov -0x1c(%ebp),%eax
10f540: 01 46 4c add %eax,0x4c(%esi)
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
10f543: 57 push %edi
10f544: 53 push %ebx
10f545: 51 push %ecx
10f546: 56 push %esi
10f547: e8 75 bc ff ff call 10b1c1 <_Heap_Block_allocate>
10f54c: 83 c4 10 add $0x10,%esp
10f54f: eb 11 jmp 10f562 <_Heap_Allocate_aligned_with_boundary+0x13e>
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
10f551: 8b 49 08 mov 0x8(%ecx),%ecx
if ( alignment == 0 ) {
alignment = page_size;
}
}
while ( block != free_list_tail ) {
10f554: 3b 4d dc cmp -0x24(%ebp),%ecx
10f557: 0f 85 2d ff ff ff jne 10f48a <_Heap_Allocate_aligned_with_boundary+0x66>
10f55d: 8b 75 dc mov -0x24(%ebp),%esi
10f560: 31 db xor %ebx,%ebx
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
10f562: 8b 45 e4 mov -0x1c(%ebp),%eax
10f565: 39 46 44 cmp %eax,0x44(%esi)
10f568: 73 03 jae 10f56d <_Heap_Allocate_aligned_with_boundary+0x149>
stats->max_search = search_count;
10f56a: 89 46 44 mov %eax,0x44(%esi)
}
return (void *) alloc_begin;
10f56d: 89 d8 mov %ebx,%eax
}
10f56f: 8d 65 f4 lea -0xc(%ebp),%esp
10f572: 5b pop %ebx
10f573: 5e pop %esi
10f574: 5f pop %edi
10f575: c9 leave
10f576: c3 ret
0010f913 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
10f913: 55 push %ebp
10f914: 89 e5 mov %esp,%ebp
10f916: 57 push %edi
10f917: 56 push %esi
10f918: 53 push %ebx
10f919: 83 ec 4c sub $0x4c,%esp
10f91c: 8b 5d 08 mov 0x8(%ebp),%ebx
10f91f: 8b 4d 10 mov 0x10(%ebp),%ecx
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
10f922: 8b 43 20 mov 0x20(%ebx),%eax
10f925: 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;
10f928: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
Heap_Block *extend_last_block = NULL;
10f92f: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
uintptr_t const page_size = heap->page_size;
10f936: 8b 53 10 mov 0x10(%ebx),%edx
10f939: 89 55 c4 mov %edx,-0x3c(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10f93c: 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;
10f93f: 8b 7b 30 mov 0x30(%ebx),%edi
10f942: 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;
10f945: 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 ) {
10f947: 8b 7d 0c mov 0xc(%ebp),%edi
10f94a: 01 cf add %ecx,%edi
10f94c: 0f 82 d4 01 00 00 jb 10fb26 <_Heap_Extend+0x213>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
10f952: 52 push %edx
10f953: 52 push %edx
10f954: 8d 55 e0 lea -0x20(%ebp),%edx
10f957: 52 push %edx
10f958: 8d 55 e4 lea -0x1c(%ebp),%edx
10f95b: 52 push %edx
10f95c: 50 push %eax
10f95d: ff 75 c4 pushl -0x3c(%ebp)
10f960: 51 push %ecx
10f961: ff 75 0c pushl 0xc(%ebp)
10f964: e8 4f b9 ff ff call 10b2b8 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
10f969: 83 c4 20 add $0x20,%esp
10f96c: 84 c0 test %al,%al
10f96e: 0f 84 b2 01 00 00 je 10fb26 <_Heap_Extend+0x213>
10f974: 8b 4d c0 mov -0x40(%ebp),%ecx
10f977: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp)
10f97e: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
10f985: 31 f6 xor %esi,%esi
10f987: 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;
10f98e: 8b 43 18 mov 0x18(%ebx),%eax
10f991: 89 5d b8 mov %ebx,-0x48(%ebp)
10f994: eb 02 jmp 10f998 <_Heap_Extend+0x85>
10f996: 89 c8 mov %ecx,%eax
uintptr_t const sub_area_end = start_block->prev_size;
10f998: 8b 19 mov (%ecx),%ebx
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
10f99a: 39 c7 cmp %eax,%edi
10f99c: 76 09 jbe 10f9a7 <_Heap_Extend+0x94>
10f99e: 39 5d 0c cmp %ebx,0xc(%ebp)
10f9a1: 0f 82 7d 01 00 00 jb 10fb24 <_Heap_Extend+0x211> <== NEVER TAKEN
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10f9a7: 39 c7 cmp %eax,%edi
10f9a9: 74 06 je 10f9b1 <_Heap_Extend+0x9e>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10f9ab: 39 df cmp %ebx,%edi
10f9ad: 72 07 jb 10f9b6 <_Heap_Extend+0xa3>
10f9af: eb 08 jmp 10f9b9 <_Heap_Extend+0xa6>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10f9b1: 89 4d d0 mov %ecx,-0x30(%ebp)
10f9b4: eb 03 jmp 10f9b9 <_Heap_Extend+0xa6>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10f9b6: 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);
10f9b9: 8d 43 f8 lea -0x8(%ebx),%eax
10f9bc: 89 45 d4 mov %eax,-0x2c(%ebp)
10f9bf: 89 d8 mov %ebx,%eax
10f9c1: 31 d2 xor %edx,%edx
10f9c3: 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);
10f9c6: 29 55 d4 sub %edx,-0x2c(%ebp)
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
10f9c9: 3b 5d 0c cmp 0xc(%ebp),%ebx
10f9cc: 75 07 jne 10f9d5 <_Heap_Extend+0xc2>
start_block->prev_size = extend_area_end;
10f9ce: 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 )
10f9d0: 8b 75 d4 mov -0x2c(%ebp),%esi
10f9d3: eb 08 jmp 10f9dd <_Heap_Extend+0xca>
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
10f9d5: 73 06 jae 10f9dd <_Heap_Extend+0xca>
10f9d7: 8b 55 d4 mov -0x2c(%ebp),%edx
10f9da: 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;
10f9dd: 8b 45 d4 mov -0x2c(%ebp),%eax
10f9e0: 8b 48 04 mov 0x4(%eax),%ecx
10f9e3: 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);
10f9e6: 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 );
10f9e8: 3b 4d c0 cmp -0x40(%ebp),%ecx
10f9eb: 75 a9 jne 10f996 <_Heap_Extend+0x83>
10f9ed: 8b 5d b8 mov -0x48(%ebp),%ebx
if ( extend_area_begin < heap->area_begin ) {
10f9f0: 8b 55 0c mov 0xc(%ebp),%edx
10f9f3: 3b 53 18 cmp 0x18(%ebx),%edx
10f9f6: 73 05 jae 10f9fd <_Heap_Extend+0xea>
heap->area_begin = extend_area_begin;
10f9f8: 89 53 18 mov %edx,0x18(%ebx)
10f9fb: eb 08 jmp 10fa05 <_Heap_Extend+0xf2>
} else if ( heap->area_end < extend_area_end ) {
10f9fd: 39 7b 1c cmp %edi,0x1c(%ebx)
10fa00: 73 03 jae 10fa05 <_Heap_Extend+0xf2>
heap->area_end = extend_area_end;
10fa02: 89 7b 1c mov %edi,0x1c(%ebx)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
10fa05: 8b 45 e0 mov -0x20(%ebp),%eax
10fa08: 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 =
10fa0b: 89 c1 mov %eax,%ecx
10fa0d: 29 d1 sub %edx,%ecx
10fa0f: 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;
10fa12: 89 3a mov %edi,(%edx)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
10fa14: 83 c9 01 or $0x1,%ecx
10fa17: 89 4a 04 mov %ecx,0x4(%edx)
extend_last_block->prev_size = extend_first_block_size;
10fa1a: 8b 4d d4 mov -0x2c(%ebp),%ecx
10fa1d: 89 08 mov %ecx,(%eax)
extend_last_block->size_and_flag = 0;
10fa1f: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
10fa26: 39 53 20 cmp %edx,0x20(%ebx)
10fa29: 76 05 jbe 10fa30 <_Heap_Extend+0x11d>
heap->first_block = extend_first_block;
10fa2b: 89 53 20 mov %edx,0x20(%ebx)
10fa2e: eb 08 jmp 10fa38 <_Heap_Extend+0x125>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
10fa30: 39 43 24 cmp %eax,0x24(%ebx)
10fa33: 73 03 jae 10fa38 <_Heap_Extend+0x125>
heap->last_block = extend_last_block;
10fa35: 89 43 24 mov %eax,0x24(%ebx)
}
if ( merge_below_block != NULL ) {
10fa38: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10fa3c: 74 3b je 10fa79 <_Heap_Extend+0x166>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
10fa3e: 8b 43 10 mov 0x10(%ebx),%eax
10fa41: 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 );
10fa44: 8b 4d 0c mov 0xc(%ebp),%ecx
10fa47: 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;
10fa4a: 89 c8 mov %ecx,%eax
10fa4c: 31 d2 xor %edx,%edx
10fa4e: f7 75 d4 divl -0x2c(%ebp)
if ( remainder != 0 ) {
10fa51: 85 d2 test %edx,%edx
10fa53: 74 05 je 10fa5a <_Heap_Extend+0x147> <== ALWAYS TAKEN
return value - remainder + alignment;
10fa55: 03 4d d4 add -0x2c(%ebp),%ecx <== NOT EXECUTED
10fa58: 29 d1 sub %edx,%ecx <== NOT EXECUTED
uintptr_t const new_first_block_begin =
10fa5a: 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;
10fa5d: 8b 45 d0 mov -0x30(%ebp),%eax
10fa60: 8b 00 mov (%eax),%eax
10fa62: 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 =
10fa65: 8b 45 d0 mov -0x30(%ebp),%eax
10fa68: 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;
10fa6a: 83 c8 01 or $0x1,%eax
10fa6d: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, new_first_block );
10fa70: 89 d8 mov %ebx,%eax
10fa72: e8 81 fe ff ff call 10f8f8 <_Heap_Free_block>
10fa77: eb 14 jmp 10fa8d <_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 ) {
10fa79: 83 7d c8 00 cmpl $0x0,-0x38(%ebp)
10fa7d: 74 0e je 10fa8d <_Heap_Extend+0x17a>
_Heap_Link_below(
10fa7f: 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;
10fa82: 8b 45 c8 mov -0x38(%ebp),%eax
10fa85: 29 d0 sub %edx,%eax
10fa87: 83 c8 01 or $0x1,%eax
10fa8a: 89 42 04 mov %eax,0x4(%edx)
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
10fa8d: 85 f6 test %esi,%esi
10fa8f: 74 30 je 10fac1 <_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,
10fa91: 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(
10fa94: 29 f7 sub %esi,%edi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10fa96: 89 f8 mov %edi,%eax
10fa98: 31 d2 xor %edx,%edx
10fa9a: f7 73 10 divl 0x10(%ebx)
10fa9d: 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)
10fa9f: 8b 46 04 mov 0x4(%esi),%eax
10faa2: 29 f8 sub %edi,%eax
| HEAP_PREV_BLOCK_USED;
10faa4: 83 c8 01 or $0x1,%eax
10faa7: 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;
10faab: 8b 46 04 mov 0x4(%esi),%eax
10faae: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
10fab1: 09 f8 or %edi,%eax
10fab3: 89 46 04 mov %eax,0x4(%esi)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
10fab6: 89 f2 mov %esi,%edx
10fab8: 89 d8 mov %ebx,%eax
10faba: e8 39 fe ff ff call 10f8f8 <_Heap_Free_block>
10fabf: eb 21 jmp 10fae2 <_Heap_Extend+0x1cf>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
10fac1: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
10fac5: 74 1b je 10fae2 <_Heap_Extend+0x1cf>
_Heap_Link_above(
10fac7: 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 );
10faca: 8b 45 e4 mov -0x1c(%ebp),%eax
10facd: 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;
10fad0: 8b 7d cc mov -0x34(%ebp),%edi
10fad3: 8b 57 04 mov 0x4(%edi),%edx
10fad6: 83 e2 01 and $0x1,%edx
block->size_and_flag = size | flag;
10fad9: 09 d0 or %edx,%eax
10fadb: 89 47 04 mov %eax,0x4(%edi)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
10fade: 83 49 04 01 orl $0x1,0x4(%ecx)
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
10fae2: 85 f6 test %esi,%esi
10fae4: 75 10 jne 10faf6 <_Heap_Extend+0x1e3>
10fae6: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10faea: 75 0a jne 10faf6 <_Heap_Extend+0x1e3>
_Heap_Free_block( heap, extend_first_block );
10faec: 8b 55 e4 mov -0x1c(%ebp),%edx
10faef: 89 d8 mov %ebx,%eax
10faf1: e8 02 fe ff ff call 10f8f8 <_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
10faf6: 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(
10faf9: 8b 43 20 mov 0x20(%ebx),%eax
10fafc: 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;
10fafe: 8b 4a 04 mov 0x4(%edx),%ecx
10fb01: 83 e1 01 and $0x1,%ecx
block->size_and_flag = size | flag;
10fb04: 09 c8 or %ecx,%eax
10fb06: 89 42 04 mov %eax,0x4(%edx)
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
10fb09: 8b 43 30 mov 0x30(%ebx),%eax
10fb0c: 2b 45 bc sub -0x44(%ebp),%eax
/* Statistics */
stats->size += extended_size;
10fb0f: 01 43 2c add %eax,0x2c(%ebx)
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
10fb12: 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 )
10fb17: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10fb1b: 74 09 je 10fb26 <_Heap_Extend+0x213> <== NEVER TAKEN
*extended_size_ptr = extended_size;
10fb1d: 8b 55 14 mov 0x14(%ebp),%edx
10fb20: 89 02 mov %eax,(%edx)
10fb22: eb 02 jmp 10fb26 <_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;
10fb24: 31 f6 xor %esi,%esi
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
10fb26: 89 f0 mov %esi,%eax
10fb28: 8d 65 f4 lea -0xc(%ebp),%esp
10fb2b: 5b pop %ebx
10fb2c: 5e pop %esi
10fb2d: 5f pop %edi
10fb2e: c9 leave
10fb2f: c3 ret
0010f578 <_Heap_Free>:
#include <rtems/system.h>
#include <rtems/score/sysstate.h>
#include <rtems/score/heap.h>
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
10f578: 55 push %ebp
10f579: 89 e5 mov %esp,%ebp
10f57b: 57 push %edi
10f57c: 56 push %esi
10f57d: 53 push %ebx
10f57e: 83 ec 14 sub $0x14,%esp
10f581: 8b 4d 08 mov 0x8(%ebp),%ecx
10f584: 8b 45 0c mov 0xc(%ebp),%eax
10f587: 8d 58 f8 lea -0x8(%eax),%ebx
10f58a: 31 d2 xor %edx,%edx
10f58c: 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);
10f58f: 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
10f591: 8b 41 20 mov 0x20(%ecx),%eax
10f594: 89 45 ec mov %eax,-0x14(%ebp)
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10f597: 31 d2 xor %edx,%edx
10f599: 39 c3 cmp %eax,%ebx
10f59b: 72 08 jb 10f5a5 <_Heap_Free+0x2d>
10f59d: 31 d2 xor %edx,%edx
10f59f: 39 59 24 cmp %ebx,0x24(%ecx)
10f5a2: 0f 93 c2 setae %dl
uintptr_t block_size = 0;
uintptr_t next_block_size = 0;
bool next_is_free = false;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
return false;
10f5a5: 31 c0 xor %eax,%eax
Heap_Block *next_block = NULL;
uintptr_t block_size = 0;
uintptr_t next_block_size = 0;
bool next_is_free = false;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
10f5a7: 85 d2 test %edx,%edx
10f5a9: 0f 84 21 01 00 00 je 10f6d0 <_Heap_Free+0x158>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f5af: 8b 43 04 mov 0x4(%ebx),%eax
10f5b2: 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;
10f5b5: 89 c6 mov %eax,%esi
10f5b7: 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);
10f5ba: 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;
10f5bd: 31 ff xor %edi,%edi
10f5bf: 3b 55 ec cmp -0x14(%ebp),%edx
10f5c2: 72 0a jb 10f5ce <_Heap_Free+0x56> <== NEVER TAKEN
10f5c4: 31 c0 xor %eax,%eax
10f5c6: 39 51 24 cmp %edx,0x24(%ecx)
10f5c9: 0f 93 c0 setae %al
10f5cc: 89 c7 mov %eax,%edi
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
10f5ce: 31 c0 xor %eax,%eax
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
10f5d0: 85 ff test %edi,%edi
10f5d2: 0f 84 f8 00 00 00 je 10f6d0 <_Heap_Free+0x158> <== NEVER TAKEN
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f5d8: 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 ) ) {
10f5db: f7 c7 01 00 00 00 test $0x1,%edi
10f5e1: 0f 84 e9 00 00 00 je 10f6d0 <_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;
10f5e7: 83 e7 fe and $0xfffffffe,%edi
10f5ea: 89 7d e8 mov %edi,-0x18(%ebp)
_HAssert( false );
return false;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
10f5ed: 8b 41 24 mov 0x24(%ecx),%eax
10f5f0: 89 45 e4 mov %eax,-0x1c(%ebp)
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
10f5f3: 31 c0 xor %eax,%eax
10f5f5: 3b 55 e4 cmp -0x1c(%ebp),%edx
10f5f8: 74 0a je 10f604 <_Heap_Free+0x8c>
10f5fa: 31 c0 xor %eax,%eax
10f5fc: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1)
10f601: 0f 94 c0 sete %al
_HAssert( false );
return false;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
10f604: 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 ) ) {
10f607: f6 45 f0 01 testb $0x1,-0x10(%ebp)
10f60b: 75 62 jne 10f66f <_Heap_Free+0xf7>
uintptr_t const prev_size = block->prev_size;
10f60d: 8b 03 mov (%ebx),%eax
10f60f: 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);
10f612: 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;
10f614: 31 ff xor %edi,%edi
10f616: 3b 5d ec cmp -0x14(%ebp),%ebx
10f619: 72 0a jb 10f625 <_Heap_Free+0xad> <== NEVER TAKEN
10f61b: 31 c0 xor %eax,%eax
10f61d: 39 5d e4 cmp %ebx,-0x1c(%ebp)
10f620: 0f 93 c0 setae %al
10f623: 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 );
10f625: 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 ) ) {
10f627: 85 ff test %edi,%edi
10f629: 0f 84 a1 00 00 00 je 10f6d0 <_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) ) {
10f62f: f6 43 04 01 testb $0x1,0x4(%ebx)
10f633: 0f 84 97 00 00 00 je 10f6d0 <_Heap_Free+0x158> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
10f639: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f63d: 74 1a je 10f659 <_Heap_Free+0xe1>
uintptr_t const size = block_size + prev_size + next_block_size;
10f63f: 8b 45 e8 mov -0x18(%ebp),%eax
10f642: 8d 04 06 lea (%esi,%eax,1),%eax
10f645: 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;
10f648: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = block->prev;
10f64b: 8b 52 0c mov 0xc(%edx),%edx
prev->next = next;
10f64e: 89 7a 08 mov %edi,0x8(%edx)
next->prev = prev;
10f651: 89 57 0c mov %edx,0xc(%edi)
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
10f654: ff 49 38 decl 0x38(%ecx)
10f657: eb 33 jmp 10f68c <_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;
10f659: 8b 45 f0 mov -0x10(%ebp),%eax
10f65c: 8d 04 06 lea (%esi,%eax,1),%eax
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f65f: 89 c7 mov %eax,%edi
10f661: 83 cf 01 or $0x1,%edi
10f664: 89 7b 04 mov %edi,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f667: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = size;
10f66b: 89 02 mov %eax,(%edx)
10f66d: eb 56 jmp 10f6c5 <_Heap_Free+0x14d>
}
} else if ( next_is_free ) { /* coalesce next */
10f66f: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f673: 74 24 je 10f699 <_Heap_Free+0x121>
uintptr_t const size = block_size + next_block_size;
10f675: 8b 45 e8 mov -0x18(%ebp),%eax
10f678: 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;
10f67a: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = old_block->prev;
10f67d: 8b 52 0c mov 0xc(%edx),%edx
new_block->next = next;
10f680: 89 7b 08 mov %edi,0x8(%ebx)
new_block->prev = prev;
10f683: 89 53 0c mov %edx,0xc(%ebx)
next->prev = new_block;
10f686: 89 5f 0c mov %ebx,0xc(%edi)
prev->next = new_block;
10f689: 89 5a 08 mov %ebx,0x8(%edx)
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f68c: 89 c2 mov %eax,%edx
10f68e: 83 ca 01 or $0x1,%edx
10f691: 89 53 04 mov %edx,0x4(%ebx)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
10f694: 89 04 03 mov %eax,(%ebx,%eax,1)
10f697: eb 2c jmp 10f6c5 <_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;
10f699: 8b 41 08 mov 0x8(%ecx),%eax
new_block->next = next;
10f69c: 89 43 08 mov %eax,0x8(%ebx)
new_block->prev = block_before;
10f69f: 89 4b 0c mov %ecx,0xc(%ebx)
block_before->next = new_block;
10f6a2: 89 59 08 mov %ebx,0x8(%ecx)
next->prev = new_block;
10f6a5: 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;
10f6a8: 89 f0 mov %esi,%eax
10f6aa: 83 c8 01 or $0x1,%eax
10f6ad: 89 43 04 mov %eax,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f6b0: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = block_size;
10f6b4: 89 32 mov %esi,(%edx)
/* Statistics */
++stats->free_blocks;
10f6b6: 8b 41 38 mov 0x38(%ecx),%eax
10f6b9: 40 inc %eax
10f6ba: 89 41 38 mov %eax,0x38(%ecx)
if ( stats->max_free_blocks < stats->free_blocks ) {
10f6bd: 39 41 3c cmp %eax,0x3c(%ecx)
10f6c0: 73 03 jae 10f6c5 <_Heap_Free+0x14d>
stats->max_free_blocks = stats->free_blocks;
10f6c2: 89 41 3c mov %eax,0x3c(%ecx)
}
}
/* Statistics */
--stats->used_blocks;
10f6c5: ff 49 40 decl 0x40(%ecx)
++stats->frees;
10f6c8: ff 41 50 incl 0x50(%ecx)
stats->free_size += block_size;
10f6cb: 01 71 30 add %esi,0x30(%ecx)
return( true );
10f6ce: b0 01 mov $0x1,%al
}
10f6d0: 83 c4 14 add $0x14,%esp
10f6d3: 5b pop %ebx
10f6d4: 5e pop %esi
10f6d5: 5f pop %edi
10f6d6: c9 leave
10f6d7: c3 ret
0011ce4c <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
11ce4c: 55 push %ebp
11ce4d: 89 e5 mov %esp,%ebp
11ce4f: 57 push %edi
11ce50: 56 push %esi
11ce51: 53 push %ebx
11ce52: 8b 5d 08 mov 0x8(%ebp),%ebx
11ce55: 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);
11ce58: 8d 4e f8 lea -0x8(%esi),%ecx
11ce5b: 89 f0 mov %esi,%eax
11ce5d: 31 d2 xor %edx,%edx
11ce5f: 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);
11ce62: 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
11ce64: 8b 53 20 mov 0x20(%ebx),%edx
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11ce67: 31 ff xor %edi,%edi
11ce69: 39 d1 cmp %edx,%ecx
11ce6b: 72 0a jb 11ce77 <_Heap_Size_of_alloc_area+0x2b>
11ce6d: 31 c0 xor %eax,%eax
11ce6f: 39 4b 24 cmp %ecx,0x24(%ebx)
11ce72: 0f 93 c0 setae %al
11ce75: 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;
11ce77: 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 ) ) {
11ce79: 85 ff test %edi,%edi
11ce7b: 74 30 je 11cead <_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;
11ce7d: 8b 41 04 mov 0x4(%ecx),%eax
11ce80: 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);
11ce83: 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;
11ce85: 31 ff xor %edi,%edi
11ce87: 39 d1 cmp %edx,%ecx
11ce89: 72 0a jb 11ce95 <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN
11ce8b: 31 c0 xor %eax,%eax
11ce8d: 39 4b 24 cmp %ecx,0x24(%ebx)
11ce90: 0f 93 c0 setae %al
11ce93: 89 c7 mov %eax,%edi
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
11ce95: 31 c0 xor %eax,%eax
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
11ce97: 85 ff test %edi,%edi
11ce99: 74 12 je 11cead <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
11ce9b: f6 41 04 01 testb $0x1,0x4(%ecx)
11ce9f: 74 0c je 11cead <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_BLOCK_SIZE_OFFSET - alloc_begin;
11cea1: 29 f1 sub %esi,%ecx
11cea3: 8d 51 04 lea 0x4(%ecx),%edx
11cea6: 8b 45 10 mov 0x10(%ebp),%eax
11cea9: 89 10 mov %edx,(%eax)
return true;
11ceab: b0 01 mov $0x1,%al
}
11cead: 5b pop %ebx
11ceae: 5e pop %esi
11ceaf: 5f pop %edi
11ceb0: c9 leave
11ceb1: c3 ret
0010bc6e <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
10bc6e: 55 push %ebp
10bc6f: 89 e5 mov %esp,%ebp
10bc71: 57 push %edi
10bc72: 56 push %esi
10bc73: 53 push %ebx
10bc74: 83 ec 4c sub $0x4c,%esp
10bc77: 8b 75 08 mov 0x8(%ebp),%esi
10bc7a: 8b 5d 0c mov 0xc(%ebp),%ebx
uintptr_t const page_size = heap->page_size;
10bc7d: 8b 46 10 mov 0x10(%esi),%eax
10bc80: 89 45 d8 mov %eax,-0x28(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10bc83: 8b 4e 14 mov 0x14(%esi),%ecx
10bc86: 89 4d d4 mov %ecx,-0x2c(%ebp)
Heap_Block *const first_block = heap->first_block;
10bc89: 8b 46 20 mov 0x20(%esi),%eax
10bc8c: 89 45 d0 mov %eax,-0x30(%ebp)
Heap_Block *const last_block = heap->last_block;
10bc8f: 8b 4e 24 mov 0x24(%esi),%ecx
10bc92: 89 4d c8 mov %ecx,-0x38(%ebp)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10bc95: c7 45 e4 30 bc 10 00 movl $0x10bc30,-0x1c(%ebp)
10bc9c: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
10bca0: 74 07 je 10bca9 <_Heap_Walk+0x3b>
10bca2: c7 45 e4 35 bc 10 00 movl $0x10bc35,-0x1c(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
10bca9: 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() ) ) {
10bcab: 83 3d ec 73 12 00 03 cmpl $0x3,0x1273ec
10bcb2: 0f 85 e8 02 00 00 jne 10bfa0 <_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)(
10bcb8: 52 push %edx
10bcb9: ff 76 0c pushl 0xc(%esi)
10bcbc: ff 76 08 pushl 0x8(%esi)
10bcbf: ff 75 c8 pushl -0x38(%ebp)
10bcc2: ff 75 d0 pushl -0x30(%ebp)
10bcc5: ff 76 1c pushl 0x1c(%esi)
10bcc8: ff 76 18 pushl 0x18(%esi)
10bccb: ff 75 d4 pushl -0x2c(%ebp)
10bcce: ff 75 d8 pushl -0x28(%ebp)
10bcd1: 68 11 f9 11 00 push $0x11f911
10bcd6: 6a 00 push $0x0
10bcd8: 53 push %ebx
10bcd9: 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 ) {
10bcdc: 83 c4 30 add $0x30,%esp
10bcdf: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10bce3: 75 0b jne 10bcf0 <_Heap_Walk+0x82>
(*printer)( source, true, "page size is zero\n" );
10bce5: 50 push %eax
10bce6: 68 a2 f9 11 00 push $0x11f9a2
10bceb: e9 6b 02 00 00 jmp 10bf5b <_Heap_Walk+0x2ed>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
10bcf0: f6 45 d8 03 testb $0x3,-0x28(%ebp)
10bcf4: 74 0d je 10bd03 <_Heap_Walk+0x95>
(*printer)(
10bcf6: ff 75 d8 pushl -0x28(%ebp)
10bcf9: 68 b5 f9 11 00 push $0x11f9b5
10bcfe: e9 58 02 00 00 jmp 10bf5b <_Heap_Walk+0x2ed>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bd03: 8b 45 d4 mov -0x2c(%ebp),%eax
10bd06: 31 d2 xor %edx,%edx
10bd08: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
10bd0b: 85 d2 test %edx,%edx
10bd0d: 74 0d je 10bd1c <_Heap_Walk+0xae>
(*printer)(
10bd0f: ff 75 d4 pushl -0x2c(%ebp)
10bd12: 68 d3 f9 11 00 push $0x11f9d3
10bd17: e9 3f 02 00 00 jmp 10bf5b <_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;
10bd1c: 8b 45 d0 mov -0x30(%ebp),%eax
10bd1f: 83 c0 08 add $0x8,%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bd22: 31 d2 xor %edx,%edx
10bd24: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if (
10bd27: 85 d2 test %edx,%edx
10bd29: 74 0d je 10bd38 <_Heap_Walk+0xca>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
10bd2b: ff 75 d0 pushl -0x30(%ebp)
10bd2e: 68 f7 f9 11 00 push $0x11f9f7
10bd33: e9 23 02 00 00 jmp 10bf5b <_Heap_Walk+0x2ed>
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
10bd38: 8b 45 d0 mov -0x30(%ebp),%eax
10bd3b: f6 40 04 01 testb $0x1,0x4(%eax)
10bd3f: 75 0b jne 10bd4c <_Heap_Walk+0xde>
(*printer)(
10bd41: 57 push %edi
10bd42: 68 28 fa 11 00 push $0x11fa28
10bd47: e9 0f 02 00 00 jmp 10bf5b <_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;
10bd4c: 8b 4d c8 mov -0x38(%ebp),%ecx
10bd4f: 8b 79 04 mov 0x4(%ecx),%edi
10bd52: 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);
10bd55: 01 cf add %ecx,%edi
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
10bd57: f6 47 04 01 testb $0x1,0x4(%edi)
10bd5b: 75 0b jne 10bd68 <_Heap_Walk+0xfa>
(*printer)(
10bd5d: 56 push %esi
10bd5e: 68 56 fa 11 00 push $0x11fa56
10bd63: e9 f3 01 00 00 jmp 10bf5b <_Heap_Walk+0x2ed>
);
return false;
}
if (
10bd68: 3b 7d d0 cmp -0x30(%ebp),%edi
10bd6b: 74 0b je 10bd78 <_Heap_Walk+0x10a> <== ALWAYS TAKEN
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
10bd6d: 51 push %ecx <== NOT EXECUTED
10bd6e: 68 6b fa 11 00 push $0x11fa6b <== NOT EXECUTED
10bd73: e9 e3 01 00 00 jmp 10bf5b <_Heap_Walk+0x2ed> <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
10bd78: 8b 46 10 mov 0x10(%esi),%eax
10bd7b: 89 45 e0 mov %eax,-0x20(%ebp)
block = next_block;
} while ( block != first_block );
return true;
}
10bd7e: 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 );
10bd81: 89 75 dc mov %esi,-0x24(%ebp)
10bd84: eb 75 jmp 10bdfb <_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;
10bd86: 31 c0 xor %eax,%eax
10bd88: 39 4e 20 cmp %ecx,0x20(%esi)
10bd8b: 77 08 ja 10bd95 <_Heap_Walk+0x127>
10bd8d: 31 c0 xor %eax,%eax
10bd8f: 39 4e 24 cmp %ecx,0x24(%esi)
10bd92: 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 ) ) {
10bd95: 85 c0 test %eax,%eax
10bd97: 75 0b jne 10bda4 <_Heap_Walk+0x136>
(*printer)(
10bd99: 51 push %ecx
10bd9a: 68 9a fa 11 00 push $0x11fa9a
10bd9f: e9 b7 01 00 00 jmp 10bf5b <_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;
10bda4: 8d 41 08 lea 0x8(%ecx),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bda7: 31 d2 xor %edx,%edx
10bda9: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if (
10bdac: 85 d2 test %edx,%edx
10bdae: 74 0b je 10bdbb <_Heap_Walk+0x14d>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
10bdb0: 51 push %ecx
10bdb1: 68 ba fa 11 00 push $0x11faba
10bdb6: e9 a0 01 00 00 jmp 10bf5b <_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;
10bdbb: 8b 41 04 mov 0x4(%ecx),%eax
10bdbe: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10bdc1: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1)
10bdc6: 74 0b je 10bdd3 <_Heap_Walk+0x165>
(*printer)(
10bdc8: 51 push %ecx
10bdc9: 68 ea fa 11 00 push $0x11faea
10bdce: e9 88 01 00 00 jmp 10bf5b <_Heap_Walk+0x2ed>
);
return false;
}
if ( free_block->prev != prev_block ) {
10bdd3: 8b 41 0c mov 0xc(%ecx),%eax
10bdd6: 3b 45 dc cmp -0x24(%ebp),%eax
10bdd9: 74 1a je 10bdf5 <_Heap_Walk+0x187>
(*printer)(
10bddb: 83 ec 0c sub $0xc,%esp
10bdde: 50 push %eax
10bddf: 51 push %ecx
10bde0: 68 06 fb 11 00 push $0x11fb06
10bde5: 6a 01 push $0x1
10bde7: 53 push %ebx
10bde8: ff 55 e4 call *-0x1c(%ebp)
10bdeb: 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;
10bdee: 31 c0 xor %eax,%eax
10bdf0: e9 ab 01 00 00 jmp 10bfa0 <_Heap_Walk+0x332>
return false;
}
prev_block = free_block;
free_block = free_block->next;
10bdf5: 89 4d dc mov %ecx,-0x24(%ebp)
10bdf8: 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 ) {
10bdfb: 39 f1 cmp %esi,%ecx
10bdfd: 75 87 jne 10bd86 <_Heap_Walk+0x118>
10bdff: 89 5d dc mov %ebx,-0x24(%ebp)
10be02: eb 02 jmp 10be06 <_Heap_Walk+0x198>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10be04: 89 df mov %ebx,%edi
return true;
}
10be06: 8b 4f 04 mov 0x4(%edi),%ecx
10be09: 89 4d cc mov %ecx,-0x34(%ebp)
10be0c: 83 e1 fe and $0xfffffffe,%ecx
10be0f: 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);
10be12: 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;
10be15: 31 c0 xor %eax,%eax
10be17: 39 5e 20 cmp %ebx,0x20(%esi)
10be1a: 77 08 ja 10be24 <_Heap_Walk+0x1b6> <== NEVER TAKEN
10be1c: 31 c0 xor %eax,%eax
10be1e: 39 5e 24 cmp %ebx,0x24(%esi)
10be21: 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 ) ) {
10be24: 85 c0 test %eax,%eax
10be26: 75 11 jne 10be39 <_Heap_Walk+0x1cb>
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 38 fb 11 00 push $0x11fb38
10be37: eb ac jmp 10bde5 <_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;
10be39: 3b 7d c8 cmp -0x38(%ebp),%edi
10be3c: 0f 95 c1 setne %cl
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10be3f: 8b 45 e0 mov -0x20(%ebp),%eax
10be42: 31 d2 xor %edx,%edx
10be44: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
10be47: 85 d2 test %edx,%edx
10be49: 74 15 je 10be60 <_Heap_Walk+0x1f2>
10be4b: 84 c9 test %cl,%cl
10be4d: 74 11 je 10be60 <_Heap_Walk+0x1f2>
10be4f: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be52: 83 ec 0c sub $0xc,%esp
10be55: ff 75 e0 pushl -0x20(%ebp)
10be58: 57 push %edi
10be59: 68 65 fb 11 00 push $0x11fb65
10be5e: eb 85 jmp 10bde5 <_Heap_Walk+0x177>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
10be60: 8b 45 d4 mov -0x2c(%ebp),%eax
10be63: 39 45 e0 cmp %eax,-0x20(%ebp)
10be66: 73 18 jae 10be80 <_Heap_Walk+0x212>
10be68: 84 c9 test %cl,%cl
10be6a: 74 14 je 10be80 <_Heap_Walk+0x212> <== NEVER TAKEN
10be6c: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be6f: 52 push %edx
10be70: 52 push %edx
10be71: 50 push %eax
10be72: ff 75 e0 pushl -0x20(%ebp)
10be75: 57 push %edi
10be76: 68 93 fb 11 00 push $0x11fb93
10be7b: e9 65 ff ff ff jmp 10bde5 <_Heap_Walk+0x177>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
10be80: 39 fb cmp %edi,%ebx
10be82: 77 18 ja 10be9c <_Heap_Walk+0x22e>
10be84: 84 c9 test %cl,%cl
10be86: 74 14 je 10be9c <_Heap_Walk+0x22e>
10be88: 89 d9 mov %ebx,%ecx
10be8a: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be8d: 83 ec 0c sub $0xc,%esp
10be90: 51 push %ecx
10be91: 57 push %edi
10be92: 68 be fb 11 00 push $0x11fbbe
10be97: e9 49 ff ff ff jmp 10bde5 <_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;
10be9c: 8b 4d cc mov -0x34(%ebp),%ecx
10be9f: 83 e1 01 and $0x1,%ecx
10bea2: 89 4d c4 mov %ecx,-0x3c(%ebp)
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10bea5: f6 43 04 01 testb $0x1,0x4(%ebx)
10bea9: 0f 85 ba 00 00 00 jne 10bf69 <_Heap_Walk+0x2fb>
block = next_block;
} while ( block != first_block );
return true;
}
10beaf: 8b 46 08 mov 0x8(%esi),%eax
10beb2: 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 ?
10beb5: 8b 4f 08 mov 0x8(%edi),%ecx
10beb8: 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)(
10bebb: ba de f8 11 00 mov $0x11f8de,%edx
10bec0: 3b 4e 0c cmp 0xc(%esi),%ecx
10bec3: 74 0e je 10bed3 <_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)" : "")
10bec5: ba 15 f8 11 00 mov $0x11f815,%edx
10beca: 39 f1 cmp %esi,%ecx
10becc: 75 05 jne 10bed3 <_Heap_Walk+0x265>
10bece: ba ed f8 11 00 mov $0x11f8ed,%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 ?
10bed3: 8b 47 0c mov 0xc(%edi),%eax
10bed6: 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)(
10bed9: b8 f7 f8 11 00 mov $0x11f8f7,%eax
10bede: 8b 4d c0 mov -0x40(%ebp),%ecx
10bee1: 39 4d cc cmp %ecx,-0x34(%ebp)
10bee4: 74 0f je 10bef5 <_Heap_Walk+0x287>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10bee6: b8 15 f8 11 00 mov $0x11f815,%eax
10beeb: 39 75 cc cmp %esi,-0x34(%ebp)
10beee: 75 05 jne 10bef5 <_Heap_Walk+0x287>
10bef0: b8 07 f9 11 00 mov $0x11f907,%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)(
10bef5: 83 ec 0c sub $0xc,%esp
10bef8: 52 push %edx
10bef9: ff 75 b4 pushl -0x4c(%ebp)
10befc: 50 push %eax
10befd: ff 75 cc pushl -0x34(%ebp)
10bf00: ff 75 e0 pushl -0x20(%ebp)
10bf03: 57 push %edi
10bf04: 68 f2 fb 11 00 push $0x11fbf2
10bf09: 6a 00 push $0x0
10bf0b: ff 75 dc pushl -0x24(%ebp)
10bf0e: 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 ) {
10bf11: 8b 03 mov (%ebx),%eax
10bf13: 83 c4 30 add $0x30,%esp
10bf16: 39 45 e0 cmp %eax,-0x20(%ebp)
10bf19: 74 16 je 10bf31 <_Heap_Walk+0x2c3>
10bf1b: 89 d9 mov %ebx,%ecx
10bf1d: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bf20: 56 push %esi
10bf21: 51 push %ecx
10bf22: 50 push %eax
10bf23: ff 75 e0 pushl -0x20(%ebp)
10bf26: 57 push %edi
10bf27: 68 27 fc 11 00 push $0x11fc27
10bf2c: e9 b4 fe ff ff jmp 10bde5 <_Heap_Walk+0x177>
);
return false;
}
if ( !prev_used ) {
10bf31: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bf35: 75 0b jne 10bf42 <_Heap_Walk+0x2d4>
10bf37: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bf3a: 57 push %edi
10bf3b: 68 60 fc 11 00 push $0x11fc60
10bf40: eb 19 jmp 10bf5b <_Heap_Walk+0x2ed>
block = next_block;
} while ( block != first_block );
return true;
}
10bf42: 8b 46 08 mov 0x8(%esi),%eax
10bf45: eb 07 jmp 10bf4e <_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 ) {
10bf47: 39 f8 cmp %edi,%eax
10bf49: 74 4a je 10bf95 <_Heap_Walk+0x327>
return true;
}
free_block = free_block->next;
10bf4b: 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 ) {
10bf4e: 39 f0 cmp %esi,%eax
10bf50: 75 f5 jne 10bf47 <_Heap_Walk+0x2d9>
10bf52: 8b 5d dc mov -0x24(%ebp),%ebx
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10bf55: 57 push %edi
10bf56: 68 cb fc 11 00 push $0x11fccb
10bf5b: 6a 01 push $0x1
10bf5d: 53 push %ebx
10bf5e: ff 55 e4 call *-0x1c(%ebp)
10bf61: 83 c4 10 add $0x10,%esp
10bf64: e9 85 fe ff ff jmp 10bdee <_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) {
10bf69: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bf6d: 74 0e je 10bf7d <_Heap_Walk+0x30f>
(*printer)(
10bf6f: 83 ec 0c sub $0xc,%esp
10bf72: ff 75 e0 pushl -0x20(%ebp)
10bf75: 57 push %edi
10bf76: 68 8f fc 11 00 push $0x11fc8f
10bf7b: eb 0d jmp 10bf8a <_Heap_Walk+0x31c>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
10bf7d: 51 push %ecx
10bf7e: 51 push %ecx
10bf7f: ff 37 pushl (%edi)
10bf81: ff 75 e0 pushl -0x20(%ebp)
10bf84: 57 push %edi
10bf85: 68 a6 fc 11 00 push $0x11fca6
10bf8a: 6a 00 push $0x0
10bf8c: ff 75 dc pushl -0x24(%ebp)
10bf8f: ff 55 e4 call *-0x1c(%ebp)
10bf92: 83 c4 20 add $0x20,%esp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10bf95: 3b 5d d0 cmp -0x30(%ebp),%ebx
10bf98: 0f 85 66 fe ff ff jne 10be04 <_Heap_Walk+0x196>
return true;
10bf9e: b0 01 mov $0x1,%al
}
10bfa0: 8d 65 f4 lea -0xc(%ebp),%esp
10bfa3: 5b pop %ebx
10bfa4: 5e pop %esi
10bfa5: 5f pop %edi
10bfa6: c9 leave
10bfa7: c3 ret
0010b2a0 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10b2a0: 55 push %ebp
10b2a1: 89 e5 mov %esp,%ebp
10b2a3: 53 push %ebx
10b2a4: 83 ec 08 sub $0x8,%esp
10b2a7: 8b 45 08 mov 0x8(%ebp),%eax
10b2aa: 8b 55 0c mov 0xc(%ebp),%edx
10b2ad: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10b2b0: a3 7c 42 12 00 mov %eax,0x12427c
_Internal_errors_What_happened.is_internal = is_internal;
10b2b5: 88 15 80 42 12 00 mov %dl,0x124280
_Internal_errors_What_happened.the_error = the_error;
10b2bb: 89 1d 84 42 12 00 mov %ebx,0x124284
_User_extensions_Fatal( the_source, is_internal, the_error );
10b2c1: 53 push %ebx
10b2c2: 0f b6 d2 movzbl %dl,%edx
10b2c5: 52 push %edx
10b2c6: 50 push %eax
10b2c7: e8 1f 19 00 00 call 10cbeb <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
10b2cc: c7 05 64 43 12 00 05 movl $0x5,0x124364 <== NOT EXECUTED
10b2d3: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10b2d6: fa cli <== NOT EXECUTED
10b2d7: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10b2d9: f4 hlt <== NOT EXECUTED
10b2da: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b2dd: eb fe jmp 10b2dd <_Internal_error_Occurred+0x3d><== NOT EXECUTED
0010b330 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10b330: 55 push %ebp
10b331: 89 e5 mov %esp,%ebp
10b333: 56 push %esi
10b334: 53 push %ebx
10b335: 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;
10b338: 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 )
10b33a: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
10b33e: 74 53 je 10b393 <_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 );
10b340: 8d 73 20 lea 0x20(%ebx),%esi
10b343: 83 ec 0c sub $0xc,%esp
10b346: 56 push %esi
10b347: e8 24 f7 ff ff call 10aa70 <_Chain_Get>
10b34c: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10b34e: 83 c4 10 add $0x10,%esp
10b351: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10b355: 74 3c je 10b393 <_Objects_Allocate+0x63>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10b357: 85 c0 test %eax,%eax
10b359: 75 1a jne 10b375 <_Objects_Allocate+0x45>
_Objects_Extend_information( information );
10b35b: 83 ec 0c sub $0xc,%esp
10b35e: 53 push %ebx
10b35f: e8 60 00 00 00 call 10b3c4 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10b364: 89 34 24 mov %esi,(%esp)
10b367: e8 04 f7 ff ff call 10aa70 <_Chain_Get>
10b36c: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10b36e: 83 c4 10 add $0x10,%esp
10b371: 85 c0 test %eax,%eax
10b373: 74 1e je 10b393 <_Objects_Allocate+0x63>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
10b375: 0f b7 41 08 movzwl 0x8(%ecx),%eax
10b379: 0f b7 53 08 movzwl 0x8(%ebx),%edx
10b37d: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
10b37f: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10b383: 31 d2 xor %edx,%edx
10b385: f7 f6 div %esi
information->inactive_per_block[ block ]--;
10b387: c1 e0 02 shl $0x2,%eax
10b38a: 03 43 30 add 0x30(%ebx),%eax
10b38d: ff 08 decl (%eax)
information->inactive--;
10b38f: 66 ff 4b 2c decw 0x2c(%ebx)
);
}
#endif
return the_object;
}
10b393: 89 c8 mov %ecx,%eax
10b395: 8d 65 f8 lea -0x8(%ebp),%esp
10b398: 5b pop %ebx
10b399: 5e pop %esi
10b39a: c9 leave
10b39b: c3 ret
0010b3c4 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
10b3c4: 55 push %ebp
10b3c5: 89 e5 mov %esp,%ebp
10b3c7: 57 push %edi
10b3c8: 56 push %esi
10b3c9: 53 push %ebx
10b3ca: 83 ec 4c sub $0x4c,%esp
10b3cd: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
10b3d0: 0f b7 43 08 movzwl 0x8(%ebx),%eax
10b3d4: 89 45 d0 mov %eax,-0x30(%ebp)
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
10b3d7: 8b 4b 34 mov 0x34(%ebx),%ecx
10b3da: 85 c9 test %ecx,%ecx
10b3dc: 74 38 je 10b416 <_Objects_Extend_information+0x52>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
10b3de: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10b3e2: 8b 43 10 mov 0x10(%ebx),%eax
10b3e5: 31 d2 xor %edx,%edx
10b3e7: 66 f7 f6 div %si
10b3ea: 0f b7 d0 movzwl %ax,%edx
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
10b3ed: 8b 45 d0 mov -0x30(%ebp),%eax
10b3f0: 89 45 cc mov %eax,-0x34(%ebp)
index_base = minimum_index;
block = 0;
10b3f3: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
10b3fa: 31 c0 xor %eax,%eax
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
10b3fc: eb 0a jmp 10b408 <_Objects_Extend_information+0x44>
if ( information->object_blocks[ block ] == NULL ) {
10b3fe: 83 3c 81 00 cmpl $0x0,(%ecx,%eax,4)
10b402: 74 28 je 10b42c <_Objects_Extend_information+0x68>
10b404: 01 75 cc add %esi,-0x34(%ebp)
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
10b407: 40 inc %eax
10b408: 39 d0 cmp %edx,%eax
10b40a: 72 f2 jb 10b3fe <_Objects_Extend_information+0x3a>
10b40c: 89 45 d4 mov %eax,-0x2c(%ebp)
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
10b40f: be 01 00 00 00 mov $0x1,%esi
10b414: eb 1b jmp 10b431 <_Objects_Extend_information+0x6d>
minimum_index = _Objects_Get_index( information->minimum_id );
10b416: 8b 55 d0 mov -0x30(%ebp),%edx
10b419: 89 55 cc mov %edx,-0x34(%ebp)
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
10b41c: be 01 00 00 00 mov $0x1,%esi
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
10b421: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
10b428: 31 d2 xor %edx,%edx
10b42a: eb 05 jmp 10b431 <_Objects_Extend_information+0x6d>
10b42c: 89 45 d4 mov %eax,-0x2c(%ebp)
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
10b42f: 31 f6 xor %esi,%esi
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
10b431: 0f b7 43 14 movzwl 0x14(%ebx),%eax
10b435: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx
10b439: 8d 0c 08 lea (%eax,%ecx,1),%ecx
10b43c: 89 4d bc mov %ecx,-0x44(%ebp)
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
10b43f: 81 f9 ff ff 00 00 cmp $0xffff,%ecx
10b445: 0f 87 d4 01 00 00 ja 10b61f <_Objects_Extend_information+0x25b>
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
10b44b: 0f af 43 18 imul 0x18(%ebx),%eax
if ( information->auto_extend ) {
10b44f: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10b453: 74 1e je 10b473 <_Objects_Extend_information+0xaf>
new_object_block = _Workspace_Allocate( block_size );
10b455: 83 ec 0c sub $0xc,%esp
10b458: 50 push %eax
10b459: 89 55 b4 mov %edx,-0x4c(%ebp)
10b45c: e8 dd 1a 00 00 call 10cf3e <_Workspace_Allocate>
10b461: 89 45 c4 mov %eax,-0x3c(%ebp)
if ( !new_object_block )
10b464: 83 c4 10 add $0x10,%esp
10b467: 85 c0 test %eax,%eax
10b469: 8b 55 b4 mov -0x4c(%ebp),%edx
10b46c: 75 1a jne 10b488 <_Objects_Extend_information+0xc4>
10b46e: e9 ac 01 00 00 jmp 10b61f <_Objects_Extend_information+0x25b>
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
10b473: 83 ec 0c sub $0xc,%esp
10b476: 50 push %eax
10b477: 89 55 b4 mov %edx,-0x4c(%ebp)
10b47a: e8 ed 1a 00 00 call 10cf6c <_Workspace_Allocate_or_fatal_error>
10b47f: 89 45 c4 mov %eax,-0x3c(%ebp)
10b482: 83 c4 10 add $0x10,%esp
10b485: 8b 55 b4 mov -0x4c(%ebp),%edx
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
10b488: 89 f1 mov %esi,%ecx
10b48a: 84 c9 test %cl,%cl
10b48c: 0f 84 0d 01 00 00 je 10b59f <_Objects_Extend_information+0x1db><== NEVER TAKEN
*/
/*
* Up the block count and maximum
*/
block_count++;
10b492: 8d 72 01 lea 0x1(%edx),%esi
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
10b495: 83 ec 0c sub $0xc,%esp
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
10b498: 8b 4d bc mov -0x44(%ebp),%ecx
10b49b: 03 4d d0 add -0x30(%ebp),%ecx
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
10b49e: 8d 04 76 lea (%esi,%esi,2),%eax
10b4a1: 8d 04 01 lea (%ecx,%eax,1),%eax
block_count++;
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
10b4a4: c1 e0 02 shl $0x2,%eax
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
10b4a7: 50 push %eax
10b4a8: 89 55 b4 mov %edx,-0x4c(%ebp)
10b4ab: e8 8e 1a 00 00 call 10cf3e <_Workspace_Allocate>
if ( !object_blocks ) {
10b4b0: 83 c4 10 add $0x10,%esp
10b4b3: 85 c0 test %eax,%eax
10b4b5: 8b 55 b4 mov -0x4c(%ebp),%edx
10b4b8: 75 13 jne 10b4cd <_Objects_Extend_information+0x109>
_Workspace_Free( new_object_block );
10b4ba: 83 ec 0c sub $0xc,%esp
10b4bd: ff 75 c4 pushl -0x3c(%ebp)
10b4c0: e8 92 1a 00 00 call 10cf57 <_Workspace_Free>
return;
10b4c5: 83 c4 10 add $0x10,%esp
10b4c8: e9 52 01 00 00 jmp 10b61f <_Objects_Extend_information+0x25b>
10b4cd: 8d 0c b0 lea (%eax,%esi,4),%ecx
10b4d0: 89 4d b8 mov %ecx,-0x48(%ebp)
10b4d3: 8d 34 f0 lea (%eax,%esi,8),%esi
10b4d6: 89 75 c0 mov %esi,-0x40(%ebp)
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
10b4d9: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx
10b4dd: 3b 4d d0 cmp -0x30(%ebp),%ecx
10b4e0: 77 04 ja 10b4e6 <_Objects_Extend_information+0x122>
10b4e2: 31 c9 xor %ecx,%ecx
10b4e4: eb 3e jmp 10b524 <_Objects_Extend_information+0x160>
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
10b4e6: 8d 34 95 00 00 00 00 lea 0x0(,%edx,4),%esi
10b4ed: 89 75 c8 mov %esi,-0x38(%ebp)
10b4f0: 8b 73 34 mov 0x34(%ebx),%esi
10b4f3: 89 c7 mov %eax,%edi
10b4f5: 8b 4d c8 mov -0x38(%ebp),%ecx
10b4f8: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
10b4fa: 8b 73 30 mov 0x30(%ebx),%esi
10b4fd: 8b 7d b8 mov -0x48(%ebp),%edi
10b500: 8b 4d c8 mov -0x38(%ebp),%ecx
10b503: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
10b505: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx
10b509: 03 4d d0 add -0x30(%ebp),%ecx
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
10b50c: c1 e1 02 shl $0x2,%ecx
10b50f: 8b 73 1c mov 0x1c(%ebx),%esi
10b512: 8b 7d c0 mov -0x40(%ebp),%edi
10b515: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10b517: eb 10 jmp 10b529 <_Objects_Extend_information+0x165>
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
local_table[ index ] = NULL;
10b519: 8b 75 c0 mov -0x40(%ebp),%esi
10b51c: c7 04 8e 00 00 00 00 movl $0x0,(%esi,%ecx,4)
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
10b523: 41 inc %ecx
10b524: 3b 4d d0 cmp -0x30(%ebp),%ecx
10b527: 72 f0 jb 10b519 <_Objects_Extend_information+0x155>
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
10b529: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4)
inactive_per_block[block_count] = 0;
10b530: 8b 4d b8 mov -0x48(%ebp),%ecx
10b533: c7 04 91 00 00 00 00 movl $0x0,(%ecx,%edx,4)
for ( index=index_base ;
index < ( information->allocation_size + index_base );
10b53a: 0f b7 4b 14 movzwl 0x14(%ebx),%ecx
10b53e: 03 4d cc add -0x34(%ebp),%ecx
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
10b541: 8b 55 cc mov -0x34(%ebp),%edx
10b544: eb 0b jmp 10b551 <_Objects_Extend_information+0x18d>
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
10b546: 8b 75 c0 mov -0x40(%ebp),%esi
10b549: c7 04 96 00 00 00 00 movl $0x0,(%esi,%edx,4)
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
10b550: 42 inc %edx
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
10b551: 39 ca cmp %ecx,%edx
10b553: 72 f1 jb 10b546 <_Objects_Extend_information+0x182>
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
10b555: 9c pushf
10b556: fa cli
10b557: 5e pop %esi
old_tables = information->object_blocks;
10b558: 8b 53 34 mov 0x34(%ebx),%edx
information->object_blocks = object_blocks;
10b55b: 89 43 34 mov %eax,0x34(%ebx)
information->inactive_per_block = inactive_per_block;
10b55e: 8b 45 b8 mov -0x48(%ebp),%eax
10b561: 89 43 30 mov %eax,0x30(%ebx)
information->local_table = local_table;
10b564: 8b 4d c0 mov -0x40(%ebp),%ecx
10b567: 89 4b 1c mov %ecx,0x1c(%ebx)
information->maximum = (Objects_Maximum) maximum;
10b56a: 8b 45 bc mov -0x44(%ebp),%eax
10b56d: 66 89 43 10 mov %ax,0x10(%ebx)
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10b571: 8b 03 mov (%ebx),%eax
10b573: c1 e0 18 shl $0x18,%eax
10b576: 0d 00 00 01 00 or $0x10000,%eax
information->maximum_id = _Objects_Build_id(
10b57b: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10b57f: c1 e1 1b shl $0x1b,%ecx
10b582: 09 c8 or %ecx,%eax
10b584: 0f b7 4d bc movzwl -0x44(%ebp),%ecx
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10b588: 09 c8 or %ecx,%eax
10b58a: 89 43 0c mov %eax,0xc(%ebx)
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
10b58d: 56 push %esi
10b58e: 9d popf
if ( old_tables )
10b58f: 85 d2 test %edx,%edx
10b591: 74 0c je 10b59f <_Objects_Extend_information+0x1db>
_Workspace_Free( old_tables );
10b593: 83 ec 0c sub $0xc,%esp
10b596: 52 push %edx
10b597: e8 bb 19 00 00 call 10cf57 <_Workspace_Free>
10b59c: 83 c4 10 add $0x10,%esp
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
10b59f: 8b 55 d4 mov -0x2c(%ebp),%edx
10b5a2: c1 e2 02 shl $0x2,%edx
10b5a5: 89 55 d0 mov %edx,-0x30(%ebp)
10b5a8: 8b 43 34 mov 0x34(%ebx),%eax
10b5ab: 8b 75 c4 mov -0x3c(%ebp),%esi
10b5ae: 8b 4d d4 mov -0x2c(%ebp),%ecx
10b5b1: 89 34 88 mov %esi,(%eax,%ecx,4)
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
10b5b4: ff 73 18 pushl 0x18(%ebx)
10b5b7: 0f b7 43 14 movzwl 0x14(%ebx),%eax
10b5bb: 50 push %eax
10b5bc: 56 push %esi
10b5bd: 8d 7d dc lea -0x24(%ebp),%edi
10b5c0: 57 push %edi
10b5c1: e8 4e 3c 00 00 call 10f214 <_Chain_Initialize>
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
10b5c6: 83 c4 10 add $0x10,%esp
);
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
10b5c9: 8b 75 cc mov -0x34(%ebp),%esi
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10b5cc: 8d 43 20 lea 0x20(%ebx),%eax
10b5cf: 89 45 d4 mov %eax,-0x2c(%ebp)
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
10b5d2: eb 28 jmp 10b5fc <_Objects_Extend_information+0x238>
10b5d4: 8b 13 mov (%ebx),%edx
10b5d6: c1 e2 18 shl $0x18,%edx
10b5d9: 81 ca 00 00 01 00 or $0x10000,%edx
the_object->id = _Objects_Build_id(
10b5df: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10b5e3: c1 e1 1b shl $0x1b,%ecx
10b5e6: 09 ca or %ecx,%edx
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10b5e8: 09 f2 or %esi,%edx
10b5ea: 89 50 08 mov %edx,0x8(%eax)
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10b5ed: 52 push %edx
10b5ee: 52 push %edx
10b5ef: 50 push %eax
10b5f0: ff 75 d4 pushl -0x2c(%ebp)
10b5f3: e8 3c f4 ff ff call 10aa34 <_Chain_Append>
index++;
10b5f8: 46 inc %esi
10b5f9: 83 c4 10 add $0x10,%esp
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
10b5fc: 83 ec 0c sub $0xc,%esp
10b5ff: 57 push %edi
10b600: e8 6b f4 ff ff call 10aa70 <_Chain_Get>
10b605: 83 c4 10 add $0x10,%esp
10b608: 85 c0 test %eax,%eax
10b60a: 75 c8 jne 10b5d4 <_Objects_Extend_information+0x210>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
10b60c: 8b 43 14 mov 0x14(%ebx),%eax
10b60f: 8b 53 30 mov 0x30(%ebx),%edx
10b612: 0f b7 c8 movzwl %ax,%ecx
10b615: 8b 75 d0 mov -0x30(%ebp),%esi
10b618: 89 0c 32 mov %ecx,(%edx,%esi,1)
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
10b61b: 66 01 43 2c add %ax,0x2c(%ebx)
}
10b61f: 8d 65 f4 lea -0xc(%ebp),%esp
10b622: 5b pop %ebx
10b623: 5e pop %esi
10b624: 5f pop %edi
10b625: c9 leave
10b626: c3 ret
0010b6b8 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint32_t the_class
)
{
10b6b8: 55 push %ebp
10b6b9: 89 e5 mov %esp,%ebp
10b6bb: 57 push %edi
10b6bc: 56 push %esi
10b6bd: 53 push %ebx
10b6be: 83 ec 0c sub $0xc,%esp
10b6c1: 8b 7d 08 mov 0x8(%ebp),%edi
10b6c4: 8b 75 0c mov 0xc(%ebp),%esi
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
10b6c7: 31 db xor %ebx,%ebx
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10b6c9: 85 f6 test %esi,%esi
10b6cb: 74 34 je 10b701 <_Objects_Get_information+0x49>
/*
* 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 );
10b6cd: 83 ec 0c sub $0xc,%esp
10b6d0: 57 push %edi
10b6d1: e8 02 40 00 00 call 10f6d8 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10b6d6: 83 c4 10 add $0x10,%esp
10b6d9: 85 c0 test %eax,%eax
10b6db: 74 24 je 10b701 <_Objects_Get_information+0x49>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10b6dd: 39 c6 cmp %eax,%esi
10b6df: 77 20 ja 10b701 <_Objects_Get_information+0x49>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10b6e1: 8b 04 bd bc 41 12 00 mov 0x1241bc(,%edi,4),%eax
10b6e8: 85 c0 test %eax,%eax
10b6ea: 74 15 je 10b701 <_Objects_Get_information+0x49><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10b6ec: 8b 1c b0 mov (%eax,%esi,4),%ebx
if ( !info )
10b6ef: 85 db test %ebx,%ebx
10b6f1: 74 0e je 10b701 <_Objects_Get_information+0x49><== 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;
10b6f3: 31 c0 xor %eax,%eax
10b6f5: 66 83 7b 10 00 cmpw $0x0,0x10(%ebx)
10b6fa: 0f 95 c0 setne %al
10b6fd: f7 d8 neg %eax
10b6ff: 21 c3 and %eax,%ebx
#endif
return info;
}
10b701: 89 d8 mov %ebx,%eax
10b703: 8d 65 f4 lea -0xc(%ebp),%esp
10b706: 5b pop %ebx
10b707: 5e pop %esi
10b708: 5f pop %edi
10b709: c9 leave
10b70a: c3 ret
00118ba8 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
118ba8: 55 push %ebp
118ba9: 89 e5 mov %esp,%ebp
118bab: 53 push %ebx
118bac: 8b 55 08 mov 0x8(%ebp),%edx
118baf: 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;
118bb2: b8 01 00 00 00 mov $0x1,%eax
118bb7: 2b 42 08 sub 0x8(%edx),%eax
118bba: 03 45 0c add 0xc(%ebp),%eax
if ( information->maximum >= index ) {
118bbd: 0f b7 5a 10 movzwl 0x10(%edx),%ebx
118bc1: 39 c3 cmp %eax,%ebx
118bc3: 72 12 jb 118bd7 <_Objects_Get_no_protection+0x2f>
if ( (the_object = information->local_table[ index ]) != NULL ) {
118bc5: 8b 52 1c mov 0x1c(%edx),%edx
118bc8: 8b 04 82 mov (%edx,%eax,4),%eax
118bcb: 85 c0 test %eax,%eax
118bcd: 74 08 je 118bd7 <_Objects_Get_no_protection+0x2f><== NEVER TAKEN
*location = OBJECTS_LOCAL;
118bcf: c7 01 00 00 00 00 movl $0x0,(%ecx)
return the_object;
118bd5: eb 08 jmp 118bdf <_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;
118bd7: c7 01 01 00 00 00 movl $0x1,(%ecx)
return NULL;
118bdd: 31 c0 xor %eax,%eax
}
118bdf: 5b pop %ebx
118be0: c9 leave
118be1: c3 ret
0010c8c8 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10c8c8: 55 push %ebp
10c8c9: 89 e5 mov %esp,%ebp
10c8cb: 53 push %ebx
10c8cc: 83 ec 14 sub $0x14,%esp
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10c8cf: 8b 45 08 mov 0x8(%ebp),%eax
10c8d2: 85 c0 test %eax,%eax
10c8d4: 75 08 jne 10c8de <_Objects_Id_to_name+0x16>
10c8d6: a1 80 77 12 00 mov 0x127780,%eax
10c8db: 8b 40 08 mov 0x8(%eax),%eax
10c8de: 89 c2 mov %eax,%edx
10c8e0: c1 ea 18 shr $0x18,%edx
10c8e3: 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 )
10c8e6: 8d 4a ff lea -0x1(%edx),%ecx
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
10c8e9: bb 03 00 00 00 mov $0x3,%ebx
10c8ee: 83 f9 02 cmp $0x2,%ecx
10c8f1: 77 36 ja 10c929 <_Objects_Id_to_name+0x61>
10c8f3: eb 3b jmp 10c930 <_Objects_Id_to_name+0x68>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10c8f5: 89 c1 mov %eax,%ecx
10c8f7: 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 ];
10c8fa: 8b 14 8a mov (%edx,%ecx,4),%edx
if ( !information )
10c8fd: 85 d2 test %edx,%edx
10c8ff: 74 28 je 10c929 <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
10c901: 80 7a 38 00 cmpb $0x0,0x38(%edx)
10c905: 75 22 jne 10c929 <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
10c907: 51 push %ecx
10c908: 8d 4d f4 lea -0xc(%ebp),%ecx
10c90b: 51 push %ecx
10c90c: 50 push %eax
10c90d: 52 push %edx
10c90e: e8 5d ff ff ff call 10c870 <_Objects_Get>
if ( !the_object )
10c913: 83 c4 10 add $0x10,%esp
10c916: 85 c0 test %eax,%eax
10c918: 74 0f je 10c929 <_Objects_Id_to_name+0x61>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10c91a: 8b 50 0c mov 0xc(%eax),%edx
10c91d: 8b 45 0c mov 0xc(%ebp),%eax
10c920: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10c922: e8 9b 07 00 00 call 10d0c2 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10c927: 31 db xor %ebx,%ebx
}
10c929: 89 d8 mov %ebx,%eax
10c92b: 8b 5d fc mov -0x4(%ebp),%ebx
10c92e: c9 leave
10c92f: 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 ] )
10c930: 8b 14 95 08 72 12 00 mov 0x127208(,%edx,4),%edx
10c937: 85 d2 test %edx,%edx
10c939: 75 ba jne 10c8f5 <_Objects_Id_to_name+0x2d><== ALWAYS TAKEN
10c93b: eb ec jmp 10c929 <_Objects_Id_to_name+0x61><== NOT EXECUTED
0010bf48 <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
10bf48: 55 push %ebp
10bf49: 89 e5 mov %esp,%ebp
10bf4b: 57 push %edi
10bf4c: 56 push %esi
10bf4d: 53 push %ebx
10bf4e: 83 ec 24 sub $0x24,%esp
10bf51: 8b 55 08 mov 0x8(%ebp),%edx
10bf54: 8b 7d 0c mov 0xc(%ebp),%edi
10bf57: 8b 5d 10 mov 0x10(%ebp),%ebx
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
10bf5a: 0f b7 42 3a movzwl 0x3a(%edx),%eax
10bf5e: 50 push %eax
10bf5f: 53 push %ebx
10bf60: 89 55 e4 mov %edx,-0x1c(%ebp)
10bf63: e8 b0 6e 00 00 call 112e18 <strnlen>
10bf68: 89 c6 mov %eax,%esi
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
10bf6a: 83 c4 10 add $0x10,%esp
10bf6d: 8b 55 e4 mov -0x1c(%ebp),%edx
10bf70: 80 7a 38 00 cmpb $0x0,0x38(%edx)
10bf74: 74 52 je 10bfc8 <_Objects_Set_name+0x80>
char *d;
d = _Workspace_Allocate( length + 1 );
10bf76: 83 ec 0c sub $0xc,%esp
10bf79: 8d 40 01 lea 0x1(%eax),%eax
10bf7c: 50 push %eax
10bf7d: e8 9c 16 00 00 call 10d61e <_Workspace_Allocate>
10bf82: 89 c2 mov %eax,%edx
if ( !d )
10bf84: 83 c4 10 add $0x10,%esp
return false;
10bf87: 31 c0 xor %eax,%eax
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
if ( !d )
10bf89: 85 d2 test %edx,%edx
10bf8b: 74 7c je 10c009 <_Objects_Set_name+0xc1><== NEVER TAKEN
return false;
if ( the_object->name.name_p ) {
10bf8d: 8b 47 0c mov 0xc(%edi),%eax
10bf90: 85 c0 test %eax,%eax
10bf92: 74 19 je 10bfad <_Objects_Set_name+0x65>
_Workspace_Free( (void *)the_object->name.name_p );
10bf94: 83 ec 0c sub $0xc,%esp
10bf97: 50 push %eax
10bf98: 89 55 e4 mov %edx,-0x1c(%ebp)
10bf9b: e8 97 16 00 00 call 10d637 <_Workspace_Free>
the_object->name.name_p = NULL;
10bfa0: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi)
10bfa7: 83 c4 10 add $0x10,%esp
10bfaa: 8b 55 e4 mov -0x1c(%ebp),%edx
}
strncpy( d, name, length );
10bfad: 50 push %eax
10bfae: 56 push %esi
10bfaf: 53 push %ebx
10bfb0: 52 push %edx
10bfb1: 89 55 e4 mov %edx,-0x1c(%ebp)
10bfb4: e8 e3 6d 00 00 call 112d9c <strncpy>
d[length] = '\0';
10bfb9: 8b 55 e4 mov -0x1c(%ebp),%edx
10bfbc: c6 04 32 00 movb $0x0,(%edx,%esi,1)
the_object->name.name_p = d;
10bfc0: 89 57 0c mov %edx,0xc(%edi)
10bfc3: 83 c4 10 add $0x10,%esp
10bfc6: eb 3f jmp 10c007 <_Objects_Set_name+0xbf>
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10bfc8: 0f be 13 movsbl (%ebx),%edx
10bfcb: c1 e2 18 shl $0x18,%edx
10bfce: b8 00 00 20 00 mov $0x200000,%eax
10bfd3: 83 fe 01 cmp $0x1,%esi
10bfd6: 76 07 jbe 10bfdf <_Objects_Set_name+0x97>
10bfd8: 0f be 43 01 movsbl 0x1(%ebx),%eax
10bfdc: c1 e0 10 shl $0x10,%eax
10bfdf: 09 c2 or %eax,%edx
10bfe1: b8 00 20 00 00 mov $0x2000,%eax
10bfe6: 83 fe 02 cmp $0x2,%esi
10bfe9: 76 07 jbe 10bff2 <_Objects_Set_name+0xaa>
10bfeb: 0f be 43 02 movsbl 0x2(%ebx),%eax
10bfef: c1 e0 08 shl $0x8,%eax
10bff2: 09 d0 or %edx,%eax
10bff4: b9 20 00 00 00 mov $0x20,%ecx
10bff9: 83 fe 03 cmp $0x3,%esi
10bffc: 76 04 jbe 10c002 <_Objects_Set_name+0xba>
10bffe: 0f be 4b 03 movsbl 0x3(%ebx),%ecx
10c002: 09 c1 or %eax,%ecx
10c004: 89 4f 0c mov %ecx,0xc(%edi)
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
10c007: b0 01 mov $0x1,%al
}
10c009: 8d 65 f4 lea -0xc(%ebp),%esp
10c00c: 5b pop %ebx
10c00d: 5e pop %esi
10c00e: 5f pop %edi
10c00f: c9 leave
10c010: c3 ret
0010ae00 <_POSIX_Condition_variables_Wait_support>:
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
10ae00: 55 push %ebp
10ae01: 89 e5 mov %esp,%ebp
10ae03: 57 push %edi
10ae04: 56 push %esi
10ae05: 53 push %ebx
10ae06: 83 ec 34 sub $0x34,%esp
10ae09: 8b 75 0c mov 0xc(%ebp),%esi
10ae0c: 8a 45 14 mov 0x14(%ebp),%al
10ae0f: 88 45 d7 mov %al,-0x29(%ebp)
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
10ae12: 8d 7d e4 lea -0x1c(%ebp),%edi
10ae15: 57 push %edi
10ae16: 56 push %esi
10ae17: e8 48 01 00 00 call 10af64 <_POSIX_Mutex_Get>
10ae1c: 83 c4 10 add $0x10,%esp
return EINVAL;
10ae1f: bb 16 00 00 00 mov $0x16,%ebx
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
10ae24: 85 c0 test %eax,%eax
10ae26: 0f 84 bb 00 00 00 je 10aee7 <_POSIX_Condition_variables_Wait_support+0xe7>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10ae2c: a1 04 74 12 00 mov 0x127404,%eax
10ae31: 48 dec %eax
10ae32: a3 04 74 12 00 mov %eax,0x127404
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
10ae37: 52 push %edx
10ae38: 52 push %edx
10ae39: 57 push %edi
10ae3a: ff 75 08 pushl 0x8(%ebp)
10ae3d: e8 16 fe ff ff call 10ac58 <_POSIX_Condition_variables_Get>
10ae42: 89 c7 mov %eax,%edi
switch ( location ) {
10ae44: 83 c4 10 add $0x10,%esp
10ae47: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10ae4b: 0f 85 96 00 00 00 jne 10aee7 <_POSIX_Condition_variables_Wait_support+0xe7>
case OBJECTS_LOCAL:
if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {
10ae51: 8b 40 14 mov 0x14(%eax),%eax
10ae54: 85 c0 test %eax,%eax
10ae56: 74 0e je 10ae66 <_POSIX_Condition_variables_Wait_support+0x66>
10ae58: 3b 06 cmp (%esi),%eax
10ae5a: 74 0a je 10ae66 <_POSIX_Condition_variables_Wait_support+0x66>
_Thread_Enable_dispatch();
10ae5c: e8 79 2d 00 00 call 10dbda <_Thread_Enable_dispatch>
return EINVAL;
10ae61: e9 81 00 00 00 jmp 10aee7 <_POSIX_Condition_variables_Wait_support+0xe7>
}
(void) pthread_mutex_unlock( mutex );
10ae66: 83 ec 0c sub $0xc,%esp
10ae69: 56 push %esi
10ae6a: e8 25 03 00 00 call 10b194 <pthread_mutex_unlock>
_Thread_Enable_dispatch();
return EINVAL;
}
*/
if ( !already_timedout ) {
10ae6f: 83 c4 10 add $0x10,%esp
10ae72: 80 7d d7 00 cmpb $0x0,-0x29(%ebp)
10ae76: 75 50 jne 10aec8 <_POSIX_Condition_variables_Wait_support+0xc8>
the_cond->Mutex = *mutex;
10ae78: 8b 06 mov (%esi),%eax
10ae7a: 89 47 14 mov %eax,0x14(%edi)
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;
10ae7d: c7 47 48 01 00 00 00 movl $0x1,0x48(%edi)
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
10ae84: a1 54 79 12 00 mov 0x127954,%eax
10ae89: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
10ae90: 83 c7 18 add $0x18,%edi
10ae93: 89 78 44 mov %edi,0x44(%eax)
_Thread_Executing->Wait.id = *cond;
10ae96: 8b 4d 08 mov 0x8(%ebp),%ecx
10ae99: 8b 11 mov (%ecx),%edx
10ae9b: 89 50 20 mov %edx,0x20(%eax)
_Thread_queue_Enqueue( &the_cond->Wait_queue, timeout );
10ae9e: 50 push %eax
10ae9f: 68 84 e3 10 00 push $0x10e384
10aea4: ff 75 10 pushl 0x10(%ebp)
10aea7: 57 push %edi
10aea8: e8 b7 31 00 00 call 10e064 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10aead: e8 28 2d 00 00 call 10dbda <_Thread_Enable_dispatch>
/*
* Switch ourself out because we blocked as a result of the
* _Thread_queue_Enqueue.
*/
status = _Thread_Executing->Wait.return_code;
10aeb2: a1 54 79 12 00 mov 0x127954,%eax
10aeb7: 8b 58 34 mov 0x34(%eax),%ebx
if ( status && status != ETIMEDOUT )
10aeba: 83 c4 10 add $0x10,%esp
10aebd: 83 fb 74 cmp $0x74,%ebx
10aec0: 74 10 je 10aed2 <_POSIX_Condition_variables_Wait_support+0xd2>
10aec2: 85 db test %ebx,%ebx
10aec4: 74 0c je 10aed2 <_POSIX_Condition_variables_Wait_support+0xd2><== ALWAYS TAKEN
10aec6: eb 1f jmp 10aee7 <_POSIX_Condition_variables_Wait_support+0xe7><== NOT EXECUTED
return status;
} else {
_Thread_Enable_dispatch();
10aec8: e8 0d 2d 00 00 call 10dbda <_Thread_Enable_dispatch>
status = ETIMEDOUT;
10aecd: bb 74 00 00 00 mov $0x74,%ebx
/*
* When we get here the dispatch disable level is 0.
*/
mutex_status = pthread_mutex_lock( mutex );
10aed2: 83 ec 0c sub $0xc,%esp
10aed5: 56 push %esi
10aed6: e8 39 02 00 00 call 10b114 <pthread_mutex_lock>
if ( mutex_status )
10aedb: 83 c4 10 add $0x10,%esp
10aede: 85 c0 test %eax,%eax
10aee0: 74 05 je 10aee7 <_POSIX_Condition_variables_Wait_support+0xe7>
return EINVAL;
10aee2: bb 16 00 00 00 mov $0x16,%ebx
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10aee7: 89 d8 mov %ebx,%eax
10aee9: 8d 65 f4 lea -0xc(%ebp),%esp
10aeec: 5b pop %ebx
10aeed: 5e pop %esi
10aeee: 5f pop %edi
10aeef: c9 leave
10aef0: c3 ret
0010e31c <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10e31c: 55 push %ebp
10e31d: 89 e5 mov %esp,%ebp
10e31f: 57 push %edi
10e320: 56 push %esi
10e321: 53 push %ebx
10e322: 83 ec 30 sub $0x30,%esp
10e325: 8b 75 08 mov 0x8(%ebp),%esi
10e328: 8b 5d 14 mov 0x14(%ebp),%ebx
10e32b: 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 );
10e32e: 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(
10e331: 50 push %eax
10e332: 56 push %esi
10e333: 68 fc cb 12 00 push $0x12cbfc
10e338: 88 55 d4 mov %dl,-0x2c(%ebp)
10e33b: e8 d4 2a 00 00 call 110e14 <_Objects_Get>
switch ( location ) {
10e340: 83 c4 10 add $0x10,%esp
10e343: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10e347: 8a 55 d4 mov -0x2c(%ebp),%dl
10e34a: 0f 85 aa 00 00 00 jne 10e3fa <_POSIX_Message_queue_Receive_support+0xde>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
10e350: 8b 78 14 mov 0x14(%eax),%edi
10e353: 89 f9 mov %edi,%ecx
10e355: 83 e1 03 and $0x3,%ecx
10e358: 49 dec %ecx
10e359: 75 0a jne 10e365 <_POSIX_Message_queue_Receive_support+0x49>
_Thread_Enable_dispatch();
10e35b: e8 02 33 00 00 call 111662 <_Thread_Enable_dispatch>
10e360: e9 95 00 00 00 jmp 10e3fa <_POSIX_Message_queue_Receive_support+0xde>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10e365: 8b 40 10 mov 0x10(%eax),%eax
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
10e368: 8b 48 68 mov 0x68(%eax),%ecx
10e36b: 39 4d 10 cmp %ecx,0x10(%ebp)
10e36e: 73 15 jae 10e385 <_POSIX_Message_queue_Receive_support+0x69>
_Thread_Enable_dispatch();
10e370: e8 ed 32 00 00 call 111662 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
10e375: e8 d2 8a 00 00 call 116e4c <__errno>
10e37a: c7 00 7a 00 00 00 movl $0x7a,(%eax)
10e380: e9 80 00 00 00 jmp 10e405 <_POSIX_Message_queue_Receive_support+0xe9>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
10e385: 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 )
10e38c: 31 c9 xor %ecx,%ecx
10e38e: 84 d2 test %dl,%dl
10e390: 74 09 je 10e39b <_POSIX_Message_queue_Receive_support+0x7f><== NEVER TAKEN
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
10e392: 81 e7 00 40 00 00 and $0x4000,%edi
10e398: 0f 94 c1 sete %cl
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
10e39b: 52 push %edx
10e39c: 52 push %edx
10e39d: ff 75 1c pushl 0x1c(%ebp)
10e3a0: 0f b6 c9 movzbl %cl,%ecx
10e3a3: 51 push %ecx
10e3a4: 8d 55 e0 lea -0x20(%ebp),%edx
10e3a7: 52 push %edx
10e3a8: ff 75 0c pushl 0xc(%ebp)
10e3ab: 56 push %esi
10e3ac: 83 c0 1c add $0x1c,%eax
10e3af: 50 push %eax
10e3b0: e8 4f 1c 00 00 call 110004 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
10e3b5: 83 c4 20 add $0x20,%esp
10e3b8: e8 a5 32 00 00 call 111662 <_Thread_Enable_dispatch>
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
10e3bd: a1 74 cc 12 00 mov 0x12cc74,%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);
10e3c2: 8b 50 24 mov 0x24(%eax),%edx
10e3c5: c1 fa 1f sar $0x1f,%edx
10e3c8: 8b 48 24 mov 0x24(%eax),%ecx
10e3cb: 31 d1 xor %edx,%ecx
10e3cd: 89 0b mov %ecx,(%ebx)
10e3cf: 29 13 sub %edx,(%ebx)
if ( !_Thread_Executing->Wait.return_code )
10e3d1: 83 78 34 00 cmpl $0x0,0x34(%eax)
10e3d5: 75 05 jne 10e3dc <_POSIX_Message_queue_Receive_support+0xc0>
return length_out;
10e3d7: 8b 45 e0 mov -0x20(%ebp),%eax
10e3da: eb 2c jmp 10e408 <_POSIX_Message_queue_Receive_support+0xec>
rtems_set_errno_and_return_minus_one(
10e3dc: e8 6b 8a 00 00 call 116e4c <__errno>
10e3e1: 89 c3 mov %eax,%ebx
10e3e3: 83 ec 0c sub $0xc,%esp
10e3e6: a1 74 cc 12 00 mov 0x12cc74,%eax
10e3eb: ff 70 34 pushl 0x34(%eax)
10e3ee: e8 ed 01 00 00 call 10e5e0 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
10e3f3: 89 03 mov %eax,(%ebx)
10e3f5: 83 c4 10 add $0x10,%esp
10e3f8: eb 0b jmp 10e405 <_POSIX_Message_queue_Receive_support+0xe9>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10e3fa: e8 4d 8a 00 00 call 116e4c <__errno>
10e3ff: c7 00 09 00 00 00 movl $0x9,(%eax)
10e405: 83 c8 ff or $0xffffffff,%eax
}
10e408: 8d 65 f4 lea -0xc(%ebp),%esp
10e40b: 5b pop %ebx
10e40c: 5e pop %esi
10e40d: 5f pop %edi
10e40e: c9 leave
10e40f: c3 ret
0010e85c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
10e85c: 55 push %ebp
10e85d: 89 e5 mov %esp,%ebp
10e85f: 83 ec 08 sub $0x8,%esp
10e862: 8b 55 08 mov 0x8(%ebp),%edx
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
10e865: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
10e86b: 83 b8 d4 00 00 00 00 cmpl $0x0,0xd4(%eax)
10e872: 75 2c jne 10e8a0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NEVER TAKEN
10e874: 83 b8 d8 00 00 00 01 cmpl $0x1,0xd8(%eax)
10e87b: 75 23 jne 10e8a0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44>
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
10e87d: 83 b8 dc 00 00 00 00 cmpl $0x0,0xdc(%eax)
10e884: 74 1a je 10e8a0 <_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;
10e886: a1 d4 51 12 00 mov 0x1251d4,%eax
10e88b: 48 dec %eax
10e88c: a3 d4 51 12 00 mov %eax,0x1251d4
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
10e891: 50 push %eax
10e892: 50 push %eax
10e893: 6a ff push $0xffffffff
10e895: 52 push %edx
10e896: e8 4d 08 00 00 call 10f0e8 <_POSIX_Thread_Exit>
10e89b: 83 c4 10 add $0x10,%esp
} else
_Thread_Enable_dispatch();
}
10e89e: c9 leave
10e89f: c3 ret
10e8a0: 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();
10e8a1: e9 38 da ff ff jmp 10c2de <_Thread_Enable_dispatch>
0010fb18 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
10fb18: 55 push %ebp
10fb19: 89 e5 mov %esp,%ebp
10fb1b: 57 push %edi
10fb1c: 56 push %esi
10fb1d: 53 push %ebx
10fb1e: 83 ec 28 sub $0x28,%esp
10fb21: 8b 55 08 mov 0x8(%ebp),%edx
10fb24: 8b 5d 0c mov 0xc(%ebp),%ebx
10fb27: 8b 7d 10 mov 0x10(%ebp),%edi
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
10fb2a: ff 33 pushl (%ebx)
10fb2c: 89 55 e0 mov %edx,-0x20(%ebp)
10fb2f: e8 c4 ff ff ff call 10faf8 <_POSIX_Priority_Is_valid>
10fb34: 83 c4 10 add $0x10,%esp
return EINVAL;
10fb37: 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 ) )
10fb3c: 84 c0 test %al,%al
10fb3e: 8b 55 e0 mov -0x20(%ebp),%edx
10fb41: 0f 84 a4 00 00 00 je 10fbeb <_POSIX_Thread_Translate_sched_param+0xd3><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
10fb47: c7 07 00 00 00 00 movl $0x0,(%edi)
*budget_callout = NULL;
10fb4d: 8b 45 14 mov 0x14(%ebp),%eax
10fb50: c7 00 00 00 00 00 movl $0x0,(%eax)
if ( policy == SCHED_OTHER ) {
10fb56: 85 d2 test %edx,%edx
10fb58: 75 0b jne 10fb65 <_POSIX_Thread_Translate_sched_param+0x4d>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
10fb5a: c7 07 01 00 00 00 movl $0x1,(%edi)
10fb60: e9 83 00 00 00 jmp 10fbe8 <_POSIX_Thread_Translate_sched_param+0xd0>
return 0;
}
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
10fb65: 31 f6 xor %esi,%esi
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
10fb67: 83 fa 01 cmp $0x1,%edx
10fb6a: 74 7f je 10fbeb <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
10fb6c: 83 fa 02 cmp $0x2,%edx
10fb6f: 75 08 jne 10fb79 <_POSIX_Thread_Translate_sched_param+0x61>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
10fb71: c7 07 02 00 00 00 movl $0x2,(%edi)
return 0;
10fb77: eb 72 jmp 10fbeb <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
10fb79: 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 ) {
10fb7e: 83 fa 04 cmp $0x4,%edx
10fb81: 75 68 jne 10fbeb <_POSIX_Thread_Translate_sched_param+0xd3>
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
10fb83: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10fb87: 75 06 jne 10fb8f <_POSIX_Thread_Translate_sched_param+0x77>
10fb89: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10fb8d: 74 5c je 10fbeb <_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) &&
10fb8f: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10fb93: 75 0b jne 10fba0 <_POSIX_Thread_Translate_sched_param+0x88>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
10fb95: 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) &&
10fb9a: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fb9e: 74 4b je 10fbeb <_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 ) <
10fba0: 83 ec 0c sub $0xc,%esp
10fba3: 8d 43 08 lea 0x8(%ebx),%eax
10fba6: 50 push %eax
10fba7: e8 58 de ff ff call 10da04 <_Timespec_To_ticks>
10fbac: 89 45 e4 mov %eax,-0x1c(%ebp)
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
10fbaf: 8d 43 10 lea 0x10(%ebx),%eax
10fbb2: 89 04 24 mov %eax,(%esp)
10fbb5: e8 4a de ff ff call 10da04 <_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 ) <
10fbba: 83 c4 10 add $0x10,%esp
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
10fbbd: 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 ) <
10fbc2: 39 45 e4 cmp %eax,-0x1c(%ebp)
10fbc5: 72 24 jb 10fbeb <_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 ) )
10fbc7: 83 ec 0c sub $0xc,%esp
10fbca: ff 73 04 pushl 0x4(%ebx)
10fbcd: e8 26 ff ff ff call 10faf8 <_POSIX_Priority_Is_valid>
10fbd2: 83 c4 10 add $0x10,%esp
10fbd5: 84 c0 test %al,%al
10fbd7: 74 12 je 10fbeb <_POSIX_Thread_Translate_sched_param+0xd3>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
10fbd9: c7 07 03 00 00 00 movl $0x3,(%edi)
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
10fbdf: 8b 45 14 mov 0x14(%ebp),%eax
10fbe2: c7 00 41 a8 10 00 movl $0x10a841,(%eax)
return 0;
10fbe8: 66 31 f6 xor %si,%si
}
return EINVAL;
}
10fbeb: 89 f0 mov %esi,%eax
10fbed: 8d 65 f4 lea -0xc(%ebp),%esp
10fbf0: 5b pop %ebx
10fbf1: 5e pop %esi
10fbf2: 5f pop %edi
10fbf3: c9 leave
10fbf4: c3 ret
0010a544 <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
10a544: 55 push %ebp
10a545: 89 e5 mov %esp,%ebp
10a547: 57 push %edi
10a548: 56 push %esi
10a549: 53 push %ebx
10a54a: 83 ec 5c sub $0x5c,%esp
uint32_t maximum;
posix_initialization_threads_table *user_threads;
pthread_t thread_id;
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
10a54d: 8b 3d 10 12 12 00 mov 0x121210,%edi
maximum = Configuration_POSIX_API.number_of_initialization_threads;
10a553: 8b 15 0c 12 12 00 mov 0x12120c,%edx
if ( !user_threads || maximum == 0 )
10a559: 85 d2 test %edx,%edx
10a55b: 74 54 je 10a5b1 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a55d: 85 ff test %edi,%edi
10a55f: 74 50 je 10a5b1 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a561: 31 db xor %ebx,%ebx
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
10a563: 8d 75 a8 lea -0x58(%ebp),%esi
10a566: 83 ec 0c sub $0xc,%esp
10a569: 56 push %esi
10a56a: 89 55 a4 mov %edx,-0x5c(%ebp)
10a56d: e8 86 56 00 00 call 10fbf8 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
10a572: 5a pop %edx
10a573: 59 pop %ecx
10a574: 6a 02 push $0x2
10a576: 56 push %esi
10a577: e8 a4 56 00 00 call 10fc20 <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
10a57c: 59 pop %ecx
10a57d: 58 pop %eax
10a57e: ff 74 df 04 pushl 0x4(%edi,%ebx,8)
10a582: 56 push %esi
10a583: e8 c4 56 00 00 call 10fc4c <pthread_attr_setstacksize>
status = pthread_create(
10a588: 6a 00 push $0x0
10a58a: ff 34 df pushl (%edi,%ebx,8)
10a58d: 56 push %esi
10a58e: 8d 45 e4 lea -0x1c(%ebp),%eax
10a591: 50 push %eax
10a592: e8 e5 fc ff ff call 10a27c <pthread_create>
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
10a597: 83 c4 20 add $0x20,%esp
10a59a: 85 c0 test %eax,%eax
10a59c: 8b 55 a4 mov -0x5c(%ebp),%edx
10a59f: 74 0b je 10a5ac <_POSIX_Threads_Initialize_user_threads_body+0x68>
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
10a5a1: 52 push %edx
10a5a2: 50 push %eax
10a5a3: 6a 01 push $0x1
10a5a5: 6a 02 push $0x2
10a5a7: e8 fc 1b 00 00 call 10c1a8 <_Internal_error_Occurred>
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
10a5ac: 43 inc %ebx
10a5ad: 39 d3 cmp %edx,%ebx
10a5af: 72 b5 jb 10a566 <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
10a5b1: 8d 65 f4 lea -0xc(%ebp),%esp
10a5b4: 5b pop %ebx
10a5b5: 5e pop %esi
10a5b6: 5f pop %edi
10a5b7: c9 leave
10a5b8: c3 ret
0010ec4b <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
10ec4b: 55 push %ebp
10ec4c: 89 e5 mov %esp,%ebp
10ec4e: 56 push %esi
10ec4f: 53 push %ebx
10ec50: 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 ];
10ec53: 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 );
10ec59: 83 ec 0c sub $0xc,%esp
10ec5c: 8d 86 94 00 00 00 lea 0x94(%esi),%eax
10ec62: 50 push %eax
10ec63: e8 58 0e 00 00 call 10fac0 <_Timespec_To_ticks>
the_thread->cpu_time_budget = ticks;
10ec68: 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);
10ec6b: 0f b6 05 f4 01 12 00 movzbl 0x1201f4,%eax
10ec72: 2b 86 84 00 00 00 sub 0x84(%esi),%eax
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
10ec78: 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 ) {
10ec7b: 83 c4 10 add $0x10,%esp
10ec7e: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx)
10ec82: 75 12 jne 10ec96 <_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 ) {
10ec84: 39 43 14 cmp %eax,0x14(%ebx)
10ec87: 76 0d jbe 10ec96 <_POSIX_Threads_Sporadic_budget_TSR+0x4b>
_Thread_Change_priority( the_thread, new_priority, true );
10ec89: 52 push %edx
10ec8a: 6a 01 push $0x1
10ec8c: 50 push %eax
10ec8d: 53 push %ebx
10ec8e: e8 11 ce ff ff call 10baa4 <_Thread_Change_priority>
10ec93: 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 );
10ec96: 83 ec 0c sub $0xc,%esp
10ec99: 8d 86 8c 00 00 00 lea 0x8c(%esi),%eax
10ec9f: 50 push %eax
10eca0: e8 1b 0e 00 00 call 10fac0 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10eca5: 89 86 b0 00 00 00 mov %eax,0xb0(%esi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10ecab: 83 c4 10 add $0x10,%esp
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
10ecae: 81 c6 a4 00 00 00 add $0xa4,%esi
10ecb4: 89 75 0c mov %esi,0xc(%ebp)
10ecb7: c7 45 08 ac 42 12 00 movl $0x1242ac,0x8(%ebp)
}
10ecbe: 8d 65 f8 lea -0x8(%ebp),%esp
10ecc1: 5b pop %ebx
10ecc2: 5e pop %esi
10ecc3: c9 leave
10ecc4: e9 43 e0 ff ff jmp 10cd0c <_Watchdog_Insert>
0010ecc9 <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
10ecc9: 55 push %ebp
10ecca: 89 e5 mov %esp,%ebp
10eccc: 83 ec 08 sub $0x8,%esp
10eccf: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10ecd2: 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 */
10ecd8: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax)
10ecdf: 0f b6 15 f4 01 12 00 movzbl 0x1201f4,%edx
10ece6: 2b 91 88 00 00 00 sub 0x88(%ecx),%edx
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
10ecec: 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 ) {
10ecef: 83 78 1c 00 cmpl $0x0,0x1c(%eax)
10ecf3: 75 12 jne 10ed07 <_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 ) {
10ecf5: 39 50 14 cmp %edx,0x14(%eax)
10ecf8: 73 0d jae 10ed07 <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN
_Thread_Change_priority( the_thread, new_priority, true );
10ecfa: 51 push %ecx
10ecfb: 6a 01 push $0x1
10ecfd: 52 push %edx
10ecfe: 50 push %eax
10ecff: e8 a0 cd ff ff call 10baa4 <_Thread_Change_priority>
10ed04: 83 c4 10 add $0x10,%esp
#if 0
printk( "lower priority\n" );
#endif
}
}
}
10ed07: c9 leave
10ed08: c3 ret
0010a314 <_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)
{
10a314: 55 push %ebp
10a315: 89 e5 mov %esp,%ebp
10a317: 53 push %ebx
10a318: 83 ec 04 sub $0x4,%esp
10a31b: 8b 5d 0c mov 0xc(%ebp),%ebx
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
10a31e: ff 43 68 incl 0x68(%ebx)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
10a321: 83 7b 54 00 cmpl $0x0,0x54(%ebx)
10a325: 75 06 jne 10a32d <_POSIX_Timer_TSR+0x19>
10a327: 83 7b 58 00 cmpl $0x0,0x58(%ebx)
10a32b: 74 34 je 10a361 <_POSIX_Timer_TSR+0x4d> <== NEVER TAKEN
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
10a32d: 83 ec 0c sub $0xc,%esp
10a330: 53 push %ebx
10a331: 68 14 a3 10 00 push $0x10a314
10a336: ff 73 08 pushl 0x8(%ebx)
10a339: ff 73 64 pushl 0x64(%ebx)
10a33c: 8d 43 10 lea 0x10(%ebx),%eax
10a33f: 50 push %eax
10a340: e8 57 55 00 00 call 10f89c <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
10a345: 83 c4 20 add $0x20,%esp
10a348: 84 c0 test %al,%al
10a34a: 74 30 je 10a37c <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
10a34c: 83 ec 0c sub $0xc,%esp
10a34f: 8d 43 6c lea 0x6c(%ebx),%eax
10a352: 50 push %eax
10a353: e8 44 14 00 00 call 10b79c <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a358: c6 43 3c 03 movb $0x3,0x3c(%ebx)
10a35c: 83 c4 10 add $0x10,%esp
10a35f: eb 04 jmp 10a365 <_POSIX_Timer_TSR+0x51>
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a361: 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 ) ) {
10a365: 50 push %eax
10a366: 50 push %eax
10a367: ff 73 44 pushl 0x44(%ebx)
10a36a: ff 73 38 pushl 0x38(%ebx)
10a36d: e8 fe 50 00 00 call 10f470 <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
10a372: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
10a379: 83 c4 10 add $0x10,%esp
}
10a37c: 8b 5d fc mov -0x4(%ebp),%ebx
10a37f: c9 leave
10a380: c3 ret
00110b94 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
110b94: 55 push %ebp
110b95: 89 e5 mov %esp,%ebp
110b97: 57 push %edi
110b98: 56 push %esi
110b99: 53 push %ebx
110b9a: 83 ec 38 sub $0x38,%esp
110b9d: 8b 5d 08 mov 0x8(%ebp),%ebx
110ba0: 8b 75 0c mov 0xc(%ebp),%esi
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
110ba3: 6a 01 push $0x1
110ba5: 0f b6 45 10 movzbl 0x10(%ebp),%eax
110ba9: 50 push %eax
110baa: 8d 7d dc lea -0x24(%ebp),%edi
110bad: 57 push %edi
110bae: 56 push %esi
110baf: 53 push %ebx
110bb0: e8 5b 00 00 00 call 110c10 <_POSIX_signals_Clear_signals>
110bb5: 88 c2 mov %al,%dl
110bb7: 83 c4 20 add $0x20,%esp
is_global, true ) )
return false;
110bba: 31 c0 xor %eax,%eax
)
{
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
110bbc: 84 d2 test %dl,%dl
110bbe: 74 46 je 110c06 <_POSIX_signals_Check_signal+0x72>
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
110bc0: 6b ce 0c imul $0xc,%esi,%ecx
110bc3: 8b 91 4c 47 12 00 mov 0x12474c(%ecx),%edx
110bc9: 83 fa 01 cmp $0x1,%edx
110bcc: 74 38 je 110c06 <_POSIX_signals_Check_signal+0x72><== NEVER TAKEN
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
110bce: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
110bd4: 89 45 d4 mov %eax,-0x2c(%ebp)
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
110bd7: 0b 81 48 47 12 00 or 0x124748(%ecx),%eax
110bdd: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx)
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
110be3: 83 b9 44 47 12 00 02 cmpl $0x2,0x124744(%ecx)
110bea: 75 06 jne 110bf2 <_POSIX_signals_Check_signal+0x5e>
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
110bec: 50 push %eax
110bed: 6a 00 push $0x0
110bef: 57 push %edi
110bf0: eb 03 jmp 110bf5 <_POSIX_signals_Check_signal+0x61>
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
110bf2: 83 ec 0c sub $0xc,%esp
110bf5: 56 push %esi
110bf6: ff d2 call *%edx
break;
110bf8: 83 c4 10 add $0x10,%esp
}
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
110bfb: 8b 45 d4 mov -0x2c(%ebp),%eax
110bfe: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx)
return true;
110c04: b0 01 mov $0x1,%al
}
110c06: 8d 65 f4 lea -0xc(%ebp),%esp
110c09: 5b pop %ebx
110c0a: 5e pop %esi
110c0b: 5f pop %edi
110c0c: c9 leave
110c0d: c3 ret
00111104 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
111104: 55 push %ebp
111105: 89 e5 mov %esp,%ebp
111107: 53 push %ebx
111108: 8b 4d 08 mov 0x8(%ebp),%ecx
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
11110b: 9c pushf
11110c: fa cli
11110d: 5a pop %edx
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
11110e: 6b c1 0c imul $0xc,%ecx,%eax
111111: 83 b8 44 47 12 00 02 cmpl $0x2,0x124744(%eax)
111118: 75 0e jne 111128 <_POSIX_signals_Clear_process_signals+0x24>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
11111a: 8d 98 40 49 12 00 lea 0x124940(%eax),%ebx
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
111120: 39 98 3c 49 12 00 cmp %ebx,0x12493c(%eax)
111126: 75 0e jne 111136 <_POSIX_signals_Clear_process_signals+0x32><== NEVER TAKEN
111128: 49 dec %ecx
111129: b8 fe ff ff ff mov $0xfffffffe,%eax
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
11112e: d3 c0 rol %cl,%eax
111130: 21 05 38 49 12 00 and %eax,0x124938
}
_ISR_Enable( level );
111136: 52 push %edx
111137: 9d popf
}
111138: 5b pop %ebx
111139: c9 leave
11113a: c3 ret
0010abb8 <_POSIX_signals_Get_highest>:
#include <rtems/score/isr.h>
int _POSIX_signals_Get_highest(
sigset_t set
)
{
10abb8: 55 push %ebp
10abb9: 89 e5 mov %esp,%ebp
10abbb: 56 push %esi
10abbc: 53 push %ebx
10abbd: 8b 55 08 mov 0x8(%ebp),%edx
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10abc0: b8 1b 00 00 00 mov $0x1b,%eax
10abc5: 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_highest(
10abca: 8d 48 ff lea -0x1(%eax),%ecx
10abcd: 89 de mov %ebx,%esi
10abcf: d3 e6 shl %cl,%esi
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
10abd1: 85 d6 test %edx,%esi
10abd3: 75 1e jne 10abf3 <_POSIX_signals_Get_highest+0x3b><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10abd5: 40 inc %eax
10abd6: 83 f8 20 cmp $0x20,%eax
10abd9: 75 ef jne 10abca <_POSIX_signals_Get_highest+0x12>
10abdb: b0 01 mov $0x1,%al
10abdd: 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_highest(
10abe2: 8d 48 ff lea -0x1(%eax),%ecx
10abe5: 89 de mov %ebx,%esi
10abe7: 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 ) ) {
10abe9: 85 d6 test %edx,%esi
10abeb: 75 06 jne 10abf3 <_POSIX_signals_Get_highest+0x3b>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
10abed: 40 inc %eax
10abee: 83 f8 1b cmp $0x1b,%eax
10abf1: 75 ef jne 10abe2 <_POSIX_signals_Get_highest+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;
}
10abf3: 5b pop %ebx
10abf4: 5e pop %esi
10abf5: c9 leave
10abf6: c3 ret
00121b18 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
121b18: 55 push %ebp
121b19: 89 e5 mov %esp,%ebp
121b1b: 57 push %edi
121b1c: 56 push %esi
121b1d: 53 push %ebx
121b1e: 83 ec 0c sub $0xc,%esp
121b21: 8b 5d 08 mov 0x8(%ebp),%ebx
121b24: 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 ];
121b27: 8b 83 f8 00 00 00 mov 0xf8(%ebx),%eax
121b2d: 8d 4e ff lea -0x1(%esi),%ecx
121b30: ba 01 00 00 00 mov $0x1,%edx
121b35: d3 e2 shl %cl,%edx
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
121b37: 8b 4b 10 mov 0x10(%ebx),%ecx
121b3a: 89 cf mov %ecx,%edi
121b3c: 81 e7 00 80 00 10 and $0x10008000,%edi
121b42: 81 ff 00 80 00 10 cmp $0x10008000,%edi
121b48: 75 55 jne 121b9f <_POSIX_signals_Unblock_thread+0x87>
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
121b4a: 85 53 30 test %edx,0x30(%ebx)
121b4d: 75 12 jne 121b61 <_POSIX_signals_Unblock_thread+0x49>
121b4f: 8b 88 cc 00 00 00 mov 0xcc(%eax),%ecx
121b55: f7 d1 not %ecx
/*
* This should only be reached via pthread_kill().
*/
return false;
121b57: 31 c0 xor %eax,%eax
* 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) ) {
121b59: 85 ca test %ecx,%edx
121b5b: 0f 84 a5 00 00 00 je 121c06 <_POSIX_signals_Unblock_thread+0xee>
the_thread->Wait.return_code = EINTR;
121b61: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
121b68: 8b 43 28 mov 0x28(%ebx),%eax
if ( !info ) {
121b6b: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
121b6f: 75 12 jne 121b83 <_POSIX_signals_Unblock_thread+0x6b>
the_info->si_signo = signo;
121b71: 89 30 mov %esi,(%eax)
the_info->si_code = SI_USER;
121b73: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_info->si_value.sival_int = 0;
121b7a: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
121b81: eb 0c jmp 121b8f <_POSIX_signals_Unblock_thread+0x77>
} else {
*the_info = *info;
121b83: b9 03 00 00 00 mov $0x3,%ecx
121b88: 89 c7 mov %eax,%edi
121b8a: 8b 75 10 mov 0x10(%ebp),%esi
121b8d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
_Thread_queue_Extract_with_proxy( the_thread );
121b8f: 83 ec 0c sub $0xc,%esp
121b92: 53 push %ebx
121b93: e8 cc f1 fe ff call 110d64 <_Thread_queue_Extract_with_proxy>
return true;
121b98: 83 c4 10 add $0x10,%esp
121b9b: b0 01 mov $0x1,%al
121b9d: eb 67 jmp 121c06 <_POSIX_signals_Unblock_thread+0xee>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
121b9f: 8b b0 cc 00 00 00 mov 0xcc(%eax),%esi
121ba5: f7 d6 not %esi
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Context_Switch_necessary = true;
}
}
return false;
121ba7: 31 c0 xor %eax,%eax
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
121ba9: 85 f2 test %esi,%edx
121bab: 74 59 je 121c06 <_POSIX_signals_Unblock_thread+0xee>
* it is not blocked, THEN
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) {
121bad: f7 c1 00 00 00 10 test $0x10000000,%ecx
121bb3: 74 35 je 121bea <_POSIX_signals_Unblock_thread+0xd2>
the_thread->Wait.return_code = EINTR;
121bb5: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
#if 0
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
_Thread_queue_Extract_with_proxy( the_thread );
else
#endif
if ( _States_Is_delaying(the_thread->current_state) ){
121bbc: 80 e1 08 and $0x8,%cl
121bbf: 74 45 je 121c06 <_POSIX_signals_Unblock_thread+0xee><== NEVER TAKEN
if ( _Watchdog_Is_active( &the_thread->Timer ) )
121bc1: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
121bc5: 75 0f jne 121bd6 <_POSIX_signals_Unblock_thread+0xbe><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
121bc7: 83 ec 0c sub $0xc,%esp
121bca: 8d 43 48 lea 0x48(%ebx),%eax
121bcd: 50 push %eax
121bce: e8 1d fa fe ff call 1115f0 <_Watchdog_Remove>
121bd3: 83 c4 10 add $0x10,%esp
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
121bd6: 50 push %eax
121bd7: 50 push %eax
121bd8: 68 f8 ff 03 10 push $0x1003fff8
121bdd: 53 push %ebx
121bde: e8 ad e7 fe ff call 110390 <_Thread_Clear_state>
121be3: 83 c4 10 add $0x10,%esp
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Context_Switch_necessary = true;
}
}
return false;
121be6: 31 c0 xor %eax,%eax
121be8: eb 1c jmp 121c06 <_POSIX_signals_Unblock_thread+0xee>
if ( _States_Is_delaying(the_thread->current_state) ){
if ( _Watchdog_Is_active( &the_thread->Timer ) )
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
121bea: 85 c9 test %ecx,%ecx
121bec: 75 18 jne 121c06 <_POSIX_signals_Unblock_thread+0xee><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
121bee: 83 3d a4 a8 12 00 00 cmpl $0x0,0x12a8a4
121bf5: 74 0f je 121c06 <_POSIX_signals_Unblock_thread+0xee>
121bf7: 3b 1d a8 a8 12 00 cmp 0x12a8a8,%ebx
121bfd: 75 07 jne 121c06 <_POSIX_signals_Unblock_thread+0xee><== NEVER TAKEN
_Context_Switch_necessary = true;
121bff: c6 05 b4 a8 12 00 01 movb $0x1,0x12a8b4
}
}
return false;
}
121c06: 8d 65 f4 lea -0xc(%ebp),%esp
121c09: 5b pop %ebx
121c0a: 5e pop %esi
121c0b: 5f pop %edi
121c0c: c9 leave
121c0d: c3 ret
0010f164 <_RTEMS_Tasks_Invoke_task_variable_dtor>:
void _RTEMS_Tasks_Invoke_task_variable_dtor(
Thread_Control *the_thread,
rtems_task_variable_t *tvp
)
{
10f164: 55 push %ebp
10f165: 89 e5 mov %esp,%ebp
10f167: 56 push %esi
10f168: 53 push %ebx
10f169: 8b 5d 0c mov 0xc(%ebp),%ebx
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
10f16c: 8b 43 10 mov 0x10(%ebx),%eax
if (_Thread_Is_executing(the_thread)) {
10f16f: 8b 15 34 47 12 00 mov 0x124734,%edx
10f175: 39 55 08 cmp %edx,0x8(%ebp)
10f178: 75 0c jne 10f186 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x22><== NEVER TAKEN
value = *tvp->ptr;
10f17a: 8b 4b 04 mov 0x4(%ebx),%ecx
10f17d: 8b 11 mov (%ecx),%edx
*tvp->ptr = tvp->gval;
10f17f: 8b 73 08 mov 0x8(%ebx),%esi
10f182: 89 31 mov %esi,(%ecx)
10f184: eb 03 jmp 10f189 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x25>
} else {
value = tvp->tval;
10f186: 8b 53 0c mov 0xc(%ebx),%edx
}
if ( dtor )
10f189: 85 c0 test %eax,%eax
10f18b: 74 09 je 10f196 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x32>
(*dtor)(value);
10f18d: 83 ec 0c sub $0xc,%esp
10f190: 52 push %edx
10f191: ff d0 call *%eax
10f193: 83 c4 10 add $0x10,%esp
_Workspace_Free(tvp);
10f196: 89 5d 08 mov %ebx,0x8(%ebp)
}
10f199: 8d 65 f8 lea -0x8(%ebp),%esp
10f19c: 5b pop %ebx
10f19d: 5e pop %esi
10f19e: c9 leave
}
if ( dtor )
(*dtor)(value);
_Workspace_Free(tvp);
10f19f: e9 b3 dd ff ff jmp 10cf57 <_Workspace_Free>
0010ef91 <_RTEMS_tasks_Post_switch_extension>:
*/
void _RTEMS_tasks_Post_switch_extension(
Thread_Control *executing
)
{
10ef91: 55 push %ebp
10ef92: 89 e5 mov %esp,%ebp
10ef94: 57 push %edi
10ef95: 56 push %esi
10ef96: 53 push %ebx
10ef97: 83 ec 1c sub $0x1c,%esp
RTEMS_API_Control *api;
ASR_Information *asr;
rtems_signal_set signal_set;
Modes_Control prev_mode;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
10ef9a: 8b 45 08 mov 0x8(%ebp),%eax
10ef9d: 8b 98 f4 00 00 00 mov 0xf4(%eax),%ebx
if ( !api )
10efa3: 85 db test %ebx,%ebx
10efa5: 74 45 je 10efec <_RTEMS_tasks_Post_switch_extension+0x5b><== NEVER TAKEN
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
10efa7: 9c pushf
10efa8: fa cli
10efa9: 58 pop %eax
signal_set = asr->signals_posted;
10efaa: 8b 7b 14 mov 0x14(%ebx),%edi
asr->signals_posted = 0;
10efad: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
_ISR_Enable( level );
10efb4: 50 push %eax
10efb5: 9d popf
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
10efb6: 85 ff test %edi,%edi
10efb8: 74 32 je 10efec <_RTEMS_tasks_Post_switch_extension+0x5b>
return;
asr->nest_level += 1;
10efba: ff 43 1c incl 0x1c(%ebx)
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
10efbd: 50 push %eax
10efbe: 8d 75 e4 lea -0x1c(%ebp),%esi
10efc1: 56 push %esi
10efc2: 68 ff ff 00 00 push $0xffff
10efc7: ff 73 10 pushl 0x10(%ebx)
10efca: e8 a9 1d 00 00 call 110d78 <rtems_task_mode>
(*asr->handler)( signal_set );
10efcf: 89 3c 24 mov %edi,(%esp)
10efd2: ff 53 0c call *0xc(%ebx)
asr->nest_level -= 1;
10efd5: ff 4b 1c decl 0x1c(%ebx)
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
10efd8: 83 c4 0c add $0xc,%esp
10efdb: 56 push %esi
10efdc: 68 ff ff 00 00 push $0xffff
10efe1: ff 75 e4 pushl -0x1c(%ebp)
10efe4: e8 8f 1d 00 00 call 110d78 <rtems_task_mode>
10efe9: 83 c4 10 add $0x10,%esp
}
10efec: 8d 65 f4 lea -0xc(%ebp),%esp
10efef: 5b pop %ebx
10eff0: 5e pop %esi
10eff1: 5f pop %edi
10eff2: c9 leave
10eff3: c3 ret
0010b410 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10b410: 55 push %ebp
10b411: 89 e5 mov %esp,%ebp
10b413: 53 push %ebx
10b414: 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 );
10b417: 8d 45 f4 lea -0xc(%ebp),%eax
10b41a: 50 push %eax
10b41b: ff 75 08 pushl 0x8(%ebp)
10b41e: 68 14 72 12 00 push $0x127214
10b423: e8 d4 1a 00 00 call 10cefc <_Objects_Get>
10b428: 89 c3 mov %eax,%ebx
switch ( location ) {
10b42a: 83 c4 10 add $0x10,%esp
10b42d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10b431: 75 64 jne 10b497 <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10b433: 8b 40 40 mov 0x40(%eax),%eax
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10b436: f6 40 11 40 testb $0x40,0x11(%eax)
10b43a: 74 18 je 10b454 <_Rate_monotonic_Timeout+0x44>
10b43c: 8b 53 08 mov 0x8(%ebx),%edx
10b43f: 39 50 20 cmp %edx,0x20(%eax)
10b442: 75 10 jne 10b454 <_Rate_monotonic_Timeout+0x44>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10b444: 52 push %edx
10b445: 52 push %edx
10b446: 68 f8 ff 03 10 push $0x1003fff8
10b44b: 50 push %eax
10b44c: e8 13 1f 00 00 call 10d364 <_Thread_Clear_state>
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
10b451: 59 pop %ecx
10b452: eb 10 jmp 10b464 <_Rate_monotonic_Timeout+0x54>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
10b454: 83 7b 38 01 cmpl $0x1,0x38(%ebx)
10b458: 75 2b jne 10b485 <_Rate_monotonic_Timeout+0x75>
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
10b45a: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx)
_Rate_monotonic_Initiate_statistics( the_period );
10b461: 83 ec 0c sub $0xc,%esp
10b464: 53 push %ebx
10b465: e8 e8 fa ff ff call 10af52 <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b46a: 8b 43 3c mov 0x3c(%ebx),%eax
10b46d: 89 43 1c mov %eax,0x1c(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b470: 58 pop %eax
10b471: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
10b472: 83 c3 10 add $0x10,%ebx
10b475: 53 push %ebx
10b476: 68 d0 73 12 00 push $0x1273d0
10b47b: e8 c0 31 00 00 call 10e640 <_Watchdog_Insert>
10b480: 83 c4 10 add $0x10,%esp
10b483: eb 07 jmp 10b48c <_Rate_monotonic_Timeout+0x7c>
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
10b485: 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;
10b48c: a1 08 73 12 00 mov 0x127308,%eax
10b491: 48 dec %eax
10b492: a3 08 73 12 00 mov %eax,0x127308
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10b497: 8b 5d fc mov -0x4(%ebp),%ebx
10b49a: c9 leave
10b49b: c3 ret
0010ad18 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
10ad18: 55 push %ebp
10ad19: 89 e5 mov %esp,%ebp
10ad1b: 56 push %esi
10ad1c: 53 push %ebx
10ad1d: 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();
10ad20: 8b 35 84 44 12 00 mov 0x124484,%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;
10ad26: 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) ||
10ad28: 85 c9 test %ecx,%ecx
10ad2a: 74 57 je 10ad83 <_TOD_Validate+0x6b> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
10ad2c: b8 40 42 0f 00 mov $0xf4240,%eax
10ad31: 31 d2 xor %edx,%edx
10ad33: f7 f6 div %esi
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
10ad35: 39 41 18 cmp %eax,0x18(%ecx)
10ad38: 73 49 jae 10ad83 <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->ticks >= ticks_per_second) ||
10ad3a: 83 79 14 3b cmpl $0x3b,0x14(%ecx)
10ad3e: 77 43 ja 10ad83 <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
10ad40: 83 79 10 3b cmpl $0x3b,0x10(%ecx)
10ad44: 77 3d ja 10ad83 <_TOD_Validate+0x6b>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
10ad46: 83 79 0c 17 cmpl $0x17,0xc(%ecx)
10ad4a: 77 37 ja 10ad83 <_TOD_Validate+0x6b>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
10ad4c: 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) ||
10ad4f: 85 c0 test %eax,%eax
10ad51: 74 30 je 10ad83 <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->month == 0) ||
10ad53: 83 f8 0c cmp $0xc,%eax
10ad56: 77 2b ja 10ad83 <_TOD_Validate+0x6b>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10ad58: 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) ||
10ad5a: 81 fe c3 07 00 00 cmp $0x7c3,%esi
10ad60: 76 21 jbe 10ad83 <_TOD_Validate+0x6b>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
10ad62: 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) ||
10ad65: 85 d2 test %edx,%edx
10ad67: 74 1a je 10ad83 <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
10ad69: 83 e6 03 and $0x3,%esi
10ad6c: 75 09 jne 10ad77 <_TOD_Validate+0x5f>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
10ad6e: 8b 04 85 48 16 12 00 mov 0x121648(,%eax,4),%eax
10ad75: eb 07 jmp 10ad7e <_TOD_Validate+0x66>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
10ad77: 8b 04 85 14 16 12 00 mov 0x121614(,%eax,4),%eax
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
10ad7e: 39 c2 cmp %eax,%edx
10ad80: 0f 96 c3 setbe %bl
if ( the_tod->day > days_in_month )
return false;
return true;
}
10ad83: 88 d8 mov %bl,%al
10ad85: 5b pop %ebx
10ad86: 5e pop %esi
10ad87: c9 leave
10ad88: c3 ret
0010baa4 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10baa4: 55 push %ebp
10baa5: 89 e5 mov %esp,%ebp
10baa7: 57 push %edi
10baa8: 56 push %esi
10baa9: 53 push %ebx
10baaa: 83 ec 28 sub $0x28,%esp
10baad: 8b 5d 08 mov 0x8(%ebp),%ebx
10bab0: 8b 7d 0c mov 0xc(%ebp),%edi
10bab3: 8a 45 10 mov 0x10(%ebp),%al
10bab6: 88 45 e7 mov %al,-0x19(%ebp)
*/
/*
* Save original state
*/
original_state = the_thread->current_state;
10bab9: 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 );
10babc: 53 push %ebx
10babd: e8 42 0d 00 00 call 10c804 <_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 )
10bac2: 83 c4 10 add $0x10,%esp
10bac5: 39 7b 14 cmp %edi,0x14(%ebx)
10bac8: 74 0c je 10bad6 <_Thread_Change_priority+0x32>
_Thread_Set_priority( the_thread, new_priority );
10baca: 50 push %eax
10bacb: 50 push %eax
10bacc: 57 push %edi
10bacd: 53 push %ebx
10bace: e8 f9 0b 00 00 call 10c6cc <_Thread_Set_priority>
10bad3: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10bad6: 9c pushf
10bad7: fa cli
10bad8: 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;
10bad9: 8b 43 10 mov 0x10(%ebx),%eax
if ( state != STATES_TRANSIENT ) {
10badc: 83 f8 04 cmp $0x4,%eax
10badf: 74 2f je 10bb10 <_Thread_Change_priority+0x6c>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10bae1: 83 e6 04 and $0x4,%esi
10bae4: 75 08 jne 10baee <_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);
10bae6: 89 c2 mov %eax,%edx
10bae8: 83 e2 fb and $0xfffffffb,%edx
10baeb: 89 53 10 mov %edx,0x10(%ebx)
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
10baee: 51 push %ecx
10baef: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10baf0: a9 e0 be 03 00 test $0x3bee0,%eax
10baf5: 0f 84 c0 00 00 00 je 10bbbb <_Thread_Change_priority+0x117>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
10bafb: 89 5d 0c mov %ebx,0xc(%ebp)
10bafe: 8b 43 44 mov 0x44(%ebx),%eax
10bb01: 89 45 08 mov %eax,0x8(%ebp)
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Context_Switch_necessary = true;
_ISR_Enable( level );
}
10bb04: 8d 65 f4 lea -0xc(%ebp),%esp
10bb07: 5b pop %ebx
10bb08: 5e pop %esi
10bb09: 5f pop %edi
10bb0a: 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 );
10bb0b: e9 34 0b 00 00 jmp 10c644 <_Thread_queue_Requeue>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10bb10: 83 e6 04 and $0x4,%esi
10bb13: 75 53 jne 10bb68 <_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 );
10bb15: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (
Priority_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10bb1c: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax
10bb22: 66 8b 93 96 00 00 00 mov 0x96(%ebx),%dx
10bb29: 66 09 10 or %dx,(%eax)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10bb2c: 66 a1 88 42 12 00 mov 0x124288,%ax
10bb32: 0b 83 94 00 00 00 or 0x94(%ebx),%eax
10bb38: 66 a3 88 42 12 00 mov %ax,0x124288
_Priority_Add_to_bit_map( &the_thread->Priority_map );
if ( prepend_it )
10bb3e: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10bb42: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax
10bb48: 74 0e je 10bb58 <_Thread_Change_priority+0xb4>
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10bb4a: 89 43 04 mov %eax,0x4(%ebx)
before_node = after_node->next;
10bb4d: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10bb4f: 89 18 mov %ebx,(%eax)
the_node->next = before_node;
10bb51: 89 13 mov %edx,(%ebx)
before_node->previous = the_node;
10bb53: 89 5a 04 mov %ebx,0x4(%edx)
10bb56: eb 10 jmp 10bb68 <_Thread_Change_priority+0xc4>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10bb58: 8d 50 04 lea 0x4(%eax),%edx
10bb5b: 89 13 mov %edx,(%ebx)
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
10bb5d: 8b 50 08 mov 0x8(%eax),%edx
the_chain->last = the_node;
10bb60: 89 58 08 mov %ebx,0x8(%eax)
old_last_node->next = the_node;
10bb63: 89 1a mov %ebx,(%edx)
the_node->previous = old_last_node;
10bb65: 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 );
10bb68: 51 push %ecx
10bb69: 9d popf
10bb6a: fa cli
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_highest( void )
{
Priority_Bit_map_control minor;
Priority_Bit_map_control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
10bb6b: 66 8b 1d 88 42 12 00 mov 0x124288,%bx
10bb72: 31 c0 xor %eax,%eax
10bb74: 89 c2 mov %eax,%edx
10bb76: 66 0f bc d3 bsf %bx,%dx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10bb7a: 0f b7 d2 movzwl %dx,%edx
10bb7d: 66 8b 9c 12 f8 42 12 mov 0x1242f8(%edx,%edx,1),%bx
10bb84: 00
10bb85: 66 0f bc c3 bsf %bx,%ax
return (_Priority_Bits_index( major ) << 4) +
10bb89: c1 e2 04 shl $0x4,%edx
10bb8c: 0f b7 c0 movzwl %ax,%eax
*/
RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
_Thread_Heir = (Thread_Control *)
_Thread_Ready_chain[ _Priority_Get_highest() ].first;
10bb8f: 8d 04 02 lea (%edx,%eax,1),%eax
10bb92: 6b c0 0c imul $0xc,%eax,%eax
10bb95: 03 05 b0 41 12 00 add 0x1241b0,%eax
* ready thread.
*/
RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
_Thread_Heir = (Thread_Control *)
10bb9b: 8b 10 mov (%eax),%edx
10bb9d: 89 15 38 47 12 00 mov %edx,0x124738
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
10bba3: a1 34 47 12 00 mov 0x124734,%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() &&
10bba8: 39 d0 cmp %edx,%eax
10bbaa: 74 0d je 10bbb9 <_Thread_Change_priority+0x115>
10bbac: 80 78 74 00 cmpb $0x0,0x74(%eax)
10bbb0: 74 07 je 10bbb9 <_Thread_Change_priority+0x115>
_Thread_Executing->is_preemptible )
_Context_Switch_necessary = true;
10bbb2: c6 05 40 47 12 00 01 movb $0x1,0x124740
_ISR_Enable( level );
10bbb9: 51 push %ecx
10bbba: 9d popf
}
10bbbb: 8d 65 f4 lea -0xc(%ebp),%esp
10bbbe: 5b pop %ebx
10bbbf: 5e pop %esi
10bbc0: 5f pop %edi
10bbc1: c9 leave
10bbc2: c3 ret
0010bbc4 <_Thread_Clear_state>:
void _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
10bbc4: 55 push %ebp
10bbc5: 89 e5 mov %esp,%ebp
10bbc7: 53 push %ebx
10bbc8: 8b 45 08 mov 0x8(%ebp),%eax
10bbcb: 8b 55 0c mov 0xc(%ebp),%edx
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10bbce: 9c pushf
10bbcf: fa cli
10bbd0: 59 pop %ecx
current_state = the_thread->current_state;
10bbd1: 8b 58 10 mov 0x10(%eax),%ebx
if ( current_state & state ) {
10bbd4: 85 da test %ebx,%edx
10bbd6: 74 71 je 10bc49 <_Thread_Clear_state+0x85>
10bbd8: f7 d2 not %edx
10bbda: 21 da and %ebx,%edx
current_state =
the_thread->current_state = _States_Clear( state, current_state );
10bbdc: 89 50 10 mov %edx,0x10(%eax)
if ( _States_Is_ready( current_state ) ) {
10bbdf: 85 d2 test %edx,%edx
10bbe1: 75 66 jne 10bc49 <_Thread_Clear_state+0x85>
RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (
Priority_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10bbe3: 8b 90 90 00 00 00 mov 0x90(%eax),%edx
10bbe9: 66 8b 98 96 00 00 00 mov 0x96(%eax),%bx
10bbf0: 66 09 1a or %bx,(%edx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10bbf3: 66 8b 15 88 42 12 00 mov 0x124288,%dx
10bbfa: 0b 90 94 00 00 00 or 0x94(%eax),%edx
10bc00: 66 89 15 88 42 12 00 mov %dx,0x124288
_Priority_Add_to_bit_map( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
10bc07: 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;
10bc0d: 8d 5a 04 lea 0x4(%edx),%ebx
10bc10: 89 18 mov %ebx,(%eax)
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
10bc12: 8b 5a 08 mov 0x8(%edx),%ebx
the_chain->last = the_node;
10bc15: 89 42 08 mov %eax,0x8(%edx)
old_last_node->next = the_node;
10bc18: 89 03 mov %eax,(%ebx)
the_node->previous = old_last_node;
10bc1a: 89 58 04 mov %ebx,0x4(%eax)
_ISR_Flash( level );
10bc1d: 51 push %ecx
10bc1e: 9d popf
10bc1f: 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 ) {
10bc20: 8b 50 14 mov 0x14(%eax),%edx
10bc23: 8b 1d 38 47 12 00 mov 0x124738,%ebx
10bc29: 3b 53 14 cmp 0x14(%ebx),%edx
10bc2c: 73 1b jae 10bc49 <_Thread_Clear_state+0x85>
_Thread_Heir = the_thread;
10bc2e: a3 38 47 12 00 mov %eax,0x124738
if ( _Thread_Executing->is_preemptible ||
10bc33: a1 34 47 12 00 mov 0x124734,%eax
10bc38: 80 78 74 00 cmpb $0x0,0x74(%eax)
10bc3c: 75 04 jne 10bc42 <_Thread_Clear_state+0x7e>
10bc3e: 85 d2 test %edx,%edx
10bc40: 75 07 jne 10bc49 <_Thread_Clear_state+0x85><== ALWAYS TAKEN
the_thread->current_priority == 0 )
_Context_Switch_necessary = true;
10bc42: c6 05 40 47 12 00 01 movb $0x1,0x124740
}
}
}
_ISR_Enable( level );
10bc49: 51 push %ecx
10bc4a: 9d popf
}
10bc4b: 5b pop %ebx
10bc4c: c9 leave
10bc4d: c3 ret
0010bdc4 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10bdc4: 55 push %ebp
10bdc5: 89 e5 mov %esp,%ebp
10bdc7: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10bdca: 8d 45 f4 lea -0xc(%ebp),%eax
10bdcd: 50 push %eax
10bdce: ff 75 08 pushl 0x8(%ebp)
10bdd1: e8 82 01 00 00 call 10bf58 <_Thread_Get>
switch ( location ) {
10bdd6: 83 c4 10 add $0x10,%esp
10bdd9: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10bddd: 75 1b jne 10bdfa <_Thread_Delay_ended+0x36><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
10bddf: 52 push %edx
10bde0: 52 push %edx
10bde1: 68 18 00 00 10 push $0x10000018
10bde6: 50 push %eax
10bde7: e8 d8 fd ff ff call 10bbc4 <_Thread_Clear_state>
10bdec: a1 e4 41 12 00 mov 0x1241e4,%eax
10bdf1: 48 dec %eax
10bdf2: a3 e4 41 12 00 mov %eax,0x1241e4
10bdf7: 83 c4 10 add $0x10,%esp
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
10bdfa: c9 leave
10bdfb: c3 ret
0010bdfc <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10bdfc: 55 push %ebp
10bdfd: 89 e5 mov %esp,%ebp
10bdff: 57 push %edi
10be00: 56 push %esi
10be01: 53 push %ebx
10be02: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10be05: 8b 1d 34 47 12 00 mov 0x124734,%ebx
_ISR_Disable( level );
10be0b: 9c pushf
10be0c: fa cli
10be0d: 58 pop %eax
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
10be0e: 8d 7d d8 lea -0x28(%ebp),%edi
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Context_Switch_necessary == true ) {
10be11: e9 f9 00 00 00 jmp 10bf0f <_Thread_Dispatch+0x113>
heir = _Thread_Heir;
10be16: 8b 35 38 47 12 00 mov 0x124738,%esi
_Thread_Dispatch_disable_level = 1;
10be1c: c7 05 e4 41 12 00 01 movl $0x1,0x1241e4
10be23: 00 00 00
_Context_Switch_necessary = false;
10be26: c6 05 40 47 12 00 00 movb $0x0,0x124740
_Thread_Executing = heir;
10be2d: 89 35 34 47 12 00 mov %esi,0x124734
/*
* 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 )
10be33: 39 de cmp %ebx,%esi
10be35: 0f 84 e2 00 00 00 je 10bf1d <_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 )
10be3b: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10be3f: 75 09 jne 10be4a <_Thread_Dispatch+0x4e>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10be41: 8b 15 b4 41 12 00 mov 0x1241b4,%edx
10be47: 89 56 78 mov %edx,0x78(%esi)
_ISR_Enable( level );
10be4a: 50 push %eax
10be4b: 9d popf
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
10be4c: 83 ec 0c sub $0xc,%esp
10be4f: 8d 45 e0 lea -0x20(%ebp),%eax
10be52: 50 push %eax
10be53: e8 70 35 00 00 call 10f3c8 <_TOD_Get_uptime>
_Timestamp_Subtract(
10be58: 83 c4 0c add $0xc,%esp
10be5b: 57 push %edi
10be5c: 8d 45 e0 lea -0x20(%ebp),%eax
10be5f: 50 push %eax
10be60: 68 98 42 12 00 push $0x124298
10be65: e8 36 0c 00 00 call 10caa0 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
10be6a: 58 pop %eax
10be6b: 5a pop %edx
10be6c: 57 push %edi
10be6d: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax
10be73: 50 push %eax
10be74: e8 f7 0b 00 00 call 10ca70 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10be79: 8b 45 e0 mov -0x20(%ebp),%eax
10be7c: 8b 55 e4 mov -0x1c(%ebp),%edx
10be7f: a3 98 42 12 00 mov %eax,0x124298
10be84: 89 15 9c 42 12 00 mov %edx,0x12429c
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10be8a: a1 6c 42 12 00 mov 0x12426c,%eax
10be8f: 83 c4 10 add $0x10,%esp
10be92: 85 c0 test %eax,%eax
10be94: 74 10 je 10bea6 <_Thread_Dispatch+0xaa> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10be96: 8b 10 mov (%eax),%edx
10be98: 89 93 f0 00 00 00 mov %edx,0xf0(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10be9e: 8b 96 f0 00 00 00 mov 0xf0(%esi),%edx
10bea4: 89 10 mov %edx,(%eax)
}
_User_extensions_Thread_switch( executing, heir );
10bea6: 51 push %ecx
10bea7: 51 push %ecx
10bea8: 56 push %esi
10bea9: 53 push %ebx
10beaa: e8 29 0e 00 00 call 10ccd8 <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10beaf: 58 pop %eax
10beb0: 5a pop %edx
10beb1: 81 c6 d4 00 00 00 add $0xd4,%esi
10beb7: 56 push %esi
10beb8: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax
10bebe: 50 push %eax
10bebf: e8 dc 10 00 00 call 10cfa0 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10bec4: 83 c4 10 add $0x10,%esp
10bec7: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx)
10bece: 74 36 je 10bf06 <_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 );
10bed0: a1 68 42 12 00 mov 0x124268,%eax
10bed5: 39 c3 cmp %eax,%ebx
10bed7: 74 2d je 10bf06 <_Thread_Dispatch+0x10a>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10bed9: 85 c0 test %eax,%eax
10bedb: 74 11 je 10beee <_Thread_Dispatch+0xf2>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10bedd: 83 ec 0c sub $0xc,%esp
10bee0: 05 ec 00 00 00 add $0xec,%eax
10bee5: 50 push %eax
10bee6: e8 e9 10 00 00 call 10cfd4 <_CPU_Context_save_fp>
10beeb: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10beee: 83 ec 0c sub $0xc,%esp
10bef1: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax
10bef7: 50 push %eax
10bef8: e8 e1 10 00 00 call 10cfde <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10befd: 89 1d 68 42 12 00 mov %ebx,0x124268
10bf03: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10bf06: 8b 1d 34 47 12 00 mov 0x124734,%ebx
_ISR_Disable( level );
10bf0c: 9c pushf
10bf0d: fa cli
10bf0e: 58 pop %eax
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Context_Switch_necessary == true ) {
10bf0f: 8a 15 40 47 12 00 mov 0x124740,%dl
10bf15: 84 d2 test %dl,%dl
10bf17: 0f 85 f9 fe ff ff jne 10be16 <_Thread_Dispatch+0x1a>
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
10bf1d: c7 05 e4 41 12 00 00 movl $0x0,0x1241e4
10bf24: 00 00 00
_ISR_Enable( level );
10bf27: 50 push %eax
10bf28: 9d popf
_API_extensions_Run_postswitch();
10bf29: e8 09 ea ff ff call 10a937 <_API_extensions_Run_postswitch>
}
10bf2e: 8d 65 f4 lea -0xc(%ebp),%esp
10bf31: 5b pop %ebx
10bf32: 5e pop %esi
10bf33: 5f pop %edi
10bf34: c9 leave
10bf35: c3 ret
0010bf58 <_Thread_Get>:
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
10bf58: 55 push %ebp
10bf59: 89 e5 mov %esp,%ebp
10bf5b: 53 push %ebx
10bf5c: 83 ec 04 sub $0x4,%esp
10bf5f: 8b 55 08 mov 0x8(%ebp),%edx
10bf62: 8b 45 0c mov 0xc(%ebp),%eax
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
10bf65: 85 d2 test %edx,%edx
10bf67: 75 1a jne 10bf83 <_Thread_Get+0x2b>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10bf69: 8b 15 e4 41 12 00 mov 0x1241e4,%edx
10bf6f: 42 inc %edx
10bf70: 89 15 e4 41 12 00 mov %edx,0x1241e4
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
10bf76: c7 00 00 00 00 00 movl $0x0,(%eax)
tp = _Thread_Executing;
10bf7c: a1 34 47 12 00 mov 0x124734,%eax
goto done;
10bf81: eb 3a jmp 10bfbd <_Thread_Get+0x65>
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
10bf83: 89 d1 mov %edx,%ecx
10bf85: c1 e9 18 shr $0x18,%ecx
10bf88: 83 e1 07 and $0x7,%ecx
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
10bf8b: 8d 59 ff lea -0x1(%ecx),%ebx
10bf8e: 83 fb 02 cmp $0x2,%ebx
10bf91: 76 2f jbe 10bfc2 <_Thread_Get+0x6a>
10bf93: eb 12 jmp 10bfa7 <_Thread_Get+0x4f>
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
goto done;
}
api_information = _Objects_Information_table[ the_api ];
10bf95: 8b 0c 8d bc 41 12 00 mov 0x1241bc(,%ecx,4),%ecx
if ( !api_information ) {
10bf9c: 85 c9 test %ecx,%ecx
10bf9e: 74 07 je 10bfa7 <_Thread_Get+0x4f> <== NEVER TAKEN
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
10bfa0: 8b 49 04 mov 0x4(%ecx),%ecx
if ( !information ) {
10bfa3: 85 c9 test %ecx,%ecx
10bfa5: 75 0a jne 10bfb1 <_Thread_Get+0x59>
*location = OBJECTS_ERROR;
10bfa7: c7 00 01 00 00 00 movl $0x1,(%eax)
{
uint32_t the_api;
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
10bfad: 31 c0 xor %eax,%eax
}
information = api_information[ the_class ];
if ( !information ) {
*location = OBJECTS_ERROR;
goto done;
10bfaf: eb 0c jmp 10bfbd <_Thread_Get+0x65>
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
10bfb1: 53 push %ebx
10bfb2: 50 push %eax
10bfb3: 52 push %edx
10bfb4: 51 push %ecx
10bfb5: e8 a2 f7 ff ff call 10b75c <_Objects_Get>
10bfba: 83 c4 10 add $0x10,%esp
done:
return tp;
}
10bfbd: 8b 5d fc mov -0x4(%ebp),%ebx
10bfc0: c9 leave
10bfc1: c3 ret
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10bfc2: 89 d3 mov %edx,%ebx
10bfc4: c1 eb 1b shr $0x1b,%ebx
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
10bfc7: 4b dec %ebx
10bfc8: 74 cb je 10bf95 <_Thread_Get+0x3d>
10bfca: eb db jmp 10bfa7 <_Thread_Get+0x4f>
00110fb8 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
110fb8: 55 push %ebp
110fb9: 89 e5 mov %esp,%ebp
110fbb: 53 push %ebx
110fbc: 83 ec 14 sub $0x14,%esp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
110fbf: 8b 1d 34 47 12 00 mov 0x124734,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
110fc5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
_ISR_Set_level(level);
110fcb: 85 c0 test %eax,%eax
110fcd: 74 03 je 110fd2 <_Thread_Handler+0x1a>
110fcf: fa cli
110fd0: eb 01 jmp 110fd3 <_Thread_Handler+0x1b>
110fd2: fb sti
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
110fd3: a0 a0 3e 12 00 mov 0x123ea0,%al
110fd8: 88 45 f7 mov %al,-0x9(%ebp)
doneConstructors = 1;
110fdb: c6 05 a0 3e 12 00 01 movb $0x1,0x123ea0
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
110fe2: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx)
110fe9: 74 24 je 11100f <_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 );
110feb: a1 68 42 12 00 mov 0x124268,%eax
110ff0: 39 c3 cmp %eax,%ebx
110ff2: 74 1b je 11100f <_Thread_Handler+0x57>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
110ff4: 85 c0 test %eax,%eax
110ff6: 74 11 je 111009 <_Thread_Handler+0x51>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
110ff8: 83 ec 0c sub $0xc,%esp
110ffb: 05 ec 00 00 00 add $0xec,%eax
111000: 50 push %eax
111001: e8 ce bf ff ff call 10cfd4 <_CPU_Context_save_fp>
111006: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
111009: 89 1d 68 42 12 00 mov %ebx,0x124268
/*
* 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 );
11100f: 83 ec 0c sub $0xc,%esp
111012: 53 push %ebx
111013: e8 70 bb ff ff call 10cb88 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
111018: e8 19 af ff ff call 10bf36 <_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) */ {
11101d: 83 c4 10 add $0x10,%esp
111020: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
111024: 75 05 jne 11102b <_Thread_Handler+0x73>
INIT_NAME ();
111026: e8 85 c0 00 00 call 11d0b0 <__start_set_sysctl_set>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
11102b: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
111031: 85 c0 test %eax,%eax
111033: 75 0b jne 111040 <_Thread_Handler+0x88>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
111035: 83 ec 0c sub $0xc,%esp
111038: ff b3 a8 00 00 00 pushl 0xa8(%ebx)
11103e: eb 0c jmp 11104c <_Thread_Handler+0x94>
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
111040: 48 dec %eax
111041: 75 15 jne 111058 <_Thread_Handler+0xa0> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
111043: 83 ec 0c sub $0xc,%esp
111046: ff b3 a4 00 00 00 pushl 0xa4(%ebx)
11104c: 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 =
111052: 89 43 28 mov %eax,0x28(%ebx)
111055: 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 );
111058: 83 ec 0c sub $0xc,%esp
11105b: 53 push %ebx
11105c: e8 58 bb ff ff call 10cbb9 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
111061: 83 c4 0c add $0xc,%esp
111064: 6a 05 push $0x5
111066: 6a 01 push $0x1
111068: 6a 00 push $0x0
11106a: e8 31 a2 ff ff call 10b2a0 <_Internal_error_Occurred>
0010bfcc <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10bfcc: 55 push %ebp
10bfcd: 89 e5 mov %esp,%ebp
10bfcf: 57 push %edi
10bfd0: 56 push %esi
10bfd1: 53 push %ebx
10bfd2: 83 ec 1c sub $0x1c,%esp
10bfd5: 8b 5d 0c mov 0xc(%ebp),%ebx
10bfd8: 8b 4d 10 mov 0x10(%ebp),%ecx
10bfdb: 8b 75 14 mov 0x14(%ebp),%esi
10bfde: 8a 55 18 mov 0x18(%ebp),%dl
10bfe1: 8a 45 20 mov 0x20(%ebp),%al
10bfe4: 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;
10bfe7: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx)
10bfee: 00 00 00
10bff1: c7 83 f8 00 00 00 00 movl $0x0,0xf8(%ebx)
10bff8: 00 00 00
extensions_area = NULL;
the_thread->libc_reent = NULL;
10bffb: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx)
10c002: 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 ) {
10c005: 85 c9 test %ecx,%ecx
10c007: 75 31 jne 10c03a <_Thread_Initialize+0x6e>
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10c009: 51 push %ecx
10c00a: 51 push %ecx
10c00b: 56 push %esi
10c00c: 53 push %ebx
10c00d: 88 55 e0 mov %dl,-0x20(%ebp)
10c010: e8 63 08 00 00 call 10c878 <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10c015: 83 c4 10 add $0x10,%esp
10c018: 39 f0 cmp %esi,%eax
10c01a: 8a 55 e0 mov -0x20(%ebp),%dl
10c01d: 0f 82 c1 01 00 00 jb 10c1e4 <_Thread_Initialize+0x218>
10c023: 85 c0 test %eax,%eax
10c025: 0f 84 b9 01 00 00 je 10c1e4 <_Thread_Initialize+0x218><== NEVER TAKEN
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
10c02b: 8b 8b d0 00 00 00 mov 0xd0(%ebx),%ecx
the_thread->Start.core_allocated_stack = true;
10c031: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx)
10c038: eb 09 jmp 10c043 <_Thread_Initialize+0x77>
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
10c03a: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx)
10c041: 89 f0 mov %esi,%eax
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
10c043: 89 8b c8 00 00 00 mov %ecx,0xc8(%ebx)
the_stack->size = size;
10c049: 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;
10c04f: 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 ) {
10c051: 84 d2 test %dl,%dl
10c053: 74 17 je 10c06c <_Thread_Initialize+0xa0>
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
10c055: 83 ec 0c sub $0xc,%esp
10c058: 6a 6c push $0x6c
10c05a: e8 df 0e 00 00 call 10cf3e <_Workspace_Allocate>
10c05f: 89 c7 mov %eax,%edi
if ( !fp_area )
10c061: 83 c4 10 add $0x10,%esp
10c064: 85 c0 test %eax,%eax
10c066: 0f 84 08 01 00 00 je 10c174 <_Thread_Initialize+0x1a8>
goto failed;
fp_area = _Context_Fp_start( fp_area, 0 );
}
the_thread->fp_context = fp_area;
10c06c: 89 bb ec 00 00 00 mov %edi,0xec(%ebx)
the_thread->Start.fp_context = fp_area;
10c072: 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;
10c078: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10c07f: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
the_watchdog->id = id;
10c086: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
the_watchdog->user_data = user_data;
10c08d: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c094: a1 78 42 12 00 mov 0x124278,%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;
10c099: 31 f6 xor %esi,%esi
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c09b: 85 c0 test %eax,%eax
10c09d: 74 1d je 10c0bc <_Thread_Initialize+0xf0>
extensions_area = _Workspace_Allocate(
10c09f: 83 ec 0c sub $0xc,%esp
10c0a2: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax
10c0a9: 50 push %eax
10c0aa: e8 8f 0e 00 00 call 10cf3e <_Workspace_Allocate>
10c0af: 89 c6 mov %eax,%esi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
10c0b1: 83 c4 10 add $0x10,%esp
10c0b4: 85 c0 test %eax,%eax
10c0b6: 0f 84 ba 00 00 00 je 10c176 <_Thread_Initialize+0x1aa>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10c0bc: 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 ) {
10c0c2: 85 f6 test %esi,%esi
10c0c4: 74 16 je 10c0dc <_Thread_Initialize+0x110>
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
10c0c6: 8b 15 78 42 12 00 mov 0x124278,%edx
10c0cc: 31 c0 xor %eax,%eax
10c0ce: eb 08 jmp 10c0d8 <_Thread_Initialize+0x10c>
the_thread->extensions[i] = NULL;
10c0d0: 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++ )
10c0d7: 40 inc %eax
10c0d8: 39 d0 cmp %edx,%eax
10c0da: 76 f4 jbe 10c0d0 <_Thread_Initialize+0x104>
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10c0dc: 8a 45 e7 mov -0x19(%ebp),%al
10c0df: 88 83 ac 00 00 00 mov %al,0xac(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10c0e5: 8b 45 24 mov 0x24(%ebp),%eax
10c0e8: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx)
the_thread->Start.budget_callout = budget_callout;
10c0ee: 8b 45 28 mov 0x28(%ebp),%eax
10c0f1: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx)
switch ( budget_algorithm ) {
10c0f7: 83 7d 24 02 cmpl $0x2,0x24(%ebp)
10c0fb: 75 08 jne 10c105 <_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;
10c0fd: a1 b4 41 12 00 mov 0x1241b4,%eax
10c102: 89 43 78 mov %eax,0x78(%ebx)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
10c105: 8b 45 2c mov 0x2c(%ebp),%eax
10c108: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
the_thread->current_state = STATES_DORMANT;
10c10e: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10c115: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10c11c: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->real_priority = priority;
10c123: 8b 45 1c mov 0x1c(%ebp),%eax
10c126: 89 43 18 mov %eax,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10c129: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
_Thread_Set_priority( the_thread, priority );
10c12f: 52 push %edx
10c130: 52 push %edx
10c131: 50 push %eax
10c132: 53 push %ebx
10c133: e8 94 05 00 00 call 10c6cc <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
10c138: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10c13f: 00 00 00
10c142: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10c149: 00 00 00
_Thread_Stack_Free( the_thread );
return false;
}
10c14c: 8b 45 08 mov 0x8(%ebp),%eax
10c14f: 8b 40 1c mov 0x1c(%eax),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c152: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c156: 89 1c 90 mov %ebx,(%eax,%edx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c159: 8b 45 30 mov 0x30(%ebp),%eax
10c15c: 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 );
10c15f: 89 1c 24 mov %ebx,(%esp)
10c162: e8 c1 0a 00 00 call 10cc28 <_User_extensions_Thread_create>
10c167: 88 c2 mov %al,%dl
if ( extension_status )
10c169: 83 c4 10 add $0x10,%esp
return true;
10c16c: 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 )
10c16e: 84 d2 test %dl,%dl
10c170: 74 04 je 10c176 <_Thread_Initialize+0x1aa>
10c172: eb 72 jmp 10c1e6 <_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;
10c174: 31 f6 xor %esi,%esi
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
failed:
if ( the_thread->libc_reent )
10c176: 8b 83 f0 00 00 00 mov 0xf0(%ebx),%eax
10c17c: 85 c0 test %eax,%eax
10c17e: 74 0c je 10c18c <_Thread_Initialize+0x1c0>
_Workspace_Free( the_thread->libc_reent );
10c180: 83 ec 0c sub $0xc,%esp
10c183: 50 push %eax
10c184: e8 ce 0d 00 00 call 10cf57 <_Workspace_Free>
10c189: 83 c4 10 add $0x10,%esp
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
10c18c: 8b 83 f4 00 00 00 mov 0xf4(%ebx),%eax
10c192: 85 c0 test %eax,%eax
10c194: 74 0c je 10c1a2 <_Thread_Initialize+0x1d6>
_Workspace_Free( the_thread->API_Extensions[i] );
10c196: 83 ec 0c sub $0xc,%esp
10c199: 50 push %eax
10c19a: e8 b8 0d 00 00 call 10cf57 <_Workspace_Free>
10c19f: 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] )
10c1a2: 8b 83 f8 00 00 00 mov 0xf8(%ebx),%eax
10c1a8: 85 c0 test %eax,%eax
10c1aa: 74 0c je 10c1b8 <_Thread_Initialize+0x1ec>
_Workspace_Free( the_thread->API_Extensions[i] );
10c1ac: 83 ec 0c sub $0xc,%esp
10c1af: 50 push %eax
10c1b0: e8 a2 0d 00 00 call 10cf57 <_Workspace_Free>
10c1b5: 83 c4 10 add $0x10,%esp
if ( extensions_area )
10c1b8: 85 f6 test %esi,%esi
10c1ba: 74 0c je 10c1c8 <_Thread_Initialize+0x1fc>
(void) _Workspace_Free( extensions_area );
10c1bc: 83 ec 0c sub $0xc,%esp
10c1bf: 56 push %esi
10c1c0: e8 92 0d 00 00 call 10cf57 <_Workspace_Free>
10c1c5: 83 c4 10 add $0x10,%esp
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
10c1c8: 85 ff test %edi,%edi
10c1ca: 74 0c je 10c1d8 <_Thread_Initialize+0x20c>
(void) _Workspace_Free( fp_area );
10c1cc: 83 ec 0c sub $0xc,%esp
10c1cf: 57 push %edi
10c1d0: e8 82 0d 00 00 call 10cf57 <_Workspace_Free>
10c1d5: 83 c4 10 add $0x10,%esp
#endif
_Thread_Stack_Free( the_thread );
10c1d8: 83 ec 0c sub $0xc,%esp
10c1db: 53 push %ebx
10c1dc: e8 e7 06 00 00 call 10c8c8 <_Thread_Stack_Free>
return false;
10c1e1: 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 */
10c1e4: 31 c0 xor %eax,%eax
_Thread_Stack_Free( the_thread );
return false;
}
10c1e6: 8d 65 f4 lea -0xc(%ebp),%esp
10c1e9: 5b pop %ebx
10c1ea: 5e pop %esi
10c1eb: 5f pop %edi
10c1ec: c9 leave
10c1ed: c3 ret
0010f468 <_Thread_Resume>:
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
10f468: 55 push %ebp
10f469: 89 e5 mov %esp,%ebp
10f46b: 53 push %ebx
10f46c: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10f46f: 9c pushf
10f470: fa cli
10f471: 59 pop %ecx
current_state = the_thread->current_state;
10f472: 8b 50 10 mov 0x10(%eax),%edx
if ( current_state & STATES_SUSPENDED ) {
10f475: f6 c2 02 test $0x2,%dl
10f478: 74 70 je 10f4ea <_Thread_Resume+0x82> <== NEVER TAKEN
10f47a: 83 e2 fd and $0xfffffffd,%edx
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
10f47d: 89 50 10 mov %edx,0x10(%eax)
if ( _States_Is_ready( current_state ) ) {
10f480: 85 d2 test %edx,%edx
10f482: 75 66 jne 10f4ea <_Thread_Resume+0x82>
RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (
Priority_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10f484: 8b 90 90 00 00 00 mov 0x90(%eax),%edx
10f48a: 66 8b 98 96 00 00 00 mov 0x96(%eax),%bx
10f491: 66 09 1a or %bx,(%edx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10f494: 66 8b 15 50 73 12 00 mov 0x127350,%dx
10f49b: 0b 90 94 00 00 00 or 0x94(%eax),%edx
10f4a1: 66 89 15 50 73 12 00 mov %dx,0x127350
_Priority_Add_to_bit_map( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
10f4a8: 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;
10f4ae: 8d 5a 04 lea 0x4(%edx),%ebx
10f4b1: 89 18 mov %ebx,(%eax)
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
10f4b3: 8b 5a 08 mov 0x8(%edx),%ebx
the_chain->last = the_node;
10f4b6: 89 42 08 mov %eax,0x8(%edx)
old_last_node->next = the_node;
10f4b9: 89 03 mov %eax,(%ebx)
the_node->previous = old_last_node;
10f4bb: 89 58 04 mov %ebx,0x4(%eax)
_ISR_Flash( level );
10f4be: 51 push %ecx
10f4bf: 9d popf
10f4c0: fa cli
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
10f4c1: 8b 50 14 mov 0x14(%eax),%edx
10f4c4: 8b 1d 00 78 12 00 mov 0x127800,%ebx
10f4ca: 3b 53 14 cmp 0x14(%ebx),%edx
10f4cd: 73 1b jae 10f4ea <_Thread_Resume+0x82>
_Thread_Heir = the_thread;
10f4cf: a3 00 78 12 00 mov %eax,0x127800
if ( _Thread_Executing->is_preemptible ||
10f4d4: a1 fc 77 12 00 mov 0x1277fc,%eax
10f4d9: 80 78 74 00 cmpb $0x0,0x74(%eax)
10f4dd: 75 04 jne 10f4e3 <_Thread_Resume+0x7b>
10f4df: 85 d2 test %edx,%edx
10f4e1: 75 07 jne 10f4ea <_Thread_Resume+0x82> <== ALWAYS TAKEN
the_thread->current_priority == 0 )
_Context_Switch_necessary = true;
10f4e3: c6 05 08 78 12 00 01 movb $0x1,0x127808
}
}
}
_ISR_Enable( level );
10f4ea: 51 push %ecx
10f4eb: 9d popf
}
10f4ec: 5b pop %ebx
10f4ed: c9 leave
10f4ee: c3 ret
0010c9b0 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10c9b0: 55 push %ebp
10c9b1: 89 e5 mov %esp,%ebp
10c9b3: 53 push %ebx
10c9b4: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10c9b7: 8b 1d 34 47 12 00 mov 0x124734,%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10c9bd: 80 7b 74 00 cmpb $0x0,0x74(%ebx)
10c9c1: 74 4c je 10ca0f <_Thread_Tickle_timeslice+0x5f>
return;
if ( !_States_Is_ready( executing->current_state ) )
10c9c3: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10c9c7: 75 46 jne 10ca0f <_Thread_Tickle_timeslice+0x5f>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10c9c9: 8b 43 7c mov 0x7c(%ebx),%eax
10c9cc: 83 f8 01 cmp $0x1,%eax
10c9cf: 72 3e jb 10ca0f <_Thread_Tickle_timeslice+0x5f>
10c9d1: 83 f8 02 cmp $0x2,%eax
10c9d4: 76 07 jbe 10c9dd <_Thread_Tickle_timeslice+0x2d>
10c9d6: 83 f8 03 cmp $0x3,%eax
10c9d9: 75 34 jne 10ca0f <_Thread_Tickle_timeslice+0x5f><== NEVER TAKEN
10c9db: eb 1a jmp 10c9f7 <_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 ) {
10c9dd: 8b 43 78 mov 0x78(%ebx),%eax
10c9e0: 48 dec %eax
10c9e1: 89 43 78 mov %eax,0x78(%ebx)
10c9e4: 85 c0 test %eax,%eax
10c9e6: 7f 27 jg 10ca0f <_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();
10c9e8: e8 27 00 00 00 call 10ca14 <_Thread_Yield_processor>
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c9ed: a1 b4 41 12 00 mov 0x1241b4,%eax
10c9f2: 89 43 78 mov %eax,0x78(%ebx)
10c9f5: eb 18 jmp 10ca0f <_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 )
10c9f7: 8b 43 78 mov 0x78(%ebx),%eax
10c9fa: 48 dec %eax
10c9fb: 89 43 78 mov %eax,0x78(%ebx)
10c9fe: 85 c0 test %eax,%eax
10ca00: 75 0d jne 10ca0f <_Thread_Tickle_timeslice+0x5f>
(*executing->budget_callout)( executing );
10ca02: 83 ec 0c sub $0xc,%esp
10ca05: 53 push %ebx
10ca06: ff 93 80 00 00 00 call *0x80(%ebx)
10ca0c: 83 c4 10 add $0x10,%esp
break;
#endif
}
}
10ca0f: 8b 5d fc mov -0x4(%ebp),%ebx
10ca12: c9 leave
10ca13: c3 ret
0010f850 <_Thread_queue_Extract_priority_helper>:
void _Thread_queue_Extract_priority_helper(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread,
bool requeuing
)
{
10f850: 55 push %ebp
10f851: 89 e5 mov %esp,%ebp
10f853: 57 push %edi
10f854: 56 push %esi
10f855: 53 push %ebx
10f856: 83 ec 1c sub $0x1c,%esp
10f859: 8b 5d 0c mov 0xc(%ebp),%ebx
10f85c: 8a 45 10 mov 0x10(%ebp),%al
10f85f: 88 45 e3 mov %al,-0x1d(%ebp)
Chain_Node *new_first_node;
Chain_Node *new_second_node;
Chain_Node *last_node;
the_node = (Chain_Node *) the_thread;
_ISR_Disable( level );
10f862: 9c pushf
10f863: fa cli
10f864: 8f 45 e4 popl -0x1c(%ebp)
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10f867: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
10f86e: 75 09 jne 10f879 <_Thread_queue_Extract_priority_helper+0x29>
_ISR_Enable( level );
10f870: ff 75 e4 pushl -0x1c(%ebp)
10f873: 9d popf
return;
10f874: e9 82 00 00 00 jmp 10f8fb <_Thread_queue_Extract_priority_helper+0xab>
/*
* The thread was actually waiting on a thread queue so let's remove it.
*/
next_node = the_node->next;
10f879: 8b 13 mov (%ebx),%edx
previous_node = the_node->previous;
10f87b: 8b 4b 04 mov 0x4(%ebx),%ecx
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
10f87e: 8b 43 38 mov 0x38(%ebx),%eax
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10f881: 8d 73 3c lea 0x3c(%ebx),%esi
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
10f884: 39 f0 cmp %esi,%eax
10f886: 74 26 je 10f8ae <_Thread_queue_Extract_priority_helper+0x5e>
new_first_node = the_thread->Wait.Block2n.first;
new_first_thread = (Thread_Control *) new_first_node;
last_node = the_thread->Wait.Block2n.last;
10f888: 8b 73 40 mov 0x40(%ebx),%esi
new_second_node = new_first_node->next;
10f88b: 8b 38 mov (%eax),%edi
previous_node->next = new_first_node;
10f88d: 89 01 mov %eax,(%ecx)
next_node->previous = new_first_node;
10f88f: 89 42 04 mov %eax,0x4(%edx)
new_first_node->next = next_node;
10f892: 89 10 mov %edx,(%eax)
new_first_node->previous = previous_node;
10f894: 89 48 04 mov %ecx,0x4(%eax)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
10f897: 39 f0 cmp %esi,%eax
10f899: 74 18 je 10f8b3 <_Thread_queue_Extract_priority_helper+0x63>
/* > two threads on 2-n */
new_second_node->previous =
_Chain_Head( &new_first_thread->Wait.Block2n );
10f89b: 8d 50 38 lea 0x38(%eax),%edx
10f89e: 89 57 04 mov %edx,0x4(%edi)
new_first_thread->Wait.Block2n.first = new_second_node;
10f8a1: 89 78 38 mov %edi,0x38(%eax)
new_first_thread->Wait.Block2n.last = last_node;
10f8a4: 89 70 40 mov %esi,0x40(%eax)
10f8a7: 83 c0 3c add $0x3c,%eax
10f8aa: 89 06 mov %eax,(%esi)
10f8ac: eb 05 jmp 10f8b3 <_Thread_queue_Extract_priority_helper+0x63>
last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
}
} else {
previous_node->next = next_node;
10f8ae: 89 11 mov %edx,(%ecx)
next_node->previous = previous_node;
10f8b0: 89 4a 04 mov %ecx,0x4(%edx)
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
10f8b3: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f8b7: 74 06 je 10f8bf <_Thread_queue_Extract_priority_helper+0x6f>
_ISR_Enable( level );
10f8b9: ff 75 e4 pushl -0x1c(%ebp)
10f8bc: 9d popf
10f8bd: eb 3c jmp 10f8fb <_Thread_queue_Extract_priority_helper+0xab>
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10f8bf: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10f8c3: 74 06 je 10f8cb <_Thread_queue_Extract_priority_helper+0x7b><== NEVER TAKEN
_ISR_Enable( level );
10f8c5: ff 75 e4 pushl -0x1c(%ebp)
10f8c8: 9d popf
10f8c9: eb 1a jmp 10f8e5 <_Thread_queue_Extract_priority_helper+0x95>
10f8cb: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10f8d2: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED
10f8d5: 9d popf <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
10f8d6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10f8d9: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED
10f8dc: 50 push %eax <== NOT EXECUTED
10f8dd: e8 42 d5 ff ff call 10ce24 <_Watchdog_Remove> <== NOT EXECUTED
10f8e2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10f8e5: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp)
10f8ec: 89 5d 08 mov %ebx,0x8(%ebp)
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
10f8ef: 8d 65 f4 lea -0xc(%ebp),%esp
10f8f2: 5b pop %ebx
10f8f3: 5e pop %esi
10f8f4: 5f pop %edi
10f8f5: c9 leave
10f8f6: e9 c9 c2 ff ff jmp 10bbc4 <_Thread_Clear_state>
10f8fb: 8d 65 f4 lea -0xc(%ebp),%esp
10f8fe: 5b pop %ebx
10f8ff: 5e pop %esi
10f900: 5f pop %edi
10f901: c9 leave
10f902: c3 ret
0010c644 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10c644: 55 push %ebp
10c645: 89 e5 mov %esp,%ebp
10c647: 57 push %edi
10c648: 56 push %esi
10c649: 53 push %ebx
10c64a: 83 ec 1c sub $0x1c,%esp
10c64d: 8b 75 08 mov 0x8(%ebp),%esi
10c650: 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 )
10c653: 85 f6 test %esi,%esi
10c655: 74 36 je 10c68d <_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 ) {
10c657: 83 7e 34 01 cmpl $0x1,0x34(%esi)
10c65b: 75 30 jne 10c68d <_Thread_queue_Requeue+0x49><== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
10c65d: 9c pushf
10c65e: fa cli
10c65f: 5b pop %ebx
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10c660: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi)
10c667: 74 22 je 10c68b <_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;
10c669: 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 );
10c670: 50 push %eax
10c671: 6a 01 push $0x1
10c673: 57 push %edi
10c674: 56 push %esi
10c675: e8 d6 31 00 00 call 10f850 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10c67a: 83 c4 0c add $0xc,%esp
10c67d: 8d 45 e4 lea -0x1c(%ebp),%eax
10c680: 50 push %eax
10c681: 57 push %edi
10c682: 56 push %esi
10c683: e8 c4 fd ff ff call 10c44c <_Thread_queue_Enqueue_priority>
10c688: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10c68b: 53 push %ebx
10c68c: 9d popf
}
}
10c68d: 8d 65 f4 lea -0xc(%ebp),%esp
10c690: 5b pop %ebx
10c691: 5e pop %esi
10c692: 5f pop %edi
10c693: c9 leave
10c694: c3 ret
0010c698 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10c698: 55 push %ebp
10c699: 89 e5 mov %esp,%ebp
10c69b: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10c69e: 8d 45 f4 lea -0xc(%ebp),%eax
10c6a1: 50 push %eax
10c6a2: ff 75 08 pushl 0x8(%ebp)
10c6a5: e8 ae f8 ff ff call 10bf58 <_Thread_Get>
switch ( location ) {
10c6aa: 83 c4 10 add $0x10,%esp
10c6ad: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10c6b1: 75 17 jne 10c6ca <_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 );
10c6b3: 83 ec 0c sub $0xc,%esp
10c6b6: 50 push %eax
10c6b7: e8 48 32 00 00 call 10f904 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10c6bc: a1 e4 41 12 00 mov 0x1241e4,%eax
10c6c1: 48 dec %eax
10c6c2: a3 e4 41 12 00 mov %eax,0x1241e4
10c6c7: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10c6ca: c9 leave
10c6cb: c3 ret
00116a70 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
116a70: 55 push %ebp
116a71: 89 e5 mov %esp,%ebp
116a73: 57 push %edi
116a74: 56 push %esi
116a75: 53 push %ebx
116a76: 83 ec 4c sub $0x4c,%esp
116a79: 8b 5d 08 mov 0x8(%ebp),%ebx
116a7c: 8d 45 dc lea -0x24(%ebp),%eax
116a7f: 8d 55 e0 lea -0x20(%ebp),%edx
116a82: 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);
116a85: 89 55 dc mov %edx,-0x24(%ebp)
the_chain->permanent_null = NULL;
116a88: 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 );
116a8f: 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;
116a92: 8d 7d d0 lea -0x30(%ebp),%edi
116a95: 8d 55 d4 lea -0x2c(%ebp),%edx
116a98: 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);
116a9b: 89 55 d0 mov %edx,-0x30(%ebp)
the_chain->permanent_null = NULL;
116a9e: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
the_chain->last = _Chain_Head(the_chain);
116aa5: 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 );
116aa8: 8d 43 30 lea 0x30(%ebx),%eax
116aab: 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 );
116aae: 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 );
116ab1: 8d 53 08 lea 0x8(%ebx),%edx
116ab4: 89 55 bc mov %edx,-0x44(%ebp)
{
/*
* 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;
116ab7: 8d 4d dc lea -0x24(%ebp),%ecx
116aba: 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;
116abd: a1 f0 e6 13 00 mov 0x13e6f0,%eax
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
116ac2: 8b 53 3c mov 0x3c(%ebx),%edx
watchdogs->last_snapshot = snapshot;
116ac5: 89 43 3c mov %eax,0x3c(%ebx)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
116ac8: 51 push %ecx
116ac9: 8d 4d d0 lea -0x30(%ebp),%ecx
116acc: 51 push %ecx
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
116acd: 29 d0 sub %edx,%eax
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
116acf: 50 push %eax
116ad0: ff 75 c0 pushl -0x40(%ebp)
116ad3: e8 88 39 00 00 call 11a460 <_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();
116ad8: a1 44 e6 13 00 mov 0x13e644,%eax
116add: 89 45 c4 mov %eax,-0x3c(%ebp)
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
116ae0: 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 ) {
116ae3: 83 c4 10 add $0x10,%esp
116ae6: 39 45 c4 cmp %eax,-0x3c(%ebp)
116ae9: 76 13 jbe 116afe <_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 );
116aeb: 52 push %edx
116aec: 8d 55 d0 lea -0x30(%ebp),%edx
116aef: 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;
116af0: 8b 4d c4 mov -0x3c(%ebp),%ecx
116af3: 29 c1 sub %eax,%ecx
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
116af5: 51 push %ecx
116af6: 56 push %esi
116af7: e8 64 39 00 00 call 11a460 <_Watchdog_Adjust_to_chain>
116afc: eb 0f jmp 116b0d <_Timer_server_Body+0x9d>
} else if ( snapshot < last_snapshot ) {
116afe: 73 10 jae 116b10 <_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 );
116b00: 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;
116b01: 2b 45 c4 sub -0x3c(%ebp),%eax
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
116b04: 50 push %eax
116b05: 6a 01 push $0x1
116b07: 56 push %esi
116b08: e8 e7 38 00 00 call 11a3f4 <_Watchdog_Adjust>
116b0d: 83 c4 10 add $0x10,%esp
}
watchdogs->last_snapshot = snapshot;
116b10: 8b 45 c4 mov -0x3c(%ebp),%eax
116b13: 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 );
116b16: 8b 43 78 mov 0x78(%ebx),%eax
116b19: 83 ec 0c sub $0xc,%esp
116b1c: 50 push %eax
116b1d: e8 da 08 00 00 call 1173fc <_Chain_Get>
if ( timer == NULL ) {
116b22: 83 c4 10 add $0x10,%esp
116b25: 85 c0 test %eax,%eax
116b27: 74 29 je 116b52 <_Timer_server_Body+0xe2><== ALWAYS TAKEN
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
116b29: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED
116b2c: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED
116b2f: 75 0b jne 116b3c <_Timer_server_Body+0xcc><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116b31: 52 push %edx <== NOT EXECUTED
116b32: 52 push %edx <== NOT EXECUTED
116b33: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
116b36: 50 push %eax <== NOT EXECUTED
116b37: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED
116b3a: eb 0c jmp 116b48 <_Timer_server_Body+0xd8><== NOT EXECUTED
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116b3c: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
116b3f: 75 d5 jne 116b16 <_Timer_server_Body+0xa6><== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116b41: 51 push %ecx <== NOT EXECUTED
116b42: 51 push %ecx <== NOT EXECUTED
116b43: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
116b46: 50 push %eax <== NOT EXECUTED
116b47: 56 push %esi <== NOT EXECUTED
116b48: e8 9b 39 00 00 call 11a4e8 <_Watchdog_Insert> <== NOT EXECUTED
116b4d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
116b50: eb c4 jmp 116b16 <_Timer_server_Body+0xa6><== NOT EXECUTED
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
116b52: 9c pushf
116b53: fa cli
116b54: 58 pop %eax
if ( _Chain_Is_empty( insert_chain ) ) {
116b55: 8b 55 b4 mov -0x4c(%ebp),%edx
116b58: 39 55 dc cmp %edx,-0x24(%ebp)
116b5b: 75 13 jne 116b70 <_Timer_server_Body+0x100><== NEVER TAKEN
ts->insert_chain = NULL;
116b5d: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx)
_ISR_Enable( level );
116b64: 50 push %eax
116b65: 9d popf
_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 ) ) {
116b66: 8b 4d b0 mov -0x50(%ebp),%ecx
116b69: 39 4d d0 cmp %ecx,-0x30(%ebp)
116b6c: 75 09 jne 116b77 <_Timer_server_Body+0x107>
116b6e: eb 3e jmp 116bae <_Timer_server_Body+0x13e>
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
116b70: 50 push %eax <== NOT EXECUTED
116b71: 9d popf <== NOT EXECUTED
116b72: e9 46 ff ff ff jmp 116abd <_Timer_server_Body+0x4d><== NOT EXECUTED
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
116b77: 9c pushf
116b78: fa cli
116b79: 5a pop %edx
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
116b7a: 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))
116b7d: 3b 45 b0 cmp -0x50(%ebp),%eax
116b80: 74 25 je 116ba7 <_Timer_server_Body+0x137>
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
116b82: 8b 08 mov (%eax),%ecx
the_chain->first = new_first;
116b84: 89 4d d0 mov %ecx,-0x30(%ebp)
new_first->previous = _Chain_Head(the_chain);
116b87: 89 79 04 mov %edi,0x4(%ecx)
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
116b8a: 85 c0 test %eax,%eax
116b8c: 74 19 je 116ba7 <_Timer_server_Body+0x137><== NEVER TAKEN
watchdog->state = WATCHDOG_INACTIVE;
116b8e: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
_ISR_Enable( level );
116b95: 52 push %edx
116b96: 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 );
116b97: 52 push %edx
116b98: 52 push %edx
116b99: ff 70 24 pushl 0x24(%eax)
116b9c: ff 70 20 pushl 0x20(%eax)
116b9f: ff 50 1c call *0x1c(%eax)
}
116ba2: 83 c4 10 add $0x10,%esp
116ba5: eb d0 jmp 116b77 <_Timer_server_Body+0x107>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
116ba7: 52 push %edx
116ba8: 9d popf
116ba9: e9 09 ff ff ff jmp 116ab7 <_Timer_server_Body+0x47>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
116bae: c6 43 7c 00 movb $0x0,0x7c(%ebx)
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
116bb2: e8 1d fe ff ff call 1169d4 <_Thread_Disable_dispatch>
_Thread_Set_state( ts->thread, STATES_DELAYING );
116bb7: 50 push %eax
116bb8: 50 push %eax
116bb9: 6a 08 push $0x8
116bbb: ff 33 pushl (%ebx)
116bbd: e8 06 31 00 00 call 119cc8 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
116bc2: 89 d8 mov %ebx,%eax
116bc4: e8 1b fe ff ff call 1169e4 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
116bc9: 89 d8 mov %ebx,%eax
116bcb: e8 5a fe ff ff call 116a2a <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
116bd0: e8 e9 27 00 00 call 1193be <_Thread_Enable_dispatch>
ts->active = true;
116bd5: 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 );
116bd9: 59 pop %ecx
116bda: ff 75 bc pushl -0x44(%ebp)
116bdd: e8 1e 3a 00 00 call 11a600 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
116be2: 8d 43 40 lea 0x40(%ebx),%eax
116be5: 89 04 24 mov %eax,(%esp)
116be8: e8 13 3a 00 00 call 11a600 <_Watchdog_Remove>
116bed: 83 c4 10 add $0x10,%esp
116bf0: e9 c2 fe ff ff jmp 116ab7 <_Timer_server_Body+0x47>
00116bf5 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
116bf5: 55 push %ebp
116bf6: 89 e5 mov %esp,%ebp
116bf8: 57 push %edi
116bf9: 56 push %esi
116bfa: 53 push %ebx
116bfb: 83 ec 2c sub $0x2c,%esp
116bfe: 8b 5d 08 mov 0x8(%ebp),%ebx
116c01: 8b 75 0c mov 0xc(%ebp),%esi
if ( ts->insert_chain == NULL ) {
116c04: 8b 43 78 mov 0x78(%ebx),%eax
116c07: 85 c0 test %eax,%eax
116c09: 0f 85 de 00 00 00 jne 116ced <_Timer_server_Schedule_operation_method+0xf8><== NEVER TAKEN
* is the reference point for the delta chain. Thus if we do not update the
* reference point we have to add DT to the initial delta of the watchdog
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
116c0f: e8 c0 fd ff ff call 1169d4 <_Thread_Disable_dispatch>
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
116c14: 8b 46 38 mov 0x38(%esi),%eax
116c17: 83 f8 01 cmp $0x1,%eax
116c1a: 75 5a jne 116c76 <_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 );
116c1c: 9c pushf
116c1d: fa cli
116c1e: 8f 45 e0 popl -0x20(%ebp)
snapshot = _Watchdog_Ticks_since_boot;
116c21: 8b 15 f0 e6 13 00 mov 0x13e6f0,%edx
last_snapshot = ts->Interval_watchdogs.last_snapshot;
116c27: 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));
116c2a: 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;
116c2d: 8d 7b 34 lea 0x34(%ebx),%edi
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
116c30: 39 f8 cmp %edi,%eax
116c32: 74 19 je 116c4d <_Timer_server_Schedule_operation_method+0x58>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
116c34: 89 d7 mov %edx,%edi
116c36: 29 cf sub %ecx,%edi
116c38: 89 7d e4 mov %edi,-0x1c(%ebp)
delta_interval = first_watchdog->delta_interval;
116c3b: 8b 78 10 mov 0x10(%eax),%edi
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116c3e: 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) {
116c40: 3b 7d e4 cmp -0x1c(%ebp),%edi
116c43: 76 05 jbe 116c4a <_Timer_server_Schedule_operation_method+0x55>
delta_interval -= delta;
116c45: 89 f9 mov %edi,%ecx
116c47: 2b 4d e4 sub -0x1c(%ebp),%ecx
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
116c4a: 89 48 10 mov %ecx,0x10(%eax)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
116c4d: 89 53 3c mov %edx,0x3c(%ebx)
_ISR_Enable( level );
116c50: ff 75 e0 pushl -0x20(%ebp)
116c53: 9d popf
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116c54: 50 push %eax
116c55: 50 push %eax
116c56: 83 c6 10 add $0x10,%esi
116c59: 56 push %esi
116c5a: 8d 43 30 lea 0x30(%ebx),%eax
116c5d: 50 push %eax
116c5e: e8 85 38 00 00 call 11a4e8 <_Watchdog_Insert>
if ( !ts->active ) {
116c63: 8a 43 7c mov 0x7c(%ebx),%al
116c66: 83 c4 10 add $0x10,%esp
116c69: 84 c0 test %al,%al
116c6b: 75 74 jne 116ce1 <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_interval_system_watchdog( ts );
116c6d: 89 d8 mov %ebx,%eax
116c6f: e8 70 fd ff ff call 1169e4 <_Timer_server_Reset_interval_system_watchdog>
116c74: eb 6b jmp 116ce1 <_Timer_server_Schedule_operation_method+0xec>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116c76: 83 f8 03 cmp $0x3,%eax
116c79: 75 66 jne 116ce1 <_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 );
116c7b: 9c pushf
116c7c: fa cli
116c7d: 8f 45 e0 popl -0x20(%ebp)
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
116c80: 8b 15 44 e6 13 00 mov 0x13e644,%edx
last_snapshot = ts->TOD_watchdogs.last_snapshot;
116c86: 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));
116c89: 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;
116c8c: 8d 7b 6c lea 0x6c(%ebx),%edi
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
116c8f: 39 f9 cmp %edi,%ecx
116c91: 74 27 je 116cba <_Timer_server_Schedule_operation_method+0xc5>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
116c93: 8b 79 10 mov 0x10(%ecx),%edi
116c96: 89 7d d4 mov %edi,-0x2c(%ebp)
if ( snapshot > last_snapshot ) {
116c99: 39 c2 cmp %eax,%edx
116c9b: 76 15 jbe 116cb2 <_Timer_server_Schedule_operation_method+0xbd>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
116c9d: 89 d7 mov %edx,%edi
116c9f: 29 c7 sub %eax,%edi
116ca1: 89 7d e4 mov %edi,-0x1c(%ebp)
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116ca4: 31 c0 xor %eax,%eax
if ( snapshot > last_snapshot ) {
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
116ca6: 39 7d d4 cmp %edi,-0x2c(%ebp)
116ca9: 76 0c jbe 116cb7 <_Timer_server_Schedule_operation_method+0xc2><== NEVER TAKEN
delta_interval -= delta;
116cab: 8b 45 d4 mov -0x2c(%ebp),%eax
116cae: 29 f8 sub %edi,%eax
116cb0: eb 05 jmp 116cb7 <_Timer_server_Schedule_operation_method+0xc2>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
116cb2: 03 45 d4 add -0x2c(%ebp),%eax
delta_interval += delta;
116cb5: 29 d0 sub %edx,%eax
}
first_watchdog->delta_interval = delta_interval;
116cb7: 89 41 10 mov %eax,0x10(%ecx)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
116cba: 89 53 74 mov %edx,0x74(%ebx)
_ISR_Enable( level );
116cbd: ff 75 e0 pushl -0x20(%ebp)
116cc0: 9d popf
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116cc1: 57 push %edi
116cc2: 57 push %edi
116cc3: 83 c6 10 add $0x10,%esi
116cc6: 56 push %esi
116cc7: 8d 43 68 lea 0x68(%ebx),%eax
116cca: 50 push %eax
116ccb: e8 18 38 00 00 call 11a4e8 <_Watchdog_Insert>
if ( !ts->active ) {
116cd0: 8a 43 7c mov 0x7c(%ebx),%al
116cd3: 83 c4 10 add $0x10,%esp
116cd6: 84 c0 test %al,%al
116cd8: 75 07 jne 116ce1 <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_tod_system_watchdog( ts );
116cda: 89 d8 mov %ebx,%eax
116cdc: e8 49 fd ff ff call 116a2a <_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 );
}
}
116ce1: 8d 65 f4 lea -0xc(%ebp),%esp
116ce4: 5b pop %ebx
116ce5: 5e pop %esi
116ce6: 5f pop %edi
116ce7: c9 leave
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
116ce8: e9 d1 26 00 00 jmp 1193be <_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 );
116ced: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED
116cf0: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED
116cf3: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
}
116cf6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
116cf9: 5b pop %ebx <== NOT EXECUTED
116cfa: 5e pop %esi <== NOT EXECUTED
116cfb: 5f pop %edi <== NOT EXECUTED
116cfc: c9 leave <== NOT EXECUTED
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
116cfd: e9 be 06 00 00 jmp 1173c0 <_Chain_Append> <== NOT EXECUTED
0010cbeb <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10cbeb: 55 push %ebp
10cbec: 89 e5 mov %esp,%ebp
10cbee: 57 push %edi
10cbef: 56 push %esi
10cbf0: 53 push %ebx
10cbf1: 83 ec 0c sub $0xc,%esp
10cbf4: 8b 7d 10 mov 0x10(%ebp),%edi
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
10cbf7: 8b 1d e0 43 12 00 mov 0x1243e0,%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 );
10cbfd: 0f b6 75 0c movzbl 0xc(%ebp),%esi
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
10cc01: eb 15 jmp 10cc18 <_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 )
10cc03: 8b 43 30 mov 0x30(%ebx),%eax
10cc06: 85 c0 test %eax,%eax
10cc08: 74 0b je 10cc15 <_User_extensions_Fatal+0x2a>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10cc0a: 52 push %edx
10cc0b: 57 push %edi
10cc0c: 56 push %esi
10cc0d: ff 75 08 pushl 0x8(%ebp)
10cc10: ff d0 call *%eax
10cc12: 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 ) {
10cc15: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
10cc18: 81 fb d8 43 12 00 cmp $0x1243d8,%ebx
10cc1e: 75 e3 jne 10cc03 <_User_extensions_Fatal+0x18>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
10cc20: 8d 65 f4 lea -0xc(%ebp),%esp
10cc23: 5b pop %ebx
10cc24: 5e pop %esi
10cc25: 5f pop %edi
10cc26: c9 leave
10cc27: c3 ret
0010cad4 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
10cad4: 55 push %ebp
10cad5: 89 e5 mov %esp,%ebp
10cad7: 57 push %edi
10cad8: 56 push %esi
10cad9: 53 push %ebx
10cada: 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;
10cadd: a1 30 02 12 00 mov 0x120230,%eax
10cae2: 89 45 e4 mov %eax,-0x1c(%ebp)
initial_extensions = Configuration.User_extension_table;
10cae5: 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);
10caeb: c7 05 d8 43 12 00 dc movl $0x1243dc,0x1243d8
10caf2: 43 12 00
the_chain->permanent_null = NULL;
10caf5: c7 05 dc 43 12 00 00 movl $0x0,0x1243dc
10cafc: 00 00 00
the_chain->last = _Chain_Head(the_chain);
10caff: c7 05 e0 43 12 00 d8 movl $0x1243d8,0x1243e0
10cb06: 43 12 00
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
10cb09: c7 05 e8 41 12 00 ec movl $0x1241ec,0x1241e8
10cb10: 41 12 00
the_chain->permanent_null = NULL;
10cb13: c7 05 ec 41 12 00 00 movl $0x0,0x1241ec
10cb1a: 00 00 00
the_chain->last = _Chain_Head(the_chain);
10cb1d: c7 05 f0 41 12 00 e8 movl $0x1241e8,0x1241f0
10cb24: 41 12 00
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10cb27: 85 f6 test %esi,%esi
10cb29: 74 53 je 10cb7e <_User_extensions_Handler_initialization+0xaa><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
10cb2b: 6b c8 34 imul $0x34,%eax,%ecx
10cb2e: 83 ec 0c sub $0xc,%esp
10cb31: 51 push %ecx
10cb32: 89 4d e0 mov %ecx,-0x20(%ebp)
10cb35: e8 32 04 00 00 call 10cf6c <_Workspace_Allocate_or_fatal_error>
10cb3a: 89 c3 mov %eax,%ebx
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10cb3c: 31 c0 xor %eax,%eax
10cb3e: 8b 4d e0 mov -0x20(%ebp),%ecx
10cb41: 89 df mov %ebx,%edi
10cb43: f3 aa rep stos %al,%es:(%edi)
10cb45: 89 f0 mov %esi,%eax
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cb47: 83 c4 10 add $0x10,%esp
10cb4a: 31 d2 xor %edx,%edx
10cb4c: eb 2b jmp 10cb79 <_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;
10cb4e: 8d 7b 14 lea 0x14(%ebx),%edi
10cb51: 89 c6 mov %eax,%esi
10cb53: b9 08 00 00 00 mov $0x8,%ecx
10cb58: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10cb5a: 83 ec 0c sub $0xc,%esp
10cb5d: 53 push %ebx
10cb5e: 89 45 dc mov %eax,-0x24(%ebp)
10cb61: 89 55 e0 mov %edx,-0x20(%ebp)
10cb64: e8 97 2f 00 00 call 10fb00 <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
10cb69: 83 c3 34 add $0x34,%ebx
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cb6c: 8b 55 e0 mov -0x20(%ebp),%edx
10cb6f: 42 inc %edx
10cb70: 8b 45 dc mov -0x24(%ebp),%eax
10cb73: 83 c0 20 add $0x20,%eax
10cb76: 83 c4 10 add $0x10,%esp
10cb79: 3b 55 e4 cmp -0x1c(%ebp),%edx
10cb7c: 72 d0 jb 10cb4e <_User_extensions_Handler_initialization+0x7a>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
10cb7e: 8d 65 f4 lea -0xc(%ebp),%esp
10cb81: 5b pop %ebx
10cb82: 5e pop %esi
10cb83: 5f pop %edi
10cb84: c9 leave
10cb85: c3 ret
0010e520 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
10e520: 55 push %ebp
10e521: 89 e5 mov %esp,%ebp
10e523: 57 push %edi
10e524: 56 push %esi
10e525: 53 push %ebx
10e526: 83 ec 1c sub $0x1c,%esp
10e529: 8b 75 08 mov 0x8(%ebp),%esi
10e52c: 8b 7d 0c mov 0xc(%ebp),%edi
10e52f: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
10e532: 9c pushf
10e533: fa cli
10e534: 58 pop %eax
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
10e535: 8b 16 mov (%esi),%edx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10e537: 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 ) ) {
10e53a: 39 ca cmp %ecx,%edx
10e53c: 74 44 je 10e582 <_Watchdog_Adjust+0x62>
switch ( direction ) {
10e53e: 85 ff test %edi,%edi
10e540: 74 3c je 10e57e <_Watchdog_Adjust+0x5e>
10e542: 4f dec %edi
10e543: 75 3d jne 10e582 <_Watchdog_Adjust+0x62> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
10e545: 01 5a 10 add %ebx,0x10(%edx)
break;
10e548: eb 38 jmp 10e582 <_Watchdog_Adjust+0x62>
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) header->first );
10e54a: 8b 16 mov (%esi),%edx
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
10e54c: 8b 7a 10 mov 0x10(%edx),%edi
10e54f: 39 fb cmp %edi,%ebx
10e551: 73 07 jae 10e55a <_Watchdog_Adjust+0x3a>
_Watchdog_First( header )->delta_interval -= units;
10e553: 29 df sub %ebx,%edi
10e555: 89 7a 10 mov %edi,0x10(%edx)
break;
10e558: eb 28 jmp 10e582 <_Watchdog_Adjust+0x62>
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
10e55a: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx)
_ISR_Enable( level );
10e561: 50 push %eax
10e562: 9d popf
_Watchdog_Tickle( header );
10e563: 83 ec 0c sub $0xc,%esp
10e566: 56 push %esi
10e567: 89 4d e4 mov %ecx,-0x1c(%ebp)
10e56a: e8 9d 01 00 00 call 10e70c <_Watchdog_Tickle>
_ISR_Disable( level );
10e56f: 9c pushf
10e570: fa cli
10e571: 58 pop %eax
if ( _Chain_Is_empty( header ) )
10e572: 83 c4 10 add $0x10,%esp
10e575: 8b 4d e4 mov -0x1c(%ebp),%ecx
10e578: 39 0e cmp %ecx,(%esi)
10e57a: 74 06 je 10e582 <_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;
10e57c: 29 fb sub %edi,%ebx
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10e57e: 85 db test %ebx,%ebx
10e580: 75 c8 jne 10e54a <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
10e582: 50 push %eax
10e583: 9d popf
}
10e584: 8d 65 f4 lea -0xc(%ebp),%esp
10e587: 5b pop %ebx
10e588: 5e pop %esi
10e589: 5f pop %edi
10e58a: c9 leave
10e58b: c3 ret
0010ce24 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10ce24: 55 push %ebp
10ce25: 89 e5 mov %esp,%ebp
10ce27: 56 push %esi
10ce28: 53 push %ebx
10ce29: 8b 55 08 mov 0x8(%ebp),%edx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10ce2c: 9c pushf
10ce2d: fa cli
10ce2e: 5e pop %esi
previous_state = the_watchdog->state;
10ce2f: 8b 42 08 mov 0x8(%edx),%eax
switch ( previous_state ) {
10ce32: 83 f8 01 cmp $0x1,%eax
10ce35: 74 09 je 10ce40 <_Watchdog_Remove+0x1c>
10ce37: 72 42 jb 10ce7b <_Watchdog_Remove+0x57>
10ce39: 83 f8 03 cmp $0x3,%eax
10ce3c: 77 3d ja 10ce7b <_Watchdog_Remove+0x57> <== NEVER TAKEN
10ce3e: eb 09 jmp 10ce49 <_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;
10ce40: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
break;
10ce47: eb 32 jmp 10ce7b <_Watchdog_Remove+0x57>
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10ce49: 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 );
}
10ce50: 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) )
10ce52: 83 39 00 cmpl $0x0,(%ecx)
10ce55: 74 06 je 10ce5d <_Watchdog_Remove+0x39>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10ce57: 8b 5a 10 mov 0x10(%edx),%ebx
10ce5a: 01 59 10 add %ebx,0x10(%ecx)
if ( _Watchdog_Sync_count )
10ce5d: 8b 1d 18 43 12 00 mov 0x124318,%ebx
10ce63: 85 db test %ebx,%ebx
10ce65: 74 0c je 10ce73 <_Watchdog_Remove+0x4f>
_Watchdog_Sync_level = _ISR_Nest_level;
10ce67: 8b 1d 30 47 12 00 mov 0x124730,%ebx
10ce6d: 89 1d 90 42 12 00 mov %ebx,0x124290
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10ce73: 8b 5a 04 mov 0x4(%edx),%ebx
next->previous = previous;
10ce76: 89 59 04 mov %ebx,0x4(%ecx)
previous->next = next;
10ce79: 89 0b mov %ecx,(%ebx)
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10ce7b: 8b 0d 1c 43 12 00 mov 0x12431c,%ecx
10ce81: 89 4a 18 mov %ecx,0x18(%edx)
_ISR_Enable( level );
10ce84: 56 push %esi
10ce85: 9d popf
return( previous_state );
}
10ce86: 5b pop %ebx
10ce87: 5e pop %esi
10ce88: c9 leave
10ce89: c3 ret
0010e094 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
10e094: 55 push %ebp
10e095: 89 e5 mov %esp,%ebp
10e097: 57 push %edi
10e098: 56 push %esi
10e099: 53 push %ebx
10e09a: 83 ec 20 sub $0x20,%esp
10e09d: 8b 7d 08 mov 0x8(%ebp),%edi
10e0a0: 8b 75 0c mov 0xc(%ebp),%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
10e0a3: 9c pushf
10e0a4: fa cli
10e0a5: 8f 45 e4 popl -0x1c(%ebp)
printk( "Watchdog Chain: %s %p\n", name, header );
10e0a8: 56 push %esi
10e0a9: 57 push %edi
10e0aa: 68 84 11 12 00 push $0x121184
10e0af: e8 d8 a9 ff ff call 108a8c <printk>
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
10e0b4: 8b 1e mov (%esi),%ebx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10e0b6: 83 c6 04 add $0x4,%esi
if ( !_Chain_Is_empty( header ) ) {
10e0b9: 83 c4 10 add $0x10,%esp
10e0bc: 39 f3 cmp %esi,%ebx
10e0be: 74 1d je 10e0dd <_Watchdog_Report_chain+0x49>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
10e0c0: 52 push %edx
10e0c1: 52 push %edx
10e0c2: 53 push %ebx
10e0c3: 6a 00 push $0x0
10e0c5: e8 32 00 00 00 call 10e0fc <_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 )
10e0ca: 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 ;
10e0cc: 83 c4 10 add $0x10,%esp
10e0cf: 39 f3 cmp %esi,%ebx
10e0d1: 75 ed jne 10e0c0 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
10e0d3: 50 push %eax
10e0d4: 50 push %eax
10e0d5: 57 push %edi
10e0d6: 68 9b 11 12 00 push $0x12119b
10e0db: eb 08 jmp 10e0e5 <_Watchdog_Report_chain+0x51>
} else {
printk( "Chain is empty\n" );
10e0dd: 83 ec 0c sub $0xc,%esp
10e0e0: 68 aa 11 12 00 push $0x1211aa
10e0e5: e8 a2 a9 ff ff call 108a8c <printk>
10e0ea: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10e0ed: ff 75 e4 pushl -0x1c(%ebp)
10e0f0: 9d popf
}
10e0f1: 8d 65 f4 lea -0xc(%ebp),%esp
10e0f4: 5b pop %ebx
10e0f5: 5e pop %esi
10e0f6: 5f pop %edi
10e0f7: c9 leave
10e0f8: c3 ret
0010ce8c <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
10ce8c: 55 push %ebp
10ce8d: 89 e5 mov %esp,%ebp
10ce8f: 57 push %edi
10ce90: 56 push %esi
10ce91: 53 push %ebx
10ce92: 83 ec 1c sub $0x1c,%esp
10ce95: 8b 7d 08 mov 0x8(%ebp),%edi
* See the comment in watchdoginsert.c and watchdogadjust.c
* about why it's safe not to declare header a pointer to
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
10ce98: 9c pushf
10ce99: fa cli
10ce9a: 5e pop %esi
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
10ce9b: 8b 1f mov (%edi),%ebx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10ce9d: 8d 47 04 lea 0x4(%edi),%eax
10cea0: 89 45 e4 mov %eax,-0x1c(%ebp)
if ( _Chain_Is_empty( header ) )
10cea3: 39 c3 cmp %eax,%ebx
10cea5: 74 40 je 10cee7 <_Watchdog_Tickle+0x5b>
* to be inserted has already had its delta_interval adjusted to 0, and
* so is added to the head of the chain with a delta_interval of 0.
*
* Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)
*/
if (the_watchdog->delta_interval != 0) {
10cea7: 8b 43 10 mov 0x10(%ebx),%eax
10ceaa: 85 c0 test %eax,%eax
10ceac: 74 08 je 10ceb6 <_Watchdog_Tickle+0x2a>
the_watchdog->delta_interval--;
10ceae: 48 dec %eax
10ceaf: 89 43 10 mov %eax,0x10(%ebx)
if ( the_watchdog->delta_interval != 0 )
10ceb2: 85 c0 test %eax,%eax
10ceb4: 75 31 jne 10cee7 <_Watchdog_Tickle+0x5b>
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
10ceb6: 83 ec 0c sub $0xc,%esp
10ceb9: 53 push %ebx
10ceba: e8 65 ff ff ff call 10ce24 <_Watchdog_Remove>
_ISR_Enable( level );
10cebf: 56 push %esi
10cec0: 9d popf
switch( watchdog_state ) {
10cec1: 83 c4 10 add $0x10,%esp
10cec4: 83 f8 02 cmp $0x2,%eax
10cec7: 75 0e jne 10ced7 <_Watchdog_Tickle+0x4b> <== NEVER TAKEN
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
10cec9: 50 push %eax
10ceca: 50 push %eax
10cecb: ff 73 24 pushl 0x24(%ebx)
10cece: ff 73 20 pushl 0x20(%ebx)
10ced1: ff 53 1c call *0x1c(%ebx)
the_watchdog->id,
the_watchdog->user_data
);
break;
10ced4: 83 c4 10 add $0x10,%esp
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
10ced7: 9c pushf
10ced8: fa cli
10ced9: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10ceda: 8b 1f mov (%edi),%ebx
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
10cedc: 3b 5d e4 cmp -0x1c(%ebp),%ebx
10cedf: 74 06 je 10cee7 <_Watchdog_Tickle+0x5b>
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
10cee1: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10cee5: eb cd jmp 10ceb4 <_Watchdog_Tickle+0x28>
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
10cee7: 56 push %esi
10cee8: 9d popf
}
10cee9: 8d 65 f4 lea -0xc(%ebp),%esp
10ceec: 5b pop %ebx
10ceed: 5e pop %esi
10ceee: 5f pop %edi
10ceef: c9 leave
10cef0: c3 ret
0011ca6c <_exit>:
extern void FINI_SYMBOL( void );
#endif
void EXIT_SYMBOL(int status)
{
11ca6c: 55 push %ebp
11ca6d: 89 e5 mov %esp,%ebp
11ca6f: 83 ec 08 sub $0x8,%esp
/*
* If the toolset uses init/fini sections, then we need to
* run the global destructors now.
*/
#if defined(__USE_INIT_FINI__)
FINI_SYMBOL();
11ca72: e8 46 06 00 00 call 11d0bd <_fini>
* We need to do the exit processing on the global reentrancy structure.
* This has already been done on the per task reentrancy structure
* associated with this task.
*/
libc_wrapup();
11ca77: e8 8c ff ff ff call 11ca08 <libc_wrapup>
rtems_shutdown_executive(status);
11ca7c: 83 ec 0c sub $0xc,%esp
11ca7f: ff 75 08 pushl 0x8(%ebp)
11ca82: e8 d5 00 00 00 call 11cb5c <rtems_shutdown_executive>
11ca87: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
11ca8a: eb fe jmp 11ca8a <_exit+0x1e> <== NOT EXECUTED
0010a268 <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
10a268: 55 push %ebp <== NOT EXECUTED
10a269: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10a26b: 57 push %edi <== NOT EXECUTED
10a26c: 56 push %esi <== NOT EXECUTED
10a26d: 53 push %ebx <== NOT EXECUTED
10a26e: 83 ec 78 sub $0x78,%esp <== NOT EXECUTED
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
10a271: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10a274: e8 99 ee ff ff call 109112 <rtems_filesystem_dirname><== NOT EXECUTED
10a279: 89 45 94 mov %eax,-0x6c(%ebp) <== NOT EXECUTED
if ( old_parent_pathlen == 0 )
10a27c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a27f: 85 c0 test %eax,%eax <== NOT EXECUTED
10a281: 8d 45 b8 lea -0x48(%ebp),%eax <== NOT EXECUTED
10a284: 75 15 jne 10a29b <_rename_r+0x33> <== NOT EXECUTED
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
10a286: 51 push %ecx <== NOT EXECUTED
10a287: 50 push %eax <== NOT EXECUTED
10a288: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED
10a28b: 50 push %eax <== NOT EXECUTED
10a28c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10a28f: e8 48 03 00 00 call 10a5dc <rtems_filesystem_get_start_loc><== NOT EXECUTED
10a294: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
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;
10a297: 31 db xor %ebx,%ebx <== NOT EXECUTED
10a299: eb 23 jmp 10a2be <_rename_r+0x56> <== NOT EXECUTED
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,
10a29b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a29e: 6a 00 push $0x0 <== NOT EXECUTED
10a2a0: 50 push %eax <== NOT EXECUTED
10a2a1: 6a 02 push $0x2 <== NOT EXECUTED
10a2a3: ff 75 94 pushl -0x6c(%ebp) <== NOT EXECUTED
10a2a6: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10a2a9: e8 fb ed ff ff call 1090a9 <rtems_filesystem_evaluate_path><== NOT EXECUTED
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
10a2ae: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
return -1;
10a2b1: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED
else {
result = rtems_filesystem_evaluate_path( old, old_parent_pathlen,
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
10a2b4: 85 c0 test %eax,%eax <== NOT EXECUTED
10a2b6: 0f 85 50 01 00 00 jne 10a40c <_rename_r+0x1a4> <== NOT EXECUTED
return -1;
free_old_parentloc = true;
10a2bc: b3 01 mov $0x1,%bl <== NOT EXECUTED
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
10a2be: 8d 7d cc lea -0x34(%ebp),%edi <== NOT EXECUTED
10a2c1: 8d 75 b8 lea -0x48(%ebp),%esi <== NOT EXECUTED
10a2c4: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED
10a2c9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
name = old + old_parent_pathlen;
10a2cb: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
10a2ce: 03 75 94 add -0x6c(%ebp),%esi <== NOT EXECUTED
10a2d1: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
10a2d4: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED
10a2d7: 89 f7 mov %esi,%edi <== NOT EXECUTED
10a2d9: 31 c0 xor %eax,%eax <== NOT EXECUTED
10a2db: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED
10a2dd: f7 d1 not %ecx <== NOT EXECUTED
10a2df: 49 dec %ecx <== NOT EXECUTED
10a2e0: 52 push %edx <== NOT EXECUTED
10a2e1: 52 push %edx <== NOT EXECUTED
10a2e2: 51 push %ecx <== NOT EXECUTED
10a2e3: 56 push %esi <== NOT EXECUTED
10a2e4: e8 68 ee ff ff call 109151 <rtems_filesystem_prefix_separators><== NOT EXECUTED
10a2e9: 01 c6 add %eax,%esi <== NOT EXECUTED
10a2eb: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
10a2ee: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED
10a2f1: 89 f7 mov %esi,%edi <== NOT EXECUTED
10a2f3: 31 c0 xor %eax,%eax <== NOT EXECUTED
10a2f5: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED
10a2f7: f7 d1 not %ecx <== NOT EXECUTED
10a2f9: 49 dec %ecx <== NOT EXECUTED
10a2fa: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
10a301: 8d 7d cc lea -0x34(%ebp),%edi <== NOT EXECUTED
10a304: 57 push %edi <== NOT EXECUTED
10a305: 6a 00 push $0x0 <== NOT EXECUTED
10a307: 51 push %ecx <== NOT EXECUTED
10a308: 56 push %esi <== NOT EXECUTED
10a309: e8 16 ed ff ff call 109024 <rtems_filesystem_evaluate_relative_path><== NOT EXECUTED
0, &old_loc, false );
if ( result != 0 ) {
10a30e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
10a311: 85 c0 test %eax,%eax <== NOT EXECUTED
10a313: 74 16 je 10a32b <_rename_r+0xc3> <== NOT EXECUTED
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
return -1;
10a315: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED
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 )
10a318: 84 db test %bl,%bl <== NOT EXECUTED
10a31a: 0f 84 ec 00 00 00 je 10a40c <_rename_r+0x1a4> <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
10a320: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a323: 8d 45 b8 lea -0x48(%ebp),%eax <== NOT EXECUTED
10a326: e9 d8 00 00 00 jmp 10a403 <_rename_r+0x19b> <== NOT EXECUTED
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
10a32b: 50 push %eax <== NOT EXECUTED
10a32c: 8d 75 a4 lea -0x5c(%ebp),%esi <== NOT EXECUTED
10a32f: 56 push %esi <== NOT EXECUTED
10a330: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED
10a333: 50 push %eax <== NOT EXECUTED
10a334: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED
10a337: e8 a0 02 00 00 call 10a5dc <rtems_filesystem_get_start_loc><== NOT EXECUTED
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
10a33c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10a33f: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED
10a342: 50 push %eax <== NOT EXECUTED
10a343: 56 push %esi <== NOT EXECUTED
10a344: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10a347: 03 45 e4 add -0x1c(%ebp),%eax <== NOT EXECUTED
10a34a: 50 push %eax <== NOT EXECUTED
10a34b: 8b 45 b0 mov -0x50(%ebp),%eax <== NOT EXECUTED
10a34e: ff 50 04 call *0x4(%eax) <== NOT EXECUTED
if ( result != 0 ) {
10a351: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a354: 85 c0 test %eax,%eax <== NOT EXECUTED
10a356: 74 2d je 10a385 <_rename_r+0x11d> <== NOT EXECUTED
rtems_filesystem_freenode( &new_parent_loc );
10a358: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a35b: 56 push %esi <== NOT EXECUTED
10a35c: e8 2f ee ff ff call 109190 <rtems_filesystem_freenode><== NOT EXECUTED
if ( free_old_parentloc )
10a361: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a364: 84 db test %bl,%bl <== NOT EXECUTED
10a366: 74 0f je 10a377 <_rename_r+0x10f> <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
10a368: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a36b: 8d 45 b8 lea -0x48(%ebp),%eax <== NOT EXECUTED
10a36e: 50 push %eax <== NOT EXECUTED
10a36f: e8 1c ee ff ff call 109190 <rtems_filesystem_freenode><== NOT EXECUTED
10a374: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_filesystem_freenode( &old_loc );
10a377: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a37a: 8d 45 cc lea -0x34(%ebp),%eax <== NOT EXECUTED
10a37d: 50 push %eax <== NOT EXECUTED
10a37e: e8 0d ee ff ff call 109190 <rtems_filesystem_freenode><== NOT EXECUTED
10a383: eb 3e jmp 10a3c3 <_rename_r+0x15b> <== NOT EXECUTED
/*
* 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 ) {
10a385: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED
10a388: 39 45 c8 cmp %eax,-0x38(%ebp) <== NOT EXECUTED
10a38b: 74 3e je 10a3cb <_rename_r+0x163> <== NOT EXECUTED
rtems_filesystem_freenode( &new_parent_loc );
10a38d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a390: 56 push %esi <== NOT EXECUTED
10a391: e8 fa ed ff ff call 109190 <rtems_filesystem_freenode><== NOT EXECUTED
if ( free_old_parentloc )
10a396: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a399: 84 db test %bl,%bl <== NOT EXECUTED
10a39b: 74 0f je 10a3ac <_rename_r+0x144> <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
10a39d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a3a0: 8d 45 b8 lea -0x48(%ebp),%eax <== NOT EXECUTED
10a3a3: 50 push %eax <== NOT EXECUTED
10a3a4: e8 e7 ed ff ff call 109190 <rtems_filesystem_freenode><== NOT EXECUTED
10a3a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_filesystem_freenode( &old_loc );
10a3ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a3af: 8d 45 cc lea -0x34(%ebp),%eax <== NOT EXECUTED
10a3b2: 50 push %eax <== NOT EXECUTED
10a3b3: e8 d8 ed ff ff call 109190 <rtems_filesystem_freenode><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EXDEV );
10a3b8: e8 1f 96 00 00 call 1139dc <__errno> <== NOT EXECUTED
10a3bd: c7 00 12 00 00 00 movl $0x12,(%eax) <== NOT EXECUTED
10a3c3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a3c6: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED
10a3c9: eb 41 jmp 10a40c <_rename_r+0x1a4> <== NOT EXECUTED
}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
10a3cb: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
10a3ce: 56 push %esi <== NOT EXECUTED
10a3cf: 57 push %edi <== NOT EXECUTED
10a3d0: 8d 55 b8 lea -0x48(%ebp),%edx <== NOT EXECUTED
10a3d3: 52 push %edx <== NOT EXECUTED
10a3d4: 8b 45 b0 mov -0x50(%ebp),%eax <== NOT EXECUTED
10a3d7: 89 55 90 mov %edx,-0x70(%ebp) <== NOT EXECUTED
10a3da: ff 50 40 call *0x40(%eax) <== NOT EXECUTED
10a3dd: 89 c7 mov %eax,%edi <== NOT EXECUTED
rtems_filesystem_freenode( &new_parent_loc );
10a3df: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10a3e2: e8 a9 ed ff ff call 109190 <rtems_filesystem_freenode><== NOT EXECUTED
if ( free_old_parentloc )
10a3e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a3ea: 84 db test %bl,%bl <== NOT EXECUTED
10a3ec: 8b 55 90 mov -0x70(%ebp),%edx <== NOT EXECUTED
10a3ef: 74 0c je 10a3fd <_rename_r+0x195> <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
10a3f1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a3f4: 52 push %edx <== NOT EXECUTED
10a3f5: e8 96 ed ff ff call 109190 <rtems_filesystem_freenode><== NOT EXECUTED
10a3fa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_filesystem_freenode( &old_loc );
10a3fd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a400: 8d 45 cc lea -0x34(%ebp),%eax <== NOT EXECUTED
10a403: 50 push %eax <== NOT EXECUTED
10a404: e8 87 ed ff ff call 109190 <rtems_filesystem_freenode><== NOT EXECUTED
return result;
10a409: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
10a40c: 89 f8 mov %edi,%eax <== NOT EXECUTED
10a40e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10a411: 5b pop %ebx <== NOT EXECUTED
10a412: 5e pop %esi <== NOT EXECUTED
10a413: 5f pop %edi <== NOT EXECUTED
10a414: c9 leave <== NOT EXECUTED
10a415: c3 ret <== NOT EXECUTED
0010a85c <_unlink_r>:
int _unlink_r(
struct _reent *ptr __attribute__((unused)),
const char *path
)
{
10a85c: 55 push %ebp <== NOT EXECUTED
10a85d: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10a85f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
return unlink( path );
10a862: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10a865: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
10a868: c9 leave <== NOT EXECUTED
int _unlink_r(
struct _reent *ptr __attribute__((unused)),
const char *path
)
{
return unlink( path );
10a869: e9 ba fe ff ff jmp 10a728 <unlink> <== NOT EXECUTED
001081c4 <cfgetispeed>:
#include <termios.h>
speed_t cfgetispeed(
const struct termios *tp
)
{
1081c4: 55 push %ebp <== NOT EXECUTED
1081c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return (tp->c_cflag / (CIBAUD / CBAUD)) & CBAUD;
1081c7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1081ca: 0f b7 40 0a movzwl 0xa(%eax),%eax <== NOT EXECUTED
1081ce: 25 0f 10 00 00 and $0x100f,%eax <== NOT EXECUTED
}
1081d3: c9 leave <== NOT EXECUTED
1081d4: c3 ret <== NOT EXECUTED
001081d8 <cfgetospeed>:
#include <termios.h>
speed_t cfgetospeed(
const struct termios *tp
)
{
1081d8: 55 push %ebp <== NOT EXECUTED
1081d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return tp->c_cflag & CBAUD;
1081db: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1081de: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
1081e1: 25 0f 10 00 00 and $0x100f,%eax <== NOT EXECUTED
}
1081e6: c9 leave <== NOT EXECUTED
1081e7: c3 ret <== NOT EXECUTED
001081e8 <cfsetispeed>:
int cfsetispeed(
struct termios *tp,
speed_t speed
)
{
1081e8: 55 push %ebp <== NOT EXECUTED
1081e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1081eb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
1081ee: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
1081f1: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
if ( speed & ~CBAUD )
1081f4: a9 f0 ef ff ff test $0xffffeff0,%eax <== NOT EXECUTED
1081f9: 74 10 je 10820b <cfsetispeed+0x23> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
1081fb: e8 14 a7 00 00 call 112914 <__errno> <== NOT EXECUTED
108200: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
108206: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
108209: eb 13 jmp 10821e <cfsetispeed+0x36> <== NOT EXECUTED
tp->c_cflag = (tp->c_cflag & ~CIBAUD) | (speed * (CIBAUD / CBAUD));
10820b: c1 e0 10 shl $0x10,%eax <== NOT EXECUTED
10820e: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED
108211: 81 e2 ff ff f0 ef and $0xeff0ffff,%edx <== NOT EXECUTED
108217: 09 d0 or %edx,%eax <== NOT EXECUTED
108219: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED
return 0;
10821c: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
10821e: c9 leave <== NOT EXECUTED
10821f: c3 ret <== NOT EXECUTED
00108220 <cfsetospeed>:
int cfsetospeed(
struct termios *tp,
speed_t speed
)
{
108220: 55 push %ebp <== NOT EXECUTED
108221: 89 e5 mov %esp,%ebp <== NOT EXECUTED
108223: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
108226: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
108229: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
if ( speed & ~CBAUD )
10822c: f7 c1 f0 ef ff ff test $0xffffeff0,%ecx <== NOT EXECUTED
108232: 74 10 je 108244 <cfsetospeed+0x24> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
108234: e8 db a6 00 00 call 112914 <__errno> <== NOT EXECUTED
108239: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
10823f: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
108242: eb 0f jmp 108253 <cfsetospeed+0x33> <== NOT EXECUTED
tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed;
108244: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED
108247: 25 f0 ef ff ff and $0xffffeff0,%eax <== NOT EXECUTED
10824c: 09 c8 or %ecx,%eax <== NOT EXECUTED
10824e: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED
return 0;
108251: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
108253: c9 leave <== NOT EXECUTED
108254: c3 ret <== NOT EXECUTED
00107364 <chroot>:
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
107364: 55 push %ebp
107365: 89 e5 mov %esp,%ebp
107367: 57 push %edi
107368: 56 push %esi
107369: 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) {
10736c: 81 3d 40 2f 12 00 c8 cmpl $0x1250c8,0x122f40
107373: 50 12 00
107376: 75 1e jne 107396 <chroot+0x32> <== NEVER TAKEN
rtems_libio_set_private_env(); /* try to set a new private env*/
107378: e8 14 11 00 00 call 108491 <rtems_libio_set_private_env>
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
10737d: 81 3d 40 2f 12 00 c8 cmpl $0x1250c8,0x122f40
107384: 50 12 00
107387: 75 0d jne 107396 <chroot+0x32> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
107389: e8 de a4 00 00 call 11186c <__errno> <== NOT EXECUTED
10738e: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
107394: eb 22 jmp 1073b8 <chroot+0x54> <== NOT EXECUTED
}
result = chdir(pathname);
107396: 83 ec 0c sub $0xc,%esp
107399: ff 75 08 pushl 0x8(%ebp)
10739c: e8 5f 75 00 00 call 10e900 <chdir>
if (result) {
1073a1: 83 c4 10 add $0x10,%esp
1073a4: 85 c0 test %eax,%eax
1073a6: 74 15 je 1073bd <chroot+0x59> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( errno );
1073a8: e8 bf a4 00 00 call 11186c <__errno> <== NOT EXECUTED
1073ad: 89 c6 mov %eax,%esi <== NOT EXECUTED
1073af: e8 b8 a4 00 00 call 11186c <__errno> <== NOT EXECUTED
1073b4: 8b 00 mov (%eax),%eax <== NOT EXECUTED
1073b6: 89 06 mov %eax,(%esi) <== NOT EXECUTED
1073b8: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
1073bb: eb 44 jmp 107401 <chroot+0x9d> <== NOT EXECUTED
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
1073bd: 83 ec 0c sub $0xc,%esp
1073c0: 6a 00 push $0x0
1073c2: 8d 75 e4 lea -0x1c(%ebp),%esi
1073c5: 56 push %esi
1073c6: 6a 00 push $0x0
1073c8: 6a 01 push $0x1
1073ca: 68 2e f4 11 00 push $0x11f42e
1073cf: e8 29 01 00 00 call 1074fd <rtems_filesystem_evaluate_path>
1073d4: 83 c4 20 add $0x20,%esp
1073d7: 85 c0 test %eax,%eax
1073d9: 75 cd jne 1073a8 <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);
1073db: 83 ec 0c sub $0xc,%esp
1073de: a1 40 2f 12 00 mov 0x122f40,%eax
1073e3: 83 c0 18 add $0x18,%eax
1073e6: 50 push %eax
1073e7: e8 f8 01 00 00 call 1075e4 <rtems_filesystem_freenode>
rtems_filesystem_root = loc;
1073ec: 8b 3d 40 2f 12 00 mov 0x122f40,%edi
1073f2: 83 c7 18 add $0x18,%edi
1073f5: b9 05 00 00 00 mov $0x5,%ecx
1073fa: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
1073fc: 83 c4 10 add $0x10,%esp
1073ff: 31 c0 xor %eax,%eax
}
107401: 8d 65 f8 lea -0x8(%ebp),%esp
107404: 5e pop %esi
107405: 5f pop %edi
107406: c9 leave
107407: c3 ret
00109ff8 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
109ff8: 55 push %ebp
109ff9: 89 e5 mov %esp,%ebp
109ffb: 83 ec 08 sub $0x8,%esp
109ffe: 8b 45 08 mov 0x8(%ebp),%eax
10a001: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
10a004: 85 d2 test %edx,%edx
10a006: 74 3c je 10a044 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10a008: 83 f8 01 cmp $0x1,%eax
10a00b: 75 0b jne 10a018 <clock_gettime+0x20>
_TOD_Get(tp);
10a00d: 83 ec 0c sub $0xc,%esp
10a010: 52 push %edx
10a011: e8 9e 1b 00 00 call 10bbb4 <_TOD_Get>
10a016: eb 13 jmp 10a02b <clock_gettime+0x33>
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
10a018: 83 f8 04 cmp $0x4,%eax
10a01b: 74 05 je 10a022 <clock_gettime+0x2a> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
10a01d: 83 f8 02 cmp $0x2,%eax
10a020: 75 10 jne 10a032 <clock_gettime+0x3a>
_TOD_Get_uptime_as_timespec( tp );
10a022: 83 ec 0c sub $0xc,%esp
10a025: 52 push %edx
10a026: e8 e5 1b 00 00 call 10bc10 <_TOD_Get_uptime_as_timespec>
return 0;
10a02b: 83 c4 10 add $0x10,%esp
10a02e: 31 c0 xor %eax,%eax
10a030: eb 20 jmp 10a052 <clock_gettime+0x5a>
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
10a032: 83 f8 03 cmp $0x3,%eax
10a035: 75 0d jne 10a044 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( ENOSYS );
10a037: e8 a0 7f 00 00 call 111fdc <__errno>
10a03c: c7 00 58 00 00 00 movl $0x58,(%eax)
10a042: eb 0b jmp 10a04f <clock_gettime+0x57>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
10a044: e8 93 7f 00 00 call 111fdc <__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
0010a054 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
10a054: 55 push %ebp
10a055: 89 e5 mov %esp,%ebp
10a057: 83 ec 08 sub $0x8,%esp
10a05a: 8b 45 08 mov 0x8(%ebp),%eax
10a05d: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
10a060: 85 d2 test %edx,%edx
10a062: 74 44 je 10a0a8 <clock_settime+0x54> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10a064: 83 f8 01 cmp $0x1,%eax
10a067: 75 28 jne 10a091 <clock_settime+0x3d>
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
10a069: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx)
10a06f: 76 37 jbe 10a0a8 <clock_settime+0x54>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a071: a1 24 62 12 00 mov 0x126224,%eax
10a076: 40 inc %eax
10a077: a3 24 62 12 00 mov %eax,0x126224
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
10a07c: 83 ec 0c sub $0xc,%esp
10a07f: 52 push %edx
10a080: e8 e3 1b 00 00 call 10bc68 <_TOD_Set>
_Thread_Enable_dispatch();
10a085: e8 6c 2c 00 00 call 10ccf6 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
10a08a: 83 c4 10 add $0x10,%esp
10a08d: 31 c0 xor %eax,%eax
10a08f: eb 25 jmp 10a0b6 <clock_settime+0x62>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
10a091: 83 f8 02 cmp $0x2,%eax
10a094: 74 05 je 10a09b <clock_settime+0x47>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
10a096: 83 f8 03 cmp $0x3,%eax
10a099: 75 0d jne 10a0a8 <clock_settime+0x54>
rtems_set_errno_and_return_minus_one( ENOSYS );
10a09b: e8 3c 7f 00 00 call 111fdc <__errno>
10a0a0: c7 00 58 00 00 00 movl $0x58,(%eax)
10a0a6: eb 0b jmp 10a0b3 <clock_settime+0x5f>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
10a0a8: e8 2f 7f 00 00 call 111fdc <__errno>
10a0ad: c7 00 16 00 00 00 movl $0x16,(%eax)
10a0b3: 83 c8 ff or $0xffffffff,%eax
return 0;
}
10a0b6: c9 leave
10a0b7: c3 ret
0010d3c0 <devFS_evaluate_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
10d3c0: 55 push %ebp
10d3c1: 89 e5 mov %esp,%ebp
10d3c3: 57 push %edi
10d3c4: 56 push %esi
10d3c5: 53 push %ebx
10d3c6: 83 ec 1c sub $0x1c,%esp
10d3c9: 8b 4d 0c mov 0xc(%ebp),%ecx
10d3cc: 8b 5d 14 mov 0x14(%ebp),%ebx
assert( 0 );
rtems_set_errno_and_return_minus_one( EIO );
}
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
10d3cf: 8b 33 mov (%ebx),%esi
if (!device_name_table)
10d3d1: 85 f6 test %esi,%esi
10d3d3: 74 04 je 10d3d9 <devFS_evaluate_path+0x19><== NEVER TAKEN
10d3d5: 31 ff xor %edi,%edi
10d3d7: eb 5a jmp 10d433 <devFS_evaluate_path+0x73>
rtems_set_errno_and_return_minus_one( EFAULT );
10d3d9: e8 06 23 00 00 call 10f6e4 <__errno> <== NOT EXECUTED
10d3de: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
10d3e4: eb 60 jmp 10d446 <devFS_evaluate_path+0x86><== NOT EXECUTED
for (i = 0; i < rtems_device_table_size; i++) {
if (!device_name_table[i].device_name)
10d3e6: 8b 16 mov (%esi),%edx
10d3e8: 85 d2 test %edx,%edx
10d3ea: 74 43 je 10d42f <devFS_evaluate_path+0x6f>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
10d3ec: 50 push %eax
10d3ed: 51 push %ecx
10d3ee: 52 push %edx
10d3ef: ff 75 08 pushl 0x8(%ebp)
10d3f2: 89 55 e4 mov %edx,-0x1c(%ebp)
10d3f5: 89 4d e0 mov %ecx,-0x20(%ebp)
10d3f8: e8 bf 2e 00 00 call 1102bc <strncmp>
10d3fd: 83 c4 10 add $0x10,%esp
10d400: 85 c0 test %eax,%eax
10d402: 8b 55 e4 mov -0x1c(%ebp),%edx
10d405: 8b 4d e0 mov -0x20(%ebp),%ecx
10d408: 75 25 jne 10d42f <devFS_evaluate_path+0x6f><== NEVER TAKEN
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
10d40a: 80 3c 0a 00 cmpb $0x0,(%edx,%ecx,1)
10d40e: 75 1f jne 10d42f <devFS_evaluate_path+0x6f><== NEVER TAKEN
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
10d410: 89 33 mov %esi,(%ebx)
pathloc->handlers = &devFS_file_handlers;
10d412: c7 43 08 7c ff 11 00 movl $0x11ff7c,0x8(%ebx)
pathloc->ops = &devFS_ops;
10d419: c7 43 0c 34 ff 11 00 movl $0x11ff34,0xc(%ebx)
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
10d420: a1 d4 ff 11 00 mov 0x11ffd4,%eax
10d425: 8b 40 28 mov 0x28(%eax),%eax
10d428: 89 43 10 mov %eax,0x10(%ebx)
return 0;
10d42b: 31 c0 xor %eax,%eax
10d42d: eb 1a jmp 10d449 <devFS_evaluate_path+0x89>
/* 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++) {
10d42f: 47 inc %edi
10d430: 83 c6 14 add $0x14,%esi
10d433: 3b 3d 48 e1 11 00 cmp 0x11e148,%edi
10d439: 72 ab jb 10d3e6 <devFS_evaluate_path+0x26>
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
10d43b: e8 a4 22 00 00 call 10f6e4 <__errno>
10d440: c7 00 02 00 00 00 movl $0x2,(%eax)
10d446: 83 c8 ff or $0xffffffff,%eax
}
10d449: 8d 65 f4 lea -0xc(%ebp),%esp
10d44c: 5b pop %ebx
10d44d: 5e pop %esi
10d44e: 5f pop %edi
10d44f: c9 leave
10d450: c3 ret
00106b18 <devFS_initialize>:
int devFS_initialize(
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const void *data
)
{
106b18: 55 push %ebp
106b19: 89 e5 mov %esp,%ebp
106b1b: 57 push %edi
106b1c: 53 push %ebx
106b1d: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_device_name_t *device_name_table;
/* allocate device only filesystem name table */
device_name_table = (rtems_device_name_t *)_Workspace_Allocate(
106b20: 83 ec 0c sub $0xc,%esp
106b23: 6b 05 48 e1 11 00 14 imul $0x14,0x11e148,%eax
106b2a: 50 push %eax
106b2b: e8 7e 62 00 00 call 10cdae <_Workspace_Allocate>
106b30: 89 c2 mov %eax,%edx
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* no memory for device filesystem */
if (!device_name_table)
106b32: 83 c4 10 add $0x10,%esp
106b35: 85 c0 test %eax,%eax
106b37: 75 10 jne 106b49 <devFS_initialize+0x31> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOMEM );
106b39: e8 a6 8b 00 00 call 10f6e4 <__errno> <== NOT EXECUTED
106b3e: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
106b44: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106b47: eb 20 jmp 106b69 <devFS_initialize+0x51> <== NOT EXECUTED
memset(
106b49: 6b 0d 48 e1 11 00 14 imul $0x14,0x11e148,%ecx
106b50: 31 c0 xor %eax,%eax
106b52: 89 d7 mov %edx,%edi
106b54: f3 aa rep stos %al,%es:(%edi)
device_name_table, 0,
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* set file handlers */
temp_mt_entry->mt_fs_root.handlers = &devFS_file_handlers;
106b56: c7 43 24 7c ff 11 00 movl $0x11ff7c,0x24(%ebx)
temp_mt_entry->mt_fs_root.ops = &devFS_ops;
106b5d: c7 43 28 34 ff 11 00 movl $0x11ff34,0x28(%ebx)
/* Set the node_access to device name table */
temp_mt_entry->mt_fs_root.node_access = (void *)device_name_table;
106b64: 89 53 1c mov %edx,0x1c(%ebx)
return 0;
106b67: 31 c0 xor %eax,%eax
}
106b69: 8d 65 f8 lea -0x8(%ebp),%esp
106b6c: 5b pop %ebx
106b6d: 5f pop %edi
106b6e: c9 leave
106b6f: c3 ret
00106cd0 <devFS_ioctl>:
int devFS_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
106cd0: 55 push %ebp
106cd1: 89 e5 mov %esp,%ebp
106cd3: 83 ec 1c sub $0x1c,%esp
106cd6: 8b 55 08 mov 0x8(%ebp),%edx
rtems_libio_ioctl_args_t args;
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
106cd9: 8b 42 18 mov 0x18(%edx),%eax
args.iop = iop;
106cdc: 89 55 e8 mov %edx,-0x18(%ebp)
args.command = command;
106cdf: 8b 55 0c mov 0xc(%ebp),%edx
106ce2: 89 55 ec mov %edx,-0x14(%ebp)
args.buffer = buffer;
106ce5: 8b 55 10 mov 0x10(%ebp),%edx
106ce8: 89 55 f0 mov %edx,-0x10(%ebp)
status = rtems_io_control(
np->major,
np->minor,
(void *) &args
106ceb: 8d 55 e8 lea -0x18(%ebp),%edx
args.iop = iop;
args.command = command;
args.buffer = buffer;
status = rtems_io_control(
106cee: 52 push %edx
106cef: ff 70 0c pushl 0xc(%eax)
106cf2: ff 70 08 pushl 0x8(%eax)
106cf5: e8 be 38 00 00 call 10a5b8 <rtems_io_control>
np->major,
np->minor,
(void *) &args
);
if ( status )
106cfa: 83 c4 10 add $0x10,%esp
106cfd: 85 c0 test %eax,%eax
106cff: 74 0e je 106d0f <devFS_ioctl+0x3f> <== ALWAYS TAKEN
return rtems_deviceio_errno(status);
106d01: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106d04: 50 push %eax <== NOT EXECUTED
106d05: e8 56 67 00 00 call 10d460 <rtems_deviceio_errno> <== NOT EXECUTED
106d0a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106d0d: eb 03 jmp 106d12 <devFS_ioctl+0x42> <== NOT EXECUTED
return args.ioctl_return;
106d0f: 8b 45 f4 mov -0xc(%ebp),%eax
}
106d12: c9 leave
106d13: c3 ret
00106b70 <devFS_mknod>:
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
106b70: 55 push %ebp
106b71: 89 e5 mov %esp,%ebp
106b73: 57 push %edi
106b74: 56 push %esi
106b75: 53 push %ebx
106b76: 83 ec 1c sub $0x1c,%esp
106b79: 8b 7d 08 mov 0x8(%ebp),%edi
106b7c: 8b 4d 10 mov 0x10(%ebp),%ecx
106b7f: 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') &&
106b82: 80 3f 64 cmpb $0x64,(%edi)
106b85: 75 18 jne 106b9f <devFS_mknod+0x2f> <== NEVER TAKEN
106b87: 80 7f 01 65 cmpb $0x65,0x1(%edi)
106b8b: 75 12 jne 106b9f <devFS_mknod+0x2f> <== NEVER TAKEN
106b8d: 80 7f 02 76 cmpb $0x76,0x2(%edi)
106b91: 75 0c jne 106b9f <devFS_mknod+0x2f> <== NEVER TAKEN
(path[2] == 'v') && (path[3] == '\0'))
return 0;
106b93: 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'))
106b95: 80 7f 03 00 cmpb $0x0,0x3(%edi)
106b99: 0f 84 c9 00 00 00 je 106c68 <devFS_mknod+0xf8>
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
106b9f: 8b 45 0c mov 0xc(%ebp),%eax
106ba2: 25 00 f0 00 00 and $0xf000,%eax
106ba7: 3d 00 20 00 00 cmp $0x2000,%eax
106bac: 74 14 je 106bc2 <devFS_mknod+0x52> <== ALWAYS TAKEN
106bae: 3d 00 60 00 00 cmp $0x6000,%eax <== NOT EXECUTED
106bb3: 74 0d je 106bc2 <devFS_mknod+0x52> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
106bb5: e8 2a 8b 00 00 call 10f6e4 <__errno> <== NOT EXECUTED
106bba: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
106bc0: eb 23 jmp 106be5 <devFS_mknod+0x75> <== NOT EXECUTED
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
106bc2: 89 4d e4 mov %ecx,-0x1c(%ebp)
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
106bc5: 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;
106bc8: 8b 45 18 mov 0x18(%ebp),%eax
106bcb: 8b 08 mov (%eax),%ecx
if (!device_name_table)
106bcd: 85 c9 test %ecx,%ecx
106bcf: 74 09 je 106bda <devFS_mknod+0x6a> <== NEVER TAKEN
106bd1: 89 ca mov %ecx,%edx
106bd3: 83 ce ff or $0xffffffff,%esi
106bd6: 31 db xor %ebx,%ebx
106bd8: eb 46 jmp 106c20 <devFS_mknod+0xb0>
rtems_set_errno_and_return_minus_one( EFAULT );
106bda: e8 05 8b 00 00 call 10f6e4 <__errno> <== NOT EXECUTED
106bdf: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
106be5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106be8: eb 7e jmp 106c68 <devFS_mknod+0xf8> <== NOT EXECUTED
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
106bea: 8b 02 mov (%edx),%eax
106bec: 85 c0 test %eax,%eax
106bee: 74 2a je 106c1a <devFS_mknod+0xaa> <== ALWAYS TAKEN
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
106bf0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
106bf3: 50 push %eax <== NOT EXECUTED
106bf4: 57 push %edi <== NOT EXECUTED
106bf5: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED
106bf8: 89 4d dc mov %ecx,-0x24(%ebp) <== NOT EXECUTED
106bfb: e8 14 96 00 00 call 110214 <strcmp> <== NOT EXECUTED
106c00: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106c03: 85 c0 test %eax,%eax <== NOT EXECUTED
106c05: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED
106c08: 8b 4d dc mov -0x24(%ebp),%ecx <== NOT EXECUTED
106c0b: 75 0f jne 106c1c <devFS_mknod+0xac> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EEXIST );
106c0d: e8 d2 8a 00 00 call 10f6e4 <__errno> <== NOT EXECUTED
106c12: c7 00 11 00 00 00 movl $0x11,(%eax) <== NOT EXECUTED
106c18: eb cb jmp 106be5 <devFS_mknod+0x75> <== NOT EXECUTED
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;
106c1a: 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++){
106c1c: 43 inc %ebx
106c1d: 83 c2 14 add $0x14,%edx
106c20: 3b 1d 48 e1 11 00 cmp 0x11e148,%ebx
106c26: 72 c2 jb 106bea <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)
106c28: 83 fe ff cmp $0xffffffff,%esi
106c2b: 75 0d jne 106c3a <devFS_mknod+0xca> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOMEM );
106c2d: e8 b2 8a 00 00 call 10f6e4 <__errno> <== NOT EXECUTED
106c32: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
106c38: eb ab jmp 106be5 <devFS_mknod+0x75> <== NOT EXECUTED
_ISR_Disable(level);
106c3a: 9c pushf
106c3b: fa cli
106c3c: 5b pop %ebx
device_name_table[slot].device_name = (char *)path;
106c3d: 6b d6 14 imul $0x14,%esi,%edx
106c40: 8d 14 11 lea (%ecx,%edx,1),%edx
106c43: 89 3a mov %edi,(%edx)
device_name_table[slot].device_name_length = strlen(path);
106c45: 31 c0 xor %eax,%eax
106c47: 83 c9 ff or $0xffffffff,%ecx
106c4a: f2 ae repnz scas %es:(%edi),%al
106c4c: f7 d1 not %ecx
106c4e: 49 dec %ecx
106c4f: 89 4a 04 mov %ecx,0x4(%edx)
device_name_table[slot].major = major;
106c52: 8b 45 e4 mov -0x1c(%ebp),%eax
106c55: 89 42 08 mov %eax,0x8(%edx)
device_name_table[slot].minor = minor;
106c58: 8b 45 e0 mov -0x20(%ebp),%eax
106c5b: 89 42 0c mov %eax,0xc(%edx)
device_name_table[slot].mode = mode;
106c5e: 8b 45 0c mov 0xc(%ebp),%eax
106c61: 89 42 10 mov %eax,0x10(%edx)
_ISR_Enable(level);
106c64: 53 push %ebx
106c65: 9d popf
return 0;
106c66: 31 c0 xor %eax,%eax
}
106c68: 8d 65 f4 lea -0xc(%ebp),%esp
106c6b: 5b pop %ebx
106c6c: 5e pop %esi
106c6d: 5f pop %edi
106c6e: c9 leave
106c6f: c3 ret
00106d48 <devFS_read>:
ssize_t devFS_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
106d48: 55 push %ebp <== NOT EXECUTED
106d49: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106d4b: 53 push %ebx <== NOT EXECUTED
106d4c: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED
106d4f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
106d52: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED
args.iop = iop;
106d55: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED
args.offset = iop->offset;
106d58: 8b 48 0c mov 0xc(%eax),%ecx <== NOT EXECUTED
106d5b: 8b 58 10 mov 0x10(%eax),%ebx <== NOT EXECUTED
106d5e: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED
106d61: 89 5d e4 mov %ebx,-0x1c(%ebp) <== NOT EXECUTED
args.buffer = buffer;
106d64: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
106d67: 89 4d e8 mov %ecx,-0x18(%ebp) <== NOT EXECUTED
args.count = count;
106d6a: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED
106d6d: 89 4d ec mov %ecx,-0x14(%ebp) <== NOT EXECUTED
args.flags = iop->flags;
106d70: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED
106d73: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED
args.bytes_moved = 0;
106d76: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED
status = rtems_io_read(
np->major,
np->minor,
(void *) &args
106d7d: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
106d80: 50 push %eax <== NOT EXECUTED
106d81: ff 72 0c pushl 0xc(%edx) <== NOT EXECUTED
106d84: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED
106d87: e8 3c 39 00 00 call 10a6c8 <rtems_io_read> <== NOT EXECUTED
np->major,
np->minor,
(void *) &args
);
if ( status )
106d8c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106d8f: 85 c0 test %eax,%eax <== NOT EXECUTED
106d91: 74 0e je 106da1 <devFS_read+0x59> <== NOT EXECUTED
return rtems_deviceio_errno(status);
106d93: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106d96: 50 push %eax <== NOT EXECUTED
106d97: e8 c4 66 00 00 call 10d460 <rtems_deviceio_errno> <== NOT EXECUTED
106d9c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106d9f: eb 03 jmp 106da4 <devFS_read+0x5c> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
106da1: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED
}
106da4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
106da7: c9 leave <== NOT EXECUTED
106da8: c3 ret <== NOT EXECUTED
00106dac <devFS_stat>:
int devFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
106dac: 55 push %ebp
106dad: 89 e5 mov %esp,%ebp
106daf: 53 push %ebx
106db0: 83 ec 04 sub $0x4,%esp
106db3: 8b 55 0c mov 0xc(%ebp),%edx
rtems_device_name_t *the_dev;
the_dev = (rtems_device_name_t *)loc->node_access;
106db6: 8b 45 08 mov 0x8(%ebp),%eax
106db9: 8b 00 mov (%eax),%eax
if (!the_dev)
106dbb: 85 c0 test %eax,%eax
106dbd: 75 10 jne 106dcf <devFS_stat+0x23> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EFAULT );
106dbf: e8 20 89 00 00 call 10f6e4 <__errno> <== NOT EXECUTED
106dc4: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
106dca: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106dcd: eb 14 jmp 106de3 <devFS_stat+0x37> <== NOT EXECUTED
buf->st_rdev = rtems_filesystem_make_dev_t( the_dev->major, the_dev->minor );
106dcf: 8b 48 0c mov 0xc(%eax),%ecx
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
106dd2: 8b 58 08 mov 0x8(%eax),%ebx
106dd5: 89 5a 18 mov %ebx,0x18(%edx)
106dd8: 89 4a 1c mov %ecx,0x1c(%edx)
buf->st_mode = the_dev->mode;
106ddb: 8b 40 10 mov 0x10(%eax),%eax
106dde: 89 42 0c mov %eax,0xc(%edx)
return 0;
106de1: 31 c0 xor %eax,%eax
}
106de3: 5a pop %edx
106de4: 5b pop %ebx
106de5: c9 leave
106de6: c3 ret
00106de8 <devFS_write>:
ssize_t devFS_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
106de8: 55 push %ebp
106de9: 89 e5 mov %esp,%ebp
106deb: 53 push %ebx
106dec: 83 ec 28 sub $0x28,%esp
106def: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_rw_args_t args;
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
106df2: 8b 50 18 mov 0x18(%eax),%edx
args.iop = iop;
106df5: 89 45 dc mov %eax,-0x24(%ebp)
args.offset = iop->offset;
106df8: 8b 48 0c mov 0xc(%eax),%ecx
106dfb: 8b 58 10 mov 0x10(%eax),%ebx
106dfe: 89 4d e0 mov %ecx,-0x20(%ebp)
106e01: 89 5d e4 mov %ebx,-0x1c(%ebp)
args.buffer = (void *) buffer;
106e04: 8b 4d 0c mov 0xc(%ebp),%ecx
106e07: 89 4d e8 mov %ecx,-0x18(%ebp)
args.count = count;
106e0a: 8b 4d 10 mov 0x10(%ebp),%ecx
106e0d: 89 4d ec mov %ecx,-0x14(%ebp)
args.flags = iop->flags;
106e10: 8b 40 14 mov 0x14(%eax),%eax
106e13: 89 45 f0 mov %eax,-0x10(%ebp)
args.bytes_moved = 0;
106e16: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
status = rtems_io_write(
np->major,
np->minor,
(void *) &args
106e1d: 8d 45 dc lea -0x24(%ebp),%eax
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write(
106e20: 50 push %eax
106e21: ff 72 0c pushl 0xc(%edx)
106e24: ff 72 08 pushl 0x8(%edx)
106e27: e8 d0 38 00 00 call 10a6fc <rtems_io_write>
np->major,
np->minor,
(void *) &args
);
if ( status )
106e2c: 83 c4 10 add $0x10,%esp
106e2f: 85 c0 test %eax,%eax
106e31: 74 0e je 106e41 <devFS_write+0x59> <== ALWAYS TAKEN
return rtems_deviceio_errno(status);
106e33: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106e36: 50 push %eax <== NOT EXECUTED
106e37: e8 24 66 00 00 call 10d460 <rtems_deviceio_errno> <== NOT EXECUTED
106e3c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106e3f: eb 03 jmp 106e44 <devFS_write+0x5c> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
106e41: 8b 45 f4 mov -0xc(%ebp),%eax
}
106e44: 8b 5d fc mov -0x4(%ebp),%ebx
106e47: c9 leave
106e48: c3 ret
001106b0 <device_ftruncate>:
int device_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
1106b0: 55 push %ebp <== NOT EXECUTED
1106b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return 0;
}
1106b3: 31 c0 xor %eax,%eax <== NOT EXECUTED
1106b5: c9 leave <== NOT EXECUTED
1106b6: c3 ret <== NOT EXECUTED
00110661 <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
110661: 55 push %ebp
110662: 89 e5 mov %esp,%ebp
110664: 83 ec 1c sub $0x1c,%esp
110667: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_ioctl_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
args.iop = iop;
11066a: 89 45 e8 mov %eax,-0x18(%ebp)
args.command = command;
11066d: 8b 55 0c mov 0xc(%ebp),%edx
110670: 89 55 ec mov %edx,-0x14(%ebp)
args.buffer = buffer;
110673: 8b 55 10 mov 0x10(%ebp),%edx
110676: 89 55 f0 mov %edx,-0x10(%ebp)
the_jnode = iop->pathinfo.node_access;
110679: 8b 40 18 mov 0x18(%eax),%eax
status = rtems_io_control(
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
11067c: 8d 55 e8 lea -0x18(%ebp),%edx
args.command = command;
args.buffer = buffer;
the_jnode = iop->pathinfo.node_access;
status = rtems_io_control(
11067f: 52 push %edx
110680: ff 70 54 pushl 0x54(%eax)
110683: ff 70 50 pushl 0x50(%eax)
110686: e8 49 08 00 00 call 110ed4 <rtems_io_control>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
11068b: 83 c4 10 add $0x10,%esp
11068e: 85 c0 test %eax,%eax
110690: 74 0e je 1106a0 <device_ioctl+0x3f> <== ALWAYS TAKEN
return rtems_deviceio_errno(status);
110692: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
110695: 50 push %eax <== NOT EXECUTED
110696: e8 39 0a 00 00 call 1110d4 <rtems_deviceio_errno> <== NOT EXECUTED
11069b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
11069e: eb 03 jmp 1106a3 <device_ioctl+0x42> <== NOT EXECUTED
return args.ioctl_return;
1106a0: 8b 45 f4 mov -0xc(%ebp),%eax
}
1106a3: c9 leave
1106a4: c3 ret
0011059f <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
11059f: 55 push %ebp
1105a0: 89 e5 mov %esp,%ebp
1105a2: 53 push %ebx
1105a3: 83 ec 28 sub $0x28,%esp
1105a6: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_rw_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
1105a9: 8b 50 18 mov 0x18(%eax),%edx
args.iop = iop;
1105ac: 89 45 dc mov %eax,-0x24(%ebp)
args.offset = iop->offset;
1105af: 8b 48 0c mov 0xc(%eax),%ecx
1105b2: 8b 58 10 mov 0x10(%eax),%ebx
1105b5: 89 4d e0 mov %ecx,-0x20(%ebp)
1105b8: 89 5d e4 mov %ebx,-0x1c(%ebp)
args.buffer = buffer;
1105bb: 8b 4d 0c mov 0xc(%ebp),%ecx
1105be: 89 4d e8 mov %ecx,-0x18(%ebp)
args.count = count;
1105c1: 8b 4d 10 mov 0x10(%ebp),%ecx
1105c4: 89 4d ec mov %ecx,-0x14(%ebp)
args.flags = iop->flags;
1105c7: 8b 40 14 mov 0x14(%eax),%eax
1105ca: 89 45 f0 mov %eax,-0x10(%ebp)
args.bytes_moved = 0;
1105cd: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
status = rtems_io_read(
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
1105d4: 8d 45 dc lea -0x24(%ebp),%eax
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
1105d7: 50 push %eax
1105d8: ff 72 54 pushl 0x54(%edx)
1105db: ff 72 50 pushl 0x50(%edx)
1105de: e8 59 09 00 00 call 110f3c <rtems_io_read>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
1105e3: 83 c4 10 add $0x10,%esp
1105e6: 85 c0 test %eax,%eax
1105e8: 74 0e je 1105f8 <device_read+0x59> <== ALWAYS TAKEN
return rtems_deviceio_errno(status);
1105ea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1105ed: 50 push %eax <== NOT EXECUTED
1105ee: e8 e1 0a 00 00 call 1110d4 <rtems_deviceio_errno> <== NOT EXECUTED
1105f3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1105f6: eb 03 jmp 1105fb <device_read+0x5c> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
1105f8: 8b 45 f4 mov -0xc(%ebp),%eax
}
1105fb: 8b 5d fc mov -0x4(%ebp),%ebx
1105fe: c9 leave
1105ff: c3 ret
00110600 <device_write>:
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
110600: 55 push %ebp
110601: 89 e5 mov %esp,%ebp
110603: 53 push %ebx
110604: 83 ec 28 sub $0x28,%esp
110607: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_rw_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
11060a: 8b 50 18 mov 0x18(%eax),%edx
args.iop = iop;
11060d: 89 45 dc mov %eax,-0x24(%ebp)
args.offset = iop->offset;
110610: 8b 48 0c mov 0xc(%eax),%ecx
110613: 8b 58 10 mov 0x10(%eax),%ebx
110616: 89 4d e0 mov %ecx,-0x20(%ebp)
110619: 89 5d e4 mov %ebx,-0x1c(%ebp)
args.buffer = (void *) buffer;
11061c: 8b 4d 0c mov 0xc(%ebp),%ecx
11061f: 89 4d e8 mov %ecx,-0x18(%ebp)
args.count = count;
110622: 8b 4d 10 mov 0x10(%ebp),%ecx
110625: 89 4d ec mov %ecx,-0x14(%ebp)
args.flags = iop->flags;
110628: 8b 40 14 mov 0x14(%eax),%eax
11062b: 89 45 f0 mov %eax,-0x10(%ebp)
args.bytes_moved = 0;
11062e: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
status = rtems_io_write(
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
110635: 8d 45 dc lea -0x24(%ebp),%eax
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write(
110638: 50 push %eax
110639: ff 72 54 pushl 0x54(%edx)
11063c: ff 72 50 pushl 0x50(%edx)
11063f: e8 2c 09 00 00 call 110f70 <rtems_io_write>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
110644: 83 c4 10 add $0x10,%esp
110647: 85 c0 test %eax,%eax
110649: 74 0e je 110659 <device_write+0x59> <== ALWAYS TAKEN
return rtems_deviceio_errno(status);
11064b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
11064e: 50 push %eax <== NOT EXECUTED
11064f: e8 80 0a 00 00 call 1110d4 <rtems_deviceio_errno> <== NOT EXECUTED
110654: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
110657: eb 03 jmp 11065c <device_write+0x5c> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
110659: 8b 45 f4 mov -0xc(%ebp),%eax
}
11065c: 8b 5d fc mov -0x4(%ebp),%ebx
11065f: c9 leave
110660: c3 ret
001080f8 <drainOutput>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
1080f8: 55 push %ebp
1080f9: 89 e5 mov %esp,%ebp
1080fb: 53 push %ebx
1080fc: 83 ec 04 sub $0x4,%esp
1080ff: 89 c3 mov %eax,%ebx
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
108101: 83 b8 b4 00 00 00 00 cmpl $0x0,0xb4(%eax)
108108: 74 46 je 108150 <drainOutput+0x58>
rtems_interrupt_disable (level);
10810a: 9c pushf
10810b: fa cli
10810c: 58 pop %eax
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
10810d: eb 2f jmp 10813e <drainOutput+0x46>
tty->rawOutBufState = rob_wait;
10810f: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
108116: 00 00 00
rtems_interrupt_enable (level);
108119: 50 push %eax
10811a: 9d popf
sc = rtems_semaphore_obtain(
10811b: 50 push %eax
10811c: 6a 00 push $0x0
10811e: 6a 00 push $0x0
108120: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
108126: e8 9d 20 00 00 call 10a1c8 <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
10812b: 83 c4 10 add $0x10,%esp
10812e: 85 c0 test %eax,%eax
108130: 74 09 je 10813b <drainOutput+0x43> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
108132: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108135: 50 push %eax <== NOT EXECUTED
108136: e8 55 26 00 00 call 10a790 <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_interrupt_disable (level);
10813b: 9c pushf
10813c: fa cli
10813d: 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) {
10813e: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx
108144: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
10814a: 39 d1 cmp %edx,%ecx
10814c: 75 c1 jne 10810f <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);
10814e: 50 push %eax
10814f: 9d popf
}
}
108150: 8b 5d fc mov -0x4(%ebp),%ebx
108153: c9 leave
108154: c3 ret
00107934 <dup2>:
int dup2(
int fildes,
int fildes2
)
{
107934: 55 push %ebp
107935: 89 e5 mov %esp,%ebp
107937: 57 push %edi
107938: 56 push %esi
107939: 53 push %ebx
10793a: 83 ec 74 sub $0x74,%esp
10793d: 8b 75 08 mov 0x8(%ebp),%esi
107940: 8b 7d 0c mov 0xc(%ebp),%edi
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
107943: 8d 55 a0 lea -0x60(%ebp),%edx
107946: 52 push %edx
107947: 56 push %esi
107948: 89 55 94 mov %edx,-0x6c(%ebp)
10794b: e8 78 04 00 00 call 107dc8 <fstat>
if ( status == -1 )
107950: 83 c4 10 add $0x10,%esp
return -1;
107953: 83 cb ff or $0xffffffff,%ebx
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
if ( status == -1 )
107956: 40 inc %eax
107957: 8b 55 94 mov -0x6c(%ebp),%edx
10795a: 74 1e je 10797a <dup2+0x46> <== NEVER TAKEN
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
10795c: 51 push %ecx
10795d: 51 push %ecx
10795e: 52 push %edx
10795f: 57 push %edi
107960: e8 63 04 00 00 call 107dc8 <fstat>
if ( status == -1 )
107965: 83 c4 10 add $0x10,%esp
107968: 40 inc %eax
107969: 74 0f je 10797a <dup2+0x46> <== ALWAYS TAKEN
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
10796b: 50 push %eax <== NOT EXECUTED
10796c: 57 push %edi <== NOT EXECUTED
10796d: 6a 00 push $0x0 <== NOT EXECUTED
10796f: 56 push %esi <== NOT EXECUTED
107970: e8 8f 01 00 00 call 107b04 <fcntl> <== NOT EXECUTED
107975: 89 c3 mov %eax,%ebx <== NOT EXECUTED
107977: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
10797a: 89 d8 mov %ebx,%eax
10797c: 8d 65 f4 lea -0xc(%ebp),%esp
10797f: 5b pop %ebx
107980: 5e pop %esi
107981: 5f pop %edi
107982: c9 leave
107983: c3 ret
00108ca0 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
108ca0: 55 push %ebp
108ca1: 89 e5 mov %esp,%ebp
108ca3: 53 push %ebx
108ca4: 83 ec 24 sub $0x24,%esp
if ((tty->termios.c_lflag & ECHOCTL) &&
108ca7: f6 42 3d 02 testb $0x2,0x3d(%edx)
108cab: 74 3e je 108ceb <echo+0x4b> <== NEVER TAKEN
iscntrl(c) && (c != '\t') && (c != '\n')) {
108cad: 0f b6 c8 movzbl %al,%ecx
108cb0: 8b 1d 0c 20 12 00 mov 0x12200c,%ebx
108cb6: f6 44 0b 01 20 testb $0x20,0x1(%ebx,%ecx,1)
108cbb: 74 2e je 108ceb <echo+0x4b>
108cbd: 3c 09 cmp $0x9,%al
108cbf: 74 2a je 108ceb <echo+0x4b>
108cc1: 3c 0a cmp $0xa,%al
108cc3: 74 26 je 108ceb <echo+0x4b>
char echobuf[2];
echobuf[0] = '^';
108cc5: c6 45 f6 5e movb $0x5e,-0xa(%ebp)
echobuf[1] = c ^ 0x40;
108cc9: 83 f0 40 xor $0x40,%eax
108ccc: 88 45 f7 mov %al,-0x9(%ebp)
rtems_termios_puts (echobuf, 2, tty);
108ccf: 50 push %eax
108cd0: 52 push %edx
108cd1: 6a 02 push $0x2
108cd3: 8d 45 f6 lea -0xa(%ebp),%eax
108cd6: 50 push %eax
108cd7: 89 55 e4 mov %edx,-0x1c(%ebp)
108cda: e8 84 fd ff ff call 108a63 <rtems_termios_puts>
tty->column += 2;
108cdf: 8b 55 e4 mov -0x1c(%ebp),%edx
108ce2: 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')) {
108ce6: 83 c4 10 add $0x10,%esp
108ce9: eb 08 jmp 108cf3 <echo+0x53>
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
108ceb: 0f b6 c0 movzbl %al,%eax
108cee: e8 90 fe ff ff call 108b83 <oproc>
}
}
108cf3: 8b 5d fc mov -0x4(%ebp),%ebx
108cf6: c9 leave
108cf7: c3 ret
001080d2 <endgrent>:
void endgrent(void)
{
1080d2: 55 push %ebp
1080d3: 89 e5 mov %esp,%ebp
1080d5: 83 ec 08 sub $0x8,%esp
if (group_fp != NULL)
1080d8: a1 98 5d 12 00 mov 0x125d98,%eax
1080dd: 85 c0 test %eax,%eax
1080df: 74 0c je 1080ed <endgrent+0x1b> <== NEVER TAKEN
fclose(group_fp);
1080e1: 83 ec 0c sub $0xc,%esp
1080e4: 50 push %eax
1080e5: e8 52 9f 00 00 call 11203c <fclose>
1080ea: 83 c4 10 add $0x10,%esp
}
1080ed: c9 leave
1080ee: c3 ret
00107f85 <endpwent>:
void endpwent(void)
{
107f85: 55 push %ebp
107f86: 89 e5 mov %esp,%ebp
107f88: 83 ec 08 sub $0x8,%esp
if (passwd_fp != NULL)
107f8b: a1 74 5e 12 00 mov 0x125e74,%eax
107f90: 85 c0 test %eax,%eax
107f92: 74 0c je 107fa0 <endpwent+0x1b> <== NEVER TAKEN
fclose(passwd_fp);
107f94: 83 ec 0c sub $0xc,%esp
107f97: 50 push %eax
107f98: e8 9f a0 00 00 call 11203c <fclose>
107f9d: 83 c4 10 add $0x10,%esp
}
107fa0: c9 leave
107fa1: c3 ret
00108cf8 <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)
{
108cf8: 55 push %ebp
108cf9: 89 e5 mov %esp,%ebp
108cfb: 57 push %edi
108cfc: 56 push %esi
108cfd: 53 push %ebx
108cfe: 83 ec 2c sub $0x2c,%esp
108d01: 89 c3 mov %eax,%ebx
108d03: 89 55 e4 mov %edx,-0x1c(%ebp)
if (tty->ccount == 0)
108d06: 83 78 20 00 cmpl $0x0,0x20(%eax)
108d0a: 0f 84 59 01 00 00 je 108e69 <erase+0x171>
return;
if (lineFlag) {
108d10: 85 d2 test %edx,%edx
108d12: 0f 84 46 01 00 00 je 108e5e <erase+0x166>
if (!(tty->termios.c_lflag & ECHO)) {
108d18: 8b 40 3c mov 0x3c(%eax),%eax
108d1b: a8 08 test $0x8,%al
108d1d: 75 0c jne 108d2b <erase+0x33> <== ALWAYS TAKEN
tty->ccount = 0;
108d1f: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
return;
108d26: e9 3e 01 00 00 jmp 108e69 <erase+0x171> <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
108d2b: a8 10 test $0x10,%al
108d2d: 0f 85 2b 01 00 00 jne 108e5e <erase+0x166> <== ALWAYS TAKEN
tty->ccount = 0;
108d33: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
108d3a: 0f b6 43 44 movzbl 0x44(%ebx),%eax <== NOT EXECUTED
108d3e: 89 da mov %ebx,%edx <== NOT EXECUTED
108d40: e8 5b ff ff ff call 108ca0 <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
108d45: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED
108d49: 0f 84 1a 01 00 00 je 108e69 <erase+0x171> <== NOT EXECUTED
echo ('\n', tty);
108d4f: 89 da mov %ebx,%edx <== NOT EXECUTED
108d51: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
108d56: eb 2a jmp 108d82 <erase+0x8a> <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
108d58: 8b 7b 1c mov 0x1c(%ebx),%edi
108d5b: 8d 50 ff lea -0x1(%eax),%edx
108d5e: 89 53 20 mov %edx,0x20(%ebx)
108d61: 8a 4c 07 ff mov -0x1(%edi,%eax,1),%cl
if (tty->termios.c_lflag & ECHO) {
108d65: 8b 53 3c mov 0x3c(%ebx),%edx
108d68: f6 c2 08 test $0x8,%dl
108d6b: 0f 84 e7 00 00 00 je 108e58 <erase+0x160> <== NEVER TAKEN
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
108d71: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
108d75: 75 17 jne 108d8e <erase+0x96>
108d77: f6 c2 10 test $0x10,%dl
108d7a: 75 12 jne 108d8e <erase+0x96> <== ALWAYS TAKEN
echo (tty->termios.c_cc[VERASE], tty);
108d7c: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED
108d80: 89 da mov %ebx,%edx <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
108d82: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108d85: 5b pop %ebx <== NOT EXECUTED
108d86: 5e pop %esi <== NOT EXECUTED
108d87: 5f pop %edi <== NOT EXECUTED
108d88: 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);
108d89: e9 12 ff ff ff jmp 108ca0 <echo> <== NOT EXECUTED
} else if (c == '\t') {
108d8e: 80 f9 09 cmp $0x9,%cl
108d91: 8b 35 0c 20 12 00 mov 0x12200c,%esi
108d97: 89 75 e0 mov %esi,-0x20(%ebp)
108d9a: 75 60 jne 108dfc <erase+0x104>
int col = tty->read_start_column;
108d9c: 8b 73 2c mov 0x2c(%ebx),%esi
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
108d9f: 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)
108da4: 81 e2 00 02 00 00 and $0x200,%edx
108daa: 89 55 dc mov %edx,-0x24(%ebp)
108dad: 89 45 d4 mov %eax,-0x2c(%ebp)
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
108db0: eb 28 jmp 108dda <erase+0xe2>
c = tty->cbuf[i++];
108db2: 8a 54 0f ff mov -0x1(%edi,%ecx,1),%dl
if (c == '\t') {
108db6: 80 fa 09 cmp $0x9,%dl
108db9: 75 05 jne 108dc0 <erase+0xc8>
col = (col | 7) + 1;
108dbb: 83 ce 07 or $0x7,%esi
108dbe: eb 18 jmp 108dd8 <erase+0xe0>
} else if (iscntrl (c)) {
108dc0: 0f b6 d2 movzbl %dl,%edx
108dc3: 8b 45 e0 mov -0x20(%ebp),%eax
108dc6: f6 44 10 01 20 testb $0x20,0x1(%eax,%edx,1)
108dcb: 74 0b je 108dd8 <erase+0xe0> <== ALWAYS TAKEN
if (tty->termios.c_lflag & ECHOCTL)
108dcd: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) <== NOT EXECUTED
108dd1: 74 06 je 108dd9 <erase+0xe1> <== NOT EXECUTED
col += 2;
108dd3: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
108dd6: eb 01 jmp 108dd9 <erase+0xe1> <== NOT EXECUTED
} else {
col++;
108dd8: 46 inc %esi
108dd9: 41 inc %ecx
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
108dda: 3b 4d d4 cmp -0x2c(%ebp),%ecx
108ddd: 75 d3 jne 108db2 <erase+0xba>
108ddf: eb 14 jmp 108df5 <erase+0xfd>
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
108de1: 57 push %edi
108de2: 53 push %ebx
108de3: 6a 01 push $0x1
108de5: 68 04 e9 11 00 push $0x11e904
108dea: e8 74 fc ff ff call 108a63 <rtems_termios_puts>
tty->column--;
108def: ff 4b 28 decl 0x28(%ebx)
108df2: 83 c4 10 add $0x10,%esp
}
/*
* Back up over the tab
*/
while (tty->column > col) {
108df5: 39 73 28 cmp %esi,0x28(%ebx)
108df8: 7f e7 jg 108de1 <erase+0xe9>
108dfa: eb 5c jmp 108e58 <erase+0x160>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
108dfc: 0f b6 f1 movzbl %cl,%esi
108dff: 8b 45 e0 mov -0x20(%ebp),%eax
108e02: f6 44 30 01 20 testb $0x20,0x1(%eax,%esi,1)
108e07: 74 21 je 108e2a <erase+0x132> <== ALWAYS TAKEN
108e09: 80 e6 02 and $0x2,%dh <== NOT EXECUTED
108e0c: 74 1c je 108e2a <erase+0x132> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
108e0e: 51 push %ecx <== NOT EXECUTED
108e0f: 53 push %ebx <== NOT EXECUTED
108e10: 6a 03 push $0x3 <== NOT EXECUTED
108e12: 68 02 e9 11 00 push $0x11e902 <== NOT EXECUTED
108e17: e8 47 fc ff ff call 108a63 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
108e1c: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
108e1f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108e22: 85 c0 test %eax,%eax <== NOT EXECUTED
108e24: 74 04 je 108e2a <erase+0x132> <== NOT EXECUTED
tty->column--;
108e26: 48 dec %eax <== NOT EXECUTED
108e27: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
108e2a: a1 0c 20 12 00 mov 0x12200c,%eax
108e2f: f6 44 30 01 20 testb $0x20,0x1(%eax,%esi,1)
108e34: 74 06 je 108e3c <erase+0x144> <== ALWAYS TAKEN
108e36: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED
108e3a: 74 1c je 108e58 <erase+0x160> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
108e3c: 52 push %edx
108e3d: 53 push %ebx
108e3e: 6a 03 push $0x3
108e40: 68 02 e9 11 00 push $0x11e902
108e45: e8 19 fc ff ff call 108a63 <rtems_termios_puts>
if (tty->column)
108e4a: 8b 43 28 mov 0x28(%ebx),%eax
108e4d: 83 c4 10 add $0x10,%esp
108e50: 85 c0 test %eax,%eax
108e52: 74 04 je 108e58 <erase+0x160> <== NEVER TAKEN
tty->column--;
108e54: 48 dec %eax
108e55: 89 43 28 mov %eax,0x28(%ebx)
}
}
}
if (!lineFlag)
108e58: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
108e5c: 74 0b je 108e69 <erase+0x171>
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
108e5e: 8b 43 20 mov 0x20(%ebx),%eax
108e61: 85 c0 test %eax,%eax
108e63: 0f 85 ef fe ff ff jne 108d58 <erase+0x60>
}
}
if (!lineFlag)
break;
}
}
108e69: 8d 65 f4 lea -0xc(%ebp),%esp
108e6c: 5b pop %ebx
108e6d: 5e pop %esi
108e6e: 5f pop %edi
108e6f: c9 leave
108e70: c3 ret
00107b04 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
107b04: 55 push %ebp
107b05: 89 e5 mov %esp,%ebp
107b07: 57 push %edi
107b08: 56 push %esi
107b09: 53 push %ebx
107b0a: 83 ec 0c sub $0xc,%esp
107b0d: 8b 5d 08 mov 0x8(%ebp),%ebx
int ret;
va_list ap;
va_start( ap, cmd );
107b10: 8d 75 10 lea 0x10(%ebp),%esi
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
107b13: 8b 0d 44 21 12 00 mov 0x122144,%ecx
107b19: 39 cb cmp %ecx,%ebx
107b1b: 73 14 jae 107b31 <fcntl+0x2d>
iop = rtems_libio_iop( fd );
107b1d: 8b 15 98 60 12 00 mov 0x126098,%edx
107b23: 6b db 38 imul $0x38,%ebx,%ebx
107b26: 8d 1c 1a lea (%edx,%ebx,1),%ebx
rtems_libio_check_is_open(iop);
107b29: 8b 43 14 mov 0x14(%ebx),%eax
107b2c: f6 c4 01 test $0x1,%ah
107b2f: 75 10 jne 107b41 <fcntl+0x3d>
107b31: e8 06 a4 00 00 call 111f3c <__errno>
107b36: c7 00 09 00 00 00 movl $0x9,(%eax)
107b3c: e9 e6 00 00 00 jmp 107c27 <fcntl+0x123>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
107b41: 83 7d 0c 09 cmpl $0x9,0xc(%ebp)
107b45: 0f 87 af 00 00 00 ja 107bfa <fcntl+0xf6>
107b4b: 8b 7d 0c mov 0xc(%ebp),%edi
107b4e: ff 24 bd 24 01 12 00 jmp *0x120124(,%edi,4)
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
107b55: 8b 36 mov (%esi),%esi
if ( fd2 )
107b57: 85 f6 test %esi,%esi
107b59: 74 0e je 107b69 <fcntl+0x65> <== ALWAYS TAKEN
diop = rtems_libio_iop( fd2 );
107b5b: 31 c0 xor %eax,%eax <== NOT EXECUTED
107b5d: 39 ce cmp %ecx,%esi <== NOT EXECUTED
107b5f: 73 15 jae 107b76 <fcntl+0x72> <== NOT EXECUTED
107b61: 6b c6 38 imul $0x38,%esi,%eax <== NOT EXECUTED
107b64: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED
107b67: eb 0d jmp 107b76 <fcntl+0x72> <== NOT EXECUTED
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
107b69: e8 d1 04 00 00 call 10803f <rtems_libio_allocate>
if ( diop == 0 ) {
107b6e: 85 c0 test %eax,%eax
107b70: 0f 84 b1 00 00 00 je 107c27 <fcntl+0x123> <== NEVER TAKEN
ret = -1;
break;
}
}
diop->flags = iop->flags;
107b76: 8b 53 14 mov 0x14(%ebx),%edx
107b79: 89 50 14 mov %edx,0x14(%eax)
diop->pathinfo = iop->pathinfo;
107b7c: 8d 78 18 lea 0x18(%eax),%edi
107b7f: 8d 73 18 lea 0x18(%ebx),%esi
107b82: b9 05 00 00 00 mov $0x5,%ecx
107b87: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ret = (int) (diop - rtems_libio_iops);
107b89: 2b 05 98 60 12 00 sub 0x126098,%eax
107b8f: c1 f8 03 sar $0x3,%eax
107b92: 69 f0 b7 6d db b6 imul $0xb6db6db7,%eax,%esi
107b98: eb 6d jmp 107c07 <fcntl+0x103>
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
107b9a: f6 c4 08 test $0x8,%ah
107b9d: 0f 95 c0 setne %al
107ba0: 0f b6 c0 movzbl %al,%eax
107ba3: 89 c6 mov %eax,%esi
107ba5: eb 64 jmp 107c0b <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 ) )
107ba7: 83 3e 00 cmpl $0x0,(%esi)
107baa: 74 05 je 107bb1 <fcntl+0xad> <== NEVER TAKEN
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
107bac: 80 cc 08 or $0x8,%ah
107baf: eb 03 jmp 107bb4 <fcntl+0xb0>
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
107bb1: 80 e4 f7 and $0xf7,%ah <== NOT EXECUTED
107bb4: 89 43 14 mov %eax,0x14(%ebx)
107bb7: eb 30 jmp 107be9 <fcntl+0xe5>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
107bb9: 83 ec 0c sub $0xc,%esp
107bbc: 50 push %eax
107bbd: e8 3f 04 00 00 call 108001 <rtems_libio_to_fcntl_flags>
107bc2: 89 c6 mov %eax,%esi
107bc4: 83 c4 10 add $0x10,%esp
107bc7: eb 3e jmp 107c07 <fcntl+0x103>
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
107bc9: 83 ec 0c sub $0xc,%esp
107bcc: ff 36 pushl (%esi)
107bce: e8 f9 03 00 00 call 107fcc <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
107bd3: 25 01 02 00 00 and $0x201,%eax
107bd8: 8b 53 14 mov 0x14(%ebx),%edx
107bdb: 81 e2 fe fd ff ff and $0xfffffdfe,%edx
107be1: 09 d0 or %edx,%eax
107be3: 89 43 14 mov %eax,0x14(%ebx)
107be6: 83 c4 10 add $0x10,%esp
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
107be9: 31 f6 xor %esi,%esi
107beb: eb 1e jmp 107c0b <fcntl+0x107>
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
107bed: e8 4a a3 00 00 call 111f3c <__errno>
107bf2: c7 00 86 00 00 00 movl $0x86,(%eax)
107bf8: eb 2d jmp 107c27 <fcntl+0x123>
ret = -1;
break;
default:
errno = EINVAL;
107bfa: e8 3d a3 00 00 call 111f3c <__errno>
107bff: c7 00 16 00 00 00 movl $0x16,(%eax)
107c05: eb 20 jmp 107c27 <fcntl+0x123>
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
107c07: 85 f6 test %esi,%esi
107c09: 78 1f js 107c2a <fcntl+0x126> <== NEVER TAKEN
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
107c0b: 50 push %eax
107c0c: 50 push %eax
107c0d: 8b 43 20 mov 0x20(%ebx),%eax
107c10: 53 push %ebx
107c11: ff 75 0c pushl 0xc(%ebp)
107c14: ff 50 30 call *0x30(%eax)
107c17: 89 c3 mov %eax,%ebx
if (err) {
107c19: 83 c4 10 add $0x10,%esp
107c1c: 85 c0 test %eax,%eax
107c1e: 74 0a je 107c2a <fcntl+0x126> <== ALWAYS TAKEN
errno = err;
107c20: e8 17 a3 00 00 call 111f3c <__errno> <== NOT EXECUTED
107c25: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
ret = -1;
107c27: 83 ce ff or $0xffffffff,%esi
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
107c2a: 89 f0 mov %esi,%eax
107c2c: 8d 65 f4 lea -0xc(%ebp),%esp
107c2f: 5b pop %ebx
107c30: 5e pop %esi
107c31: 5f pop %edi
107c32: c9 leave
107c33: c3 ret
0010f463 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
10f463: 55 push %ebp
10f464: 89 e5 mov %esp,%ebp
10f466: 57 push %edi
10f467: 56 push %esi
10f468: 53 push %ebx
10f469: 83 ec 2c sub $0x2c,%esp
)
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
10f46c: e8 4b fe ff ff call 10f2bc <pipe_lock>
10f471: 89 c6 mov %eax,%esi
if (err)
10f473: 85 c0 test %eax,%eax
10f475: 0f 85 37 03 00 00 jne 10f7b2 <fifo_open+0x34f>
return err;
pipe = *pipep;
10f47b: 8b 45 08 mov 0x8(%ebp),%eax
10f47e: 8b 18 mov (%eax),%ebx
if (pipe == NULL) {
10f480: 85 db test %ebx,%ebx
10f482: 0f 85 56 01 00 00 jne 10f5de <fifo_open+0x17b>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
10f488: 83 ec 0c sub $0xc,%esp
10f48b: 6a 34 push $0x34
10f48d: e8 76 91 ff ff call 108608 <malloc>
10f492: 89 c3 mov %eax,%ebx
10f494: 89 45 d4 mov %eax,-0x2c(%ebp)
if (pipe == NULL)
10f497: 83 c4 10 add $0x10,%esp
10f49a: 85 c0 test %eax,%eax
10f49c: 0f 84 35 01 00 00 je 10f5d7 <fifo_open+0x174>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
10f4a2: b9 0d 00 00 00 mov $0xd,%ecx
10f4a7: 89 c7 mov %eax,%edi
10f4a9: 89 f0 mov %esi,%eax
10f4ab: f3 ab rep stos %eax,%es:(%edi)
pipe->Size = PIPE_BUF;
10f4ad: c7 43 04 00 02 00 00 movl $0x200,0x4(%ebx)
pipe->Buffer = malloc(pipe->Size);
10f4b4: 83 ec 0c sub $0xc,%esp
10f4b7: 68 00 02 00 00 push $0x200
10f4bc: e8 47 91 ff ff call 108608 <malloc>
10f4c1: 89 03 mov %eax,(%ebx)
if (! pipe->Buffer)
10f4c3: 83 c4 10 add $0x10,%esp
10f4c6: 85 c0 test %eax,%eax
10f4c8: 0f 84 fb 00 00 00 je 10f5c9 <fifo_open+0x166> <== NEVER TAKEN
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
10f4ce: 8d 43 2c lea 0x2c(%ebx),%eax
10f4d1: 50 push %eax
10f4d2: 6a 00 push $0x0
10f4d4: 6a 00 push $0x0
rtems_build_name ('P', 'I', 'r', c),
10f4d6: 0f be 05 78 3f 12 00 movsbl 0x123f78,%eax
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
10f4dd: 0d 00 72 49 50 or $0x50497200,%eax
10f4e2: 50 push %eax
10f4e3: e8 d4 19 00 00 call 110ebc <rtems_barrier_create>
10f4e8: 83 c4 10 add $0x10,%esp
10f4eb: 85 c0 test %eax,%eax
10f4ed: 0f 85 c6 00 00 00 jne 10f5b9 <fifo_open+0x156>
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
10f4f3: 8d 43 30 lea 0x30(%ebx),%eax
10f4f6: 50 push %eax
10f4f7: 6a 00 push $0x0
10f4f9: 6a 00 push $0x0
rtems_build_name ('P', 'I', 'w', c),
10f4fb: 0f be 05 78 3f 12 00 movsbl 0x123f78,%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(
10f502: 0d 00 77 49 50 or $0x50497700,%eax
10f507: 50 push %eax
10f508: e8 af 19 00 00 call 110ebc <rtems_barrier_create>
10f50d: 83 c4 10 add $0x10,%esp
10f510: 85 c0 test %eax,%eax
10f512: 0f 85 90 00 00 00 jne 10f5a8 <fifo_open+0x145>
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
10f518: 83 ec 0c sub $0xc,%esp
10f51b: 8d 43 28 lea 0x28(%ebx),%eax
10f51e: 50 push %eax
10f51f: 6a 00 push $0x0
10f521: 6a 10 push $0x10
10f523: 6a 01 push $0x1
rtems_build_name ('P', 'I', 's', c), 1,
10f525: 0f be 05 78 3f 12 00 movsbl 0x123f78,%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(
10f52c: 0d 00 73 49 50 or $0x50497300,%eax
10f531: 50 push %eax
10f532: e8 a9 bc ff ff call 10b1e0 <rtems_semaphore_create>
10f537: 83 c4 20 add $0x20,%esp
10f53a: 85 c0 test %eax,%eax
10f53c: 75 59 jne 10f597 <fifo_open+0x134>
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
10f53e: 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
10f53f: 8d 7d e0 lea -0x20(%ebp),%edi
10f542: 57 push %edi
10f543: ff 73 2c pushl 0x2c(%ebx)
10f546: 68 0c 6b 12 00 push $0x126b0c
10f54b: e8 50 d4 ff ff call 10c9a0 <_Objects_Get>
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
10f550: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax)
_Thread_Enable_dispatch();
10f557: e8 1e dc ff ff call 10d17a <_Thread_Enable_dispatch>
10f55c: 83 c4 0c add $0xc,%esp
10f55f: 57 push %edi
10f560: ff 73 30 pushl 0x30(%ebx)
10f563: 68 0c 6b 12 00 push $0x126b0c
10f568: e8 33 d4 ff ff call 10c9a0 <_Objects_Get>
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
10f56d: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax)
_Thread_Enable_dispatch();
10f574: e8 01 dc ff ff call 10d17a <_Thread_Enable_dispatch>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
10f579: a0 78 3f 12 00 mov 0x123f78,%al
10f57e: 8d 50 01 lea 0x1(%eax),%edx
10f581: 88 15 78 3f 12 00 mov %dl,0x123f78
10f587: 83 c4 10 add $0x10,%esp
10f58a: 3c 7a cmp $0x7a,%al
10f58c: 75 50 jne 10f5de <fifo_open+0x17b>
c = 'a';
10f58e: c6 05 78 3f 12 00 61 movb $0x61,0x123f78
10f595: eb 47 jmp 10f5de <fifo_open+0x17b>
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
10f597: 83 ec 0c sub $0xc,%esp
10f59a: 8b 55 d4 mov -0x2c(%ebp),%edx
10f59d: ff 72 30 pushl 0x30(%edx)
10f5a0: e8 cf 19 00 00 call 110f74 <rtems_barrier_delete>
10f5a5: 83 c4 10 add $0x10,%esp
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
10f5a8: 83 ec 0c sub $0xc,%esp
10f5ab: 8b 45 d4 mov -0x2c(%ebp),%eax
10f5ae: ff 70 2c pushl 0x2c(%eax)
10f5b1: e8 be 19 00 00 call 110f74 <rtems_barrier_delete>
10f5b6: 83 c4 10 add $0x10,%esp
err_rbar:
free(pipe->Buffer);
10f5b9: 83 ec 0c sub $0xc,%esp
10f5bc: 8b 55 d4 mov -0x2c(%ebp),%edx
10f5bf: ff 32 pushl (%edx)
10f5c1: e8 9e 8b ff ff call 108164 <free>
10f5c6: 83 c4 10 add $0x10,%esp
err_buf:
free(pipe);
10f5c9: 83 ec 0c sub $0xc,%esp
10f5cc: ff 75 d4 pushl -0x2c(%ebp)
10f5cf: e8 90 8b ff ff call 108164 <free>
10f5d4: 83 c4 10 add $0x10,%esp
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
10f5d7: be f4 ff ff ff mov $0xfffffff4,%esi
10f5dc: eb 33 jmp 10f611 <fifo_open+0x1ae>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
10f5de: 50 push %eax
10f5df: 6a 00 push $0x0
10f5e1: 6a 00 push $0x0
10f5e3: ff 73 28 pushl 0x28(%ebx)
10f5e6: e8 1d be ff ff call 10b408 <rtems_semaphore_obtain>
10f5eb: 83 c4 10 add $0x10,%esp
10f5ee: 85 c0 test %eax,%eax
10f5f0: 74 05 je 10f5f7 <fifo_open+0x194> <== ALWAYS TAKEN
err = -EINTR;
10f5f2: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
if (*pipep == NULL) {
10f5f7: 8b 45 08 mov 0x8(%ebp),%eax
10f5fa: 83 38 00 cmpl $0x0,(%eax)
10f5fd: 75 12 jne 10f611 <fifo_open+0x1ae>
if (err)
10f5ff: 85 f6 test %esi,%esi
10f601: 74 09 je 10f60c <fifo_open+0x1a9> <== ALWAYS TAKEN
pipe_free(pipe);
10f603: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10f605: e8 39 fd ff ff call 10f343 <pipe_free> <== NOT EXECUTED
10f60a: eb 05 jmp 10f611 <fifo_open+0x1ae> <== NOT EXECUTED
else
*pipep = pipe;
10f60c: 8b 55 08 mov 0x8(%ebp),%edx
10f60f: 89 1a mov %ebx,(%edx)
}
out:
pipe_unlock();
10f611: e8 68 fd ff ff call 10f37e <pipe_unlock>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
10f616: 85 f6 test %esi,%esi
10f618: 0f 85 94 01 00 00 jne 10f7b2 <fifo_open+0x34f>
return err;
pipe = *pipep;
10f61e: 8b 45 08 mov 0x8(%ebp),%eax
10f621: 8b 18 mov (%eax),%ebx
switch (LIBIO_ACCMODE(iop)) {
10f623: 8b 55 0c mov 0xc(%ebp),%edx
10f626: 8b 42 14 mov 0x14(%edx),%eax
10f629: 83 e0 06 and $0x6,%eax
10f62c: 83 f8 04 cmp $0x4,%eax
10f62f: 0f 84 91 00 00 00 je 10f6c6 <fifo_open+0x263>
10f635: 83 f8 06 cmp $0x6,%eax
10f638: 0f 84 10 01 00 00 je 10f74e <fifo_open+0x2eb>
10f63e: 83 f8 02 cmp $0x2,%eax
10f641: 0f 85 49 01 00 00 jne 10f790 <fifo_open+0x32d> <== NEVER TAKEN
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
10f647: ff 43 20 incl 0x20(%ebx)
if (pipe->Readers ++ == 0)
10f64a: 8b 43 10 mov 0x10(%ebx),%eax
10f64d: 8d 50 01 lea 0x1(%eax),%edx
10f650: 89 53 10 mov %edx,0x10(%ebx)
10f653: 85 c0 test %eax,%eax
10f655: 75 11 jne 10f668 <fifo_open+0x205> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
10f657: 57 push %edi
10f658: 57 push %edi
10f659: 8d 45 e4 lea -0x1c(%ebp),%eax
10f65c: 50 push %eax
10f65d: ff 73 30 pushl 0x30(%ebx)
10f660: e8 97 19 00 00 call 110ffc <rtems_barrier_release>
10f665: 83 c4 10 add $0x10,%esp
if (pipe->Writers == 0) {
10f668: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10f66c: 0f 85 1e 01 00 00 jne 10f790 <fifo_open+0x32d>
/* Not an error */
if (LIBIO_NODELAY(iop))
10f672: 8b 45 0c mov 0xc(%ebp),%eax
10f675: f6 40 14 01 testb $0x1,0x14(%eax)
10f679: 0f 85 11 01 00 00 jne 10f790 <fifo_open+0x32d>
break;
prevCounter = pipe->writerCounter;
10f67f: 8b 7b 24 mov 0x24(%ebx),%edi
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
10f682: 83 ec 0c sub $0xc,%esp
10f685: ff 73 28 pushl 0x28(%ebx)
10f688: e8 67 be ff ff call 10b4f4 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
10f68d: 5a pop %edx
10f68e: 59 pop %ecx
10f68f: 6a 00 push $0x0
10f691: ff 73 2c pushl 0x2c(%ebx)
10f694: e8 bb 19 00 00 call 111054 <rtems_barrier_wait>
10f699: 83 c4 10 add $0x10,%esp
10f69c: 85 c0 test %eax,%eax
10f69e: 0f 85 f9 00 00 00 jne 10f79d <fifo_open+0x33a> <== NEVER TAKEN
goto out_error;
if (! PIPE_LOCK(pipe))
10f6a4: 50 push %eax
10f6a5: 6a 00 push $0x0
10f6a7: 6a 00 push $0x0
10f6a9: ff 73 28 pushl 0x28(%ebx)
10f6ac: e8 57 bd ff ff call 10b408 <rtems_semaphore_obtain>
10f6b1: 83 c4 10 add $0x10,%esp
10f6b4: 85 c0 test %eax,%eax
10f6b6: 0f 85 e1 00 00 00 jne 10f79d <fifo_open+0x33a> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->writerCounter);
10f6bc: 3b 7b 24 cmp 0x24(%ebx),%edi
10f6bf: 74 c1 je 10f682 <fifo_open+0x21f> <== NEVER TAKEN
10f6c1: e9 ca 00 00 00 jmp 10f790 <fifo_open+0x32d>
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
10f6c6: ff 43 24 incl 0x24(%ebx)
if (pipe->Writers ++ == 0)
10f6c9: 8b 43 14 mov 0x14(%ebx),%eax
10f6cc: 8d 50 01 lea 0x1(%eax),%edx
10f6cf: 89 53 14 mov %edx,0x14(%ebx)
10f6d2: 85 c0 test %eax,%eax
10f6d4: 75 11 jne 10f6e7 <fifo_open+0x284> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
10f6d6: 57 push %edi
10f6d7: 57 push %edi
10f6d8: 8d 45 e4 lea -0x1c(%ebp),%eax
10f6db: 50 push %eax
10f6dc: ff 73 2c pushl 0x2c(%ebx)
10f6df: e8 18 19 00 00 call 110ffc <rtems_barrier_release>
10f6e4: 83 c4 10 add $0x10,%esp
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
10f6e7: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10f6eb: 0f 85 9f 00 00 00 jne 10f790 <fifo_open+0x32d>
10f6f1: 8b 55 0c mov 0xc(%ebp),%edx
10f6f4: f6 42 14 01 testb $0x1,0x14(%edx)
10f6f8: 74 18 je 10f712 <fifo_open+0x2af>
PIPE_UNLOCK(pipe);
10f6fa: 83 ec 0c sub $0xc,%esp
10f6fd: ff 73 28 pushl 0x28(%ebx)
10f700: e8 ef bd ff ff call 10b4f4 <rtems_semaphore_release>
err = -ENXIO;
goto out_error;
10f705: 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;
10f708: be fa ff ff ff mov $0xfffffffa,%esi
goto out_error;
10f70d: e9 90 00 00 00 jmp 10f7a2 <fifo_open+0x33f>
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
10f712: 8b 7b 20 mov 0x20(%ebx),%edi
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
10f715: 83 ec 0c sub $0xc,%esp
10f718: ff 73 28 pushl 0x28(%ebx)
10f71b: e8 d4 bd ff ff call 10b4f4 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
10f720: 5a pop %edx
10f721: 59 pop %ecx
10f722: 6a 00 push $0x0
10f724: ff 73 30 pushl 0x30(%ebx)
10f727: e8 28 19 00 00 call 111054 <rtems_barrier_wait>
10f72c: 83 c4 10 add $0x10,%esp
10f72f: 85 c0 test %eax,%eax
10f731: 75 6a jne 10f79d <fifo_open+0x33a> <== NEVER TAKEN
goto out_error;
if (! PIPE_LOCK(pipe))
10f733: 50 push %eax
10f734: 6a 00 push $0x0
10f736: 6a 00 push $0x0
10f738: ff 73 28 pushl 0x28(%ebx)
10f73b: e8 c8 bc ff ff call 10b408 <rtems_semaphore_obtain>
10f740: 83 c4 10 add $0x10,%esp
10f743: 85 c0 test %eax,%eax
10f745: 75 56 jne 10f79d <fifo_open+0x33a> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->readerCounter);
10f747: 3b 7b 20 cmp 0x20(%ebx),%edi
10f74a: 74 c9 je 10f715 <fifo_open+0x2b2> <== NEVER TAKEN
10f74c: eb 42 jmp 10f790 <fifo_open+0x32d>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
10f74e: ff 43 20 incl 0x20(%ebx)
if (pipe->Readers ++ == 0)
10f751: 8b 43 10 mov 0x10(%ebx),%eax
10f754: 8d 50 01 lea 0x1(%eax),%edx
10f757: 89 53 10 mov %edx,0x10(%ebx)
10f75a: 85 c0 test %eax,%eax
10f75c: 75 11 jne 10f76f <fifo_open+0x30c> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
10f75e: 57 push %edi
10f75f: 57 push %edi
10f760: 8d 45 e4 lea -0x1c(%ebp),%eax
10f763: 50 push %eax
10f764: ff 73 30 pushl 0x30(%ebx)
10f767: e8 90 18 00 00 call 110ffc <rtems_barrier_release>
10f76c: 83 c4 10 add $0x10,%esp
pipe->writerCounter ++;
10f76f: ff 43 24 incl 0x24(%ebx)
if (pipe->Writers ++ == 0)
10f772: 8b 43 14 mov 0x14(%ebx),%eax
10f775: 8d 50 01 lea 0x1(%eax),%edx
10f778: 89 53 14 mov %edx,0x14(%ebx)
10f77b: 85 c0 test %eax,%eax
10f77d: 75 11 jne 10f790 <fifo_open+0x32d> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
10f77f: 51 push %ecx
10f780: 51 push %ecx
10f781: 8d 45 e4 lea -0x1c(%ebp),%eax
10f784: 50 push %eax
10f785: ff 73 2c pushl 0x2c(%ebx)
10f788: e8 6f 18 00 00 call 110ffc <rtems_barrier_release>
10f78d: 83 c4 10 add $0x10,%esp
break;
}
PIPE_UNLOCK(pipe);
10f790: 83 ec 0c sub $0xc,%esp
10f793: ff 73 28 pushl 0x28(%ebx)
10f796: e8 59 bd ff ff call 10b4f4 <rtems_semaphore_release>
10f79b: eb 12 jmp 10f7af <fifo_open+0x34c>
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
10f79d: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
10f7a2: 52 push %edx
10f7a3: 52 push %edx
10f7a4: ff 75 0c pushl 0xc(%ebp)
10f7a7: ff 75 08 pushl 0x8(%ebp)
10f7aa: e8 f6 fb ff ff call 10f3a5 <pipe_release>
return err;
10f7af: 83 c4 10 add $0x10,%esp
}
10f7b2: 89 f0 mov %esi,%eax
10f7b4: 8d 65 f4 lea -0xc(%ebp),%esp
10f7b7: 5b pop %ebx
10f7b8: 5e pop %esi
10f7b9: 5f pop %edi
10f7ba: c9 leave
10f7bb: c3 ret
00107ca8 <fpathconf>:
long fpathconf(
int fd,
int name
)
{
107ca8: 55 push %ebp
107ca9: 89 e5 mov %esp,%ebp
107cab: 83 ec 08 sub $0x8,%esp
107cae: 8b 45 08 mov 0x8(%ebp),%eax
107cb1: 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);
107cb4: 3b 05 44 21 12 00 cmp 0x122144,%eax
107cba: 73 11 jae 107ccd <fpathconf+0x25>
iop = rtems_libio_iop(fd);
107cbc: 6b c0 38 imul $0x38,%eax,%eax
107cbf: 03 05 98 60 12 00 add 0x126098,%eax
rtems_libio_check_is_open(iop);
107cc5: 8b 48 14 mov 0x14(%eax),%ecx
107cc8: f6 c5 01 test $0x1,%ch
107ccb: 75 0d jne 107cda <fpathconf+0x32> <== ALWAYS TAKEN
107ccd: e8 6a a2 00 00 call 111f3c <__errno>
107cd2: c7 00 09 00 00 00 movl $0x9,(%eax)
107cd8: eb 5b jmp 107d35 <fpathconf+0x8d>
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
107cda: 80 e1 02 and $0x2,%cl
107cdd: 74 4b je 107d2a <fpathconf+0x82> <== NEVER TAKEN
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
107cdf: 8b 40 28 mov 0x28(%eax),%eax
switch ( name ) {
107ce2: 83 fa 0b cmp $0xb,%edx
107ce5: 77 43 ja 107d2a <fpathconf+0x82>
107ce7: ff 24 95 4c 01 12 00 jmp *0x12014c(,%edx,4)
case _PC_LINK_MAX:
return_value = the_limits->link_max;
107cee: 8b 40 38 mov 0x38(%eax),%eax
break;
107cf1: eb 45 jmp 107d38 <fpathconf+0x90>
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
107cf3: 8b 40 3c mov 0x3c(%eax),%eax
break;
107cf6: eb 40 jmp 107d38 <fpathconf+0x90>
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
107cf8: 8b 40 40 mov 0x40(%eax),%eax
break;
107cfb: eb 3b jmp 107d38 <fpathconf+0x90>
case _PC_NAME_MAX:
return_value = the_limits->name_max;
107cfd: 8b 40 44 mov 0x44(%eax),%eax
break;
107d00: eb 36 jmp 107d38 <fpathconf+0x90>
case _PC_PATH_MAX:
return_value = the_limits->path_max;
107d02: 8b 40 48 mov 0x48(%eax),%eax
break;
107d05: eb 31 jmp 107d38 <fpathconf+0x90>
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
107d07: 8b 40 4c mov 0x4c(%eax),%eax
break;
107d0a: eb 2c jmp 107d38 <fpathconf+0x90>
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
107d0c: 8b 40 54 mov 0x54(%eax),%eax
break;
107d0f: eb 27 jmp 107d38 <fpathconf+0x90>
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
107d11: 8b 40 58 mov 0x58(%eax),%eax
break;
107d14: eb 22 jmp 107d38 <fpathconf+0x90>
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
107d16: 8b 40 64 mov 0x64(%eax),%eax
break;
107d19: eb 1d jmp 107d38 <fpathconf+0x90>
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
107d1b: 8b 40 50 mov 0x50(%eax),%eax
break;
107d1e: eb 18 jmp 107d38 <fpathconf+0x90>
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
107d20: 8b 40 5c mov 0x5c(%eax),%eax
break;
107d23: eb 13 jmp 107d38 <fpathconf+0x90>
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
107d25: 8b 40 60 mov 0x60(%eax),%eax
break;
107d28: eb 0e jmp 107d38 <fpathconf+0x90>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
107d2a: e8 0d a2 00 00 call 111f3c <__errno>
107d2f: c7 00 16 00 00 00 movl $0x16,(%eax)
107d35: 83 c8 ff or $0xffffffff,%eax
break;
}
return return_value;
}
107d38: c9 leave
107d39: c3 ret
001072e4 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
1072e4: 55 push %ebp
1072e5: 89 e5 mov %esp,%ebp
1072e7: 53 push %ebx
1072e8: 83 ec 04 sub $0x4,%esp
1072eb: 8b 5d 08 mov 0x8(%ebp),%ebx
MSBUMP(free_calls, 1);
1072ee: ff 05 bc 40 12 00 incl 0x1240bc
if ( !ptr )
1072f4: 85 db test %ebx,%ebx
1072f6: 74 5f je 107357 <free+0x73>
#endif
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
1072f8: 83 3d 64 43 12 00 03 cmpl $0x3,0x124364
1072ff: 75 15 jne 107316 <free+0x32> <== NEVER TAKEN
!malloc_is_system_state_OK() ) {
107301: e8 56 01 00 00 call 10745c <malloc_is_system_state_OK>
#endif
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
107306: 84 c0 test %al,%al
107308: 75 0c jne 107316 <free+0x32>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
10730a: 89 5d 08 mov %ebx,0x8(%ebp)
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
10730d: 8b 5d fc mov -0x4(%ebp),%ebx
107310: 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);
107311: e9 ae 01 00 00 jmp 1074c4 <malloc_deferred_free>
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
107316: a1 10 25 12 00 mov 0x122510,%eax
10731b: 85 c0 test %eax,%eax
10731d: 74 0a je 107329 <free+0x45>
(*rtems_malloc_statistics_helpers->at_free)(ptr);
10731f: 83 ec 0c sub $0xc,%esp
107322: 53 push %ebx
107323: ff 50 08 call *0x8(%eax)
107326: 83 c4 10 add $0x10,%esp
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
107329: 50 push %eax
10732a: 50 push %eax
10732b: 53 push %ebx
10732c: ff 35 50 01 12 00 pushl 0x120150
107332: e8 e1 46 00 00 call 10ba18 <_Protected_heap_Free>
107337: 83 c4 10 add $0x10,%esp
10733a: 84 c0 test %al,%al
10733c: 75 19 jne 107357 <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
10733e: 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",
107343: ff 70 1c pushl 0x1c(%eax)
107346: ff 70 18 pushl 0x18(%eax)
107349: 53 push %ebx
10734a: 68 97 e8 11 00 push $0x11e897
10734f: e8 ec 0b 00 00 call 107f40 <printk>
107354: 83 c4 10 add $0x10,%esp
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
107357: 8b 5d fc mov -0x4(%ebp),%ebx
10735a: c9 leave
10735b: c3 ret
00108454 <free_user_env>:
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
108454: 55 push %ebp <== NOT EXECUTED
108455: 89 e5 mov %esp,%ebp <== NOT EXECUTED
108457: 53 push %ebx <== NOT EXECUTED
108458: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED
10845b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
10845e: 81 fb c8 50 12 00 cmp $0x1250c8,%ebx <== NOT EXECUTED
108464: 74 26 je 10848c <free_user_env+0x38> <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
108466: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108469: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED
10846c: 50 push %eax <== NOT EXECUTED
10846d: e8 72 f1 ff ff call 1075e4 <rtems_filesystem_freenode><== NOT EXECUTED
rtems_filesystem_freenode( &env->root_directory);
108472: 8d 43 18 lea 0x18(%ebx),%eax <== NOT EXECUTED
108475: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
108478: e8 67 f1 ff ff call 1075e4 <rtems_filesystem_freenode><== NOT EXECUTED
free(env);
10847d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108480: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED
}
}
108483: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
108486: c9 leave <== NOT EXECUTED
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
108487: e9 6c f1 ff ff jmp 1075f8 <free> <== NOT EXECUTED
}
}
10848c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10848f: c9 leave <== NOT EXECUTED
108490: c3 ret <== NOT EXECUTED
0010dfb4 <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
10dfb4: 55 push %ebp
10dfb5: 89 e5 mov %esp,%ebp
10dfb7: 57 push %edi
10dfb8: 56 push %esi
10dfb9: 53 push %ebx
10dfba: 83 ec 3c sub $0x3c,%esp
10dfbd: 8b 5d 08 mov 0x8(%ebp),%ebx
10dfc0: 8b 45 0c mov 0xc(%ebp),%eax
10dfc3: 8b 55 10 mov 0x10(%ebp),%edx
10dfc6: 89 45 c0 mov %eax,-0x40(%ebp)
10dfc9: 89 55 c4 mov %edx,-0x3c(%ebp)
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
10dfcc: 3b 1d 44 01 12 00 cmp 0x120144,%ebx
10dfd2: 73 0f jae 10dfe3 <ftruncate+0x2f>
iop = rtems_libio_iop( fd );
10dfd4: 6b db 38 imul $0x38,%ebx,%ebx
10dfd7: 03 1d 98 40 12 00 add 0x124098,%ebx
rtems_libio_check_is_open(iop);
10dfdd: f6 43 15 01 testb $0x1,0x15(%ebx)
10dfe1: 75 0d jne 10dff0 <ftruncate+0x3c>
10dfe3: e8 6c 31 00 00 call 111154 <__errno>
10dfe8: c7 00 09 00 00 00 movl $0x9,(%eax)
10dfee: eb 3e jmp 10e02e <ftruncate+0x7a>
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
10dff0: 8d 7d d4 lea -0x2c(%ebp),%edi
10dff3: 8d 73 18 lea 0x18(%ebx),%esi
10dff6: b9 05 00 00 00 mov $0x5,%ecx
10dffb: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
10dffd: 83 ec 0c sub $0xc,%esp
10e000: 8d 45 d4 lea -0x2c(%ebp),%eax
10e003: 50 push %eax
10e004: 8b 45 e0 mov -0x20(%ebp),%eax
10e007: ff 50 10 call *0x10(%eax)
10e00a: 83 c4 10 add $0x10,%esp
10e00d: 48 dec %eax
10e00e: 75 0d jne 10e01d <ftruncate+0x69> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EISDIR );
10e010: e8 3f 31 00 00 call 111154 <__errno> <== NOT EXECUTED
10e015: c7 00 15 00 00 00 movl $0x15,(%eax) <== NOT EXECUTED
10e01b: eb 11 jmp 10e02e <ftruncate+0x7a> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10e01d: f6 43 14 04 testb $0x4,0x14(%ebx)
10e021: 75 10 jne 10e033 <ftruncate+0x7f>
10e023: e8 2c 31 00 00 call 111154 <__errno>
10e028: c7 00 16 00 00 00 movl $0x16,(%eax)
10e02e: 83 c8 ff or $0xffffffff,%eax
10e031: eb 11 jmp 10e044 <ftruncate+0x90>
return (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
10e033: 50 push %eax
10e034: 8b 43 20 mov 0x20(%ebx),%eax
10e037: ff 75 c4 pushl -0x3c(%ebp)
10e03a: ff 75 c0 pushl -0x40(%ebp)
10e03d: 53 push %ebx
10e03e: ff 50 20 call *0x20(%eax)
10e041: 83 c4 10 add $0x10,%esp
}
10e044: 8d 65 f4 lea -0xc(%ebp),%esp
10e047: 5b pop %ebx
10e048: 5e pop %esi
10e049: 5f pop %edi
10e04a: c9 leave
10e04b: c3 ret
0011e0f0 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
11e0f0: 55 push %ebp
11e0f1: 89 e5 mov %esp,%ebp
11e0f3: 57 push %edi
11e0f4: 56 push %esi
11e0f5: 53 push %ebx
11e0f6: 83 ec 2c sub $0x2c,%esp
11e0f9: 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 );
11e0fc: 31 db xor %ebx,%ebx
11e0fe: 3b 05 44 31 12 00 cmp 0x123144,%eax
11e104: 73 09 jae 11e10f <getdents+0x1f> <== NEVER TAKEN
11e106: 6b d8 38 imul $0x38,%eax,%ebx
11e109: 03 1d c0 71 12 00 add 0x1271c0,%ebx
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
11e10f: 8d 7d d4 lea -0x2c(%ebp),%edi
11e112: 8d 73 18 lea 0x18(%ebx),%esi
11e115: b9 05 00 00 00 mov $0x5,%ecx
11e11a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
11e11c: 83 ec 0c sub $0xc,%esp
11e11f: 8d 45 d4 lea -0x2c(%ebp),%eax
11e122: 50 push %eax
11e123: 8b 45 e0 mov -0x20(%ebp),%eax
11e126: ff 50 10 call *0x10(%eax)
11e129: 83 c4 10 add $0x10,%esp
11e12c: 48 dec %eax
11e12d: 74 10 je 11e13f <getdents+0x4f>
rtems_set_errno_and_return_minus_one( ENOTDIR );
11e12f: e8 a8 3f ff ff call 1120dc <__errno>
11e134: c7 00 14 00 00 00 movl $0x14,(%eax)
11e13a: 83 c8 ff or $0xffffffff,%eax
11e13d: eb 11 jmp 11e150 <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 );
11e13f: 50 push %eax
11e140: 8b 43 20 mov 0x20(%ebx),%eax
11e143: ff 75 10 pushl 0x10(%ebp)
11e146: ff 75 0c pushl 0xc(%ebp)
11e149: 53 push %ebx
11e14a: ff 50 08 call *0x8(%eax)
11e14d: 83 c4 10 add $0x10,%esp
}
11e150: 8d 65 f4 lea -0xc(%ebp),%esp
11e153: 5b pop %ebx
11e154: 5e pop %esi
11e155: 5f pop %edi
11e156: c9 leave
11e157: c3 ret
001106b8 <imfs_dir_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
1106b8: 55 push %ebp
1106b9: 89 e5 mov %esp,%ebp
1106bb: 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 )
1106be: 8b 4a 18 mov 0x18(%edx),%ecx
return -1; /* It wasn't a directory --> return error */
1106c1: 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 )
1106c4: 83 79 4c 01 cmpl $0x1,0x4c(%ecx)
1106c8: 75 10 jne 1106da <imfs_dir_open+0x22> <== NEVER TAKEN
return -1; /* It wasn't a directory --> return error */
iop->offset = 0;
1106ca: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
1106d1: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
return 0;
1106d8: 31 c0 xor %eax,%eax
}
1106da: c9 leave
1106db: c3 ret
00110919 <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
110919: 55 push %ebp
11091a: 89 e5 mov %esp,%ebp
11091c: 53 push %ebx
11091d: 83 ec 04 sub $0x4,%esp
110920: 8b 45 0c mov 0xc(%ebp),%eax
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
110923: 8b 18 mov (%eax),%ebx
110925: 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 ) )
110928: 39 53 50 cmp %edx,0x50(%ebx)
11092b: 74 0d je 11093a <imfs_dir_rmnod+0x21>
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
11092d: e8 22 08 00 00 call 111154 <__errno>
110932: c7 00 5a 00 00 00 movl $0x5a,(%eax)
110938: eb 13 jmp 11094d <imfs_dir_rmnod+0x34>
/*
* You cannot remove the file system root node.
*/
if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
11093a: 8b 40 10 mov 0x10(%eax),%eax
11093d: 39 58 1c cmp %ebx,0x1c(%eax)
110940: 75 10 jne 110952 <imfs_dir_rmnod+0x39>
rtems_set_errno_and_return_minus_one( EBUSY );
110942: e8 0d 08 00 00 call 111154 <__errno>
110947: c7 00 10 00 00 00 movl $0x10,(%eax)
11094d: 83 c8 ff or $0xffffffff,%eax
110950: eb 1c jmp 11096e <imfs_dir_rmnod+0x55>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
110952: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx)
110956: 75 ea jne 110942 <imfs_dir_rmnod+0x29> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBUSY );
IMFS_create_orphan( the_jnode );
110958: 83 ec 0c sub $0xc,%esp
11095b: 53 push %ebx
11095c: e8 6f d4 ff ff call 10ddd0 <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
110961: 89 1c 24 mov %ebx,(%esp)
110964: e8 a9 d4 ff ff call 10de12 <IMFS_check_node_remove>
return 0;
110969: 83 c4 10 add $0x10,%esp
11096c: 31 c0 xor %eax,%eax
}
11096e: 8b 5d fc mov -0x4(%ebp),%ebx
110971: c9 leave
110972: c3 ret
00107c20 <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
107c20: 55 push %ebp
107c21: 89 e5 mov %esp,%ebp
107c23: 53 push %ebx
107c24: 83 ec 04 sub $0x4,%esp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
107c27: 80 3d 5c 5f 12 00 00 cmpb $0x0,0x125f5c
107c2e: 0f 85 b8 00 00 00 jne 107cec <init_etc_passwd_group+0xcc>
return;
etc_passwd_initted = 1;
107c34: c6 05 5c 5f 12 00 01 movb $0x1,0x125f5c
mkdir("/etc", 0777);
107c3b: 50 push %eax
107c3c: 50 push %eax
107c3d: 68 ff 01 00 00 push $0x1ff
107c42: 68 43 01 12 00 push $0x120143
107c47: e8 90 07 00 00 call 1083dc <mkdir>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
107c4c: 59 pop %ecx
107c4d: 5b pop %ebx
107c4e: 68 8a ee 11 00 push $0x11ee8a
107c53: 68 48 01 12 00 push $0x120148
107c58: e8 e3 aa 00 00 call 112740 <fopen>
107c5d: 83 c4 10 add $0x10,%esp
107c60: 85 c0 test %eax,%eax
107c62: 74 06 je 107c6a <init_etc_passwd_group+0x4a>
fclose(fp);
107c64: 83 ec 0c sub $0xc,%esp
107c67: 50 push %eax
107c68: eb 2a jmp 107c94 <init_etc_passwd_group+0x74>
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
107c6a: 52 push %edx
107c6b: 52 push %edx
107c6c: 68 a4 ed 11 00 push $0x11eda4
107c71: 68 48 01 12 00 push $0x120148
107c76: e8 c5 aa 00 00 call 112740 <fopen>
107c7b: 89 c3 mov %eax,%ebx
107c7d: 83 c4 10 add $0x10,%esp
107c80: 85 c0 test %eax,%eax
107c82: 74 18 je 107c9c <init_etc_passwd_group+0x7c><== NEVER TAKEN
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
107c84: 50 push %eax
107c85: 50 push %eax
107c86: 53 push %ebx
107c87: 68 54 01 12 00 push $0x120154
107c8c: e8 7b ab 00 00 call 11280c <fputs>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
107c91: 89 1c 24 mov %ebx,(%esp)
107c94: e8 a3 a3 00 00 call 11203c <fclose>
107c99: 83 c4 10 add $0x10,%esp
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
107c9c: 51 push %ecx
107c9d: 51 push %ecx
107c9e: 68 8a ee 11 00 push $0x11ee8a
107ca3: 68 bb 01 12 00 push $0x1201bb
107ca8: e8 93 aa 00 00 call 112740 <fopen>
107cad: 83 c4 10 add $0x10,%esp
107cb0: 85 c0 test %eax,%eax
107cb2: 74 06 je 107cba <init_etc_passwd_group+0x9a>
fclose(fp);
107cb4: 83 ec 0c sub $0xc,%esp
107cb7: 50 push %eax
107cb8: eb 2a jmp 107ce4 <init_etc_passwd_group+0xc4>
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
107cba: 52 push %edx
107cbb: 52 push %edx
107cbc: 68 a4 ed 11 00 push $0x11eda4
107cc1: 68 bb 01 12 00 push $0x1201bb
107cc6: e8 75 aa 00 00 call 112740 <fopen>
107ccb: 89 c3 mov %eax,%ebx
107ccd: 83 c4 10 add $0x10,%esp
107cd0: 85 c0 test %eax,%eax
107cd2: 74 18 je 107cec <init_etc_passwd_group+0xcc><== NEVER TAKEN
fprintf( fp, "root:x:0:root\n"
107cd4: 50 push %eax
107cd5: 50 push %eax
107cd6: 53 push %ebx
107cd7: 68 c6 01 12 00 push $0x1201c6
107cdc: e8 2b ab 00 00 call 11280c <fputs>
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
107ce1: 89 1c 24 mov %ebx,(%esp)
107ce4: e8 53 a3 00 00 call 11203c <fclose>
107ce9: 83 c4 10 add $0x10,%esp
}
}
107cec: 8b 5d fc mov -0x4(%ebp),%ebx
107cef: c9 leave
107cf0: c3 ret
00108e71 <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
108e71: 55 push %ebp
108e72: 89 e5 mov %esp,%ebp
108e74: 53 push %ebx
108e75: 83 ec 14 sub $0x14,%esp
108e78: 89 d3 mov %edx,%ebx
108e7a: 88 c1 mov %al,%cl
if (tty->termios.c_iflag & ISTRIP)
108e7c: 8b 52 30 mov 0x30(%edx),%edx
108e7f: f6 c2 20 test $0x20,%dl
108e82: 74 03 je 108e87 <iproc+0x16> <== ALWAYS TAKEN
c &= 0x7f;
108e84: 83 e1 7f and $0x7f,%ecx <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
108e87: f6 c6 02 test $0x2,%dh
108e8a: 74 16 je 108ea2 <iproc+0x31>
c = tolower (c);
108e8c: 0f b6 c9 movzbl %cl,%ecx
108e8f: a1 0c 20 12 00 mov 0x12200c,%eax
108e94: 0f be 44 08 01 movsbl 0x1(%eax,%ecx,1),%eax
108e99: 83 e0 03 and $0x3,%eax
108e9c: 48 dec %eax
108e9d: 75 03 jne 108ea2 <iproc+0x31>
108e9f: 83 c1 20 add $0x20,%ecx
if (c == '\r') {
108ea2: 80 f9 0d cmp $0xd,%cl
108ea5: 75 14 jne 108ebb <iproc+0x4a>
if (tty->termios.c_iflag & IGNCR)
return 0;
108ea7: 31 c0 xor %eax,%eax
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
108ea9: f6 c2 80 test $0x80,%dl
108eac: 0f 85 d9 00 00 00 jne 108f8b <iproc+0x11a> <== NEVER TAKEN
return 0;
if (tty->termios.c_iflag & ICRNL)
108eb2: 80 e6 01 and $0x1,%dh
108eb5: 74 1a je 108ed1 <iproc+0x60> <== NEVER TAKEN
c = '\n';
108eb7: b1 0a mov $0xa,%cl
108eb9: eb 16 jmp 108ed1 <iproc+0x60>
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
108ebb: 80 f9 0a cmp $0xa,%cl
108ebe: 75 09 jne 108ec9 <iproc+0x58>
108ec0: 80 e2 40 and $0x40,%dl
108ec3: 74 0c je 108ed1 <iproc+0x60> <== ALWAYS TAKEN
c = '\r';
108ec5: b1 0d mov $0xd,%cl <== NOT EXECUTED
108ec7: eb 08 jmp 108ed1 <iproc+0x60> <== NOT EXECUTED
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
108ec9: 84 c9 test %cl,%cl
108ecb: 0f 84 87 00 00 00 je 108f58 <iproc+0xe7> <== NEVER TAKEN
108ed1: 8b 53 3c mov 0x3c(%ebx),%edx
108ed4: f6 c2 02 test $0x2,%dl
108ed7: 74 7f je 108f58 <iproc+0xe7> <== NEVER TAKEN
if (c == tty->termios.c_cc[VERASE]) {
108ed9: 3a 4b 43 cmp 0x43(%ebx),%cl
108edc: 75 04 jne 108ee2 <iproc+0x71>
erase (tty, 0);
108ede: 31 d2 xor %edx,%edx
108ee0: eb 0a jmp 108eec <iproc+0x7b>
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
108ee2: 3a 4b 44 cmp 0x44(%ebx),%cl
108ee5: 75 11 jne 108ef8 <iproc+0x87>
erase (tty, 1);
108ee7: ba 01 00 00 00 mov $0x1,%edx
108eec: 89 d8 mov %ebx,%eax
108eee: e8 05 fe ff ff call 108cf8 <erase>
108ef3: e9 91 00 00 00 jmp 108f89 <iproc+0x118>
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
108ef8: 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]) {
108efd: 3a 4b 45 cmp 0x45(%ebx),%cl
108f00: 0f 84 85 00 00 00 je 108f8b <iproc+0x11a> <== NEVER TAKEN
return 1;
} else if (c == '\n') {
108f06: 80 f9 0a cmp $0xa,%cl
108f09: 75 1a jne 108f25 <iproc+0xb4>
if (tty->termios.c_lflag & (ECHO | ECHONL))
108f0b: 80 e2 48 and $0x48,%dl
108f0e: 74 09 je 108f19 <iproc+0xa8> <== NEVER TAKEN
echo (c, tty);
108f10: 89 da mov %ebx,%edx
108f12: b0 0a mov $0xa,%al
108f14: e8 87 fd ff ff call 108ca0 <echo>
tty->cbuf[tty->ccount++] = c;
108f19: 8b 43 20 mov 0x20(%ebx),%eax
108f1c: 8b 53 1c mov 0x1c(%ebx),%edx
108f1f: c6 04 02 0a movb $0xa,(%edx,%eax,1)
108f23: eb 28 jmp 108f4d <iproc+0xdc>
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
108f25: 3a 4b 4c cmp 0x4c(%ebx),%cl
108f28: 74 05 je 108f2f <iproc+0xbe> <== NEVER TAKEN
108f2a: 3a 4b 51 cmp 0x51(%ebx),%cl
108f2d: 75 29 jne 108f58 <iproc+0xe7> <== ALWAYS TAKEN
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
108f2f: 80 e2 08 and $0x8,%dl <== NOT EXECUTED
108f32: 74 10 je 108f44 <iproc+0xd3> <== NOT EXECUTED
echo (c, tty);
108f34: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED
108f37: 89 da mov %ebx,%edx <== NOT EXECUTED
108f39: 88 4d f4 mov %cl,-0xc(%ebp) <== NOT EXECUTED
108f3c: e8 5f fd ff ff call 108ca0 <echo> <== NOT EXECUTED
108f41: 8a 4d f4 mov -0xc(%ebp),%cl <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
108f44: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED
108f47: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED
108f4a: 88 0c 02 mov %cl,(%edx,%eax,1) <== NOT EXECUTED
108f4d: 40 inc %eax
108f4e: 89 43 20 mov %eax,0x20(%ebx)
return 1;
108f51: b8 01 00 00 00 mov $0x1,%eax
108f56: eb 33 jmp 108f8b <iproc+0x11a>
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
108f58: 8b 15 44 1f 12 00 mov 0x121f44,%edx
108f5e: 4a dec %edx
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
108f5f: 31 c0 xor %eax,%eax
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
108f61: 39 53 20 cmp %edx,0x20(%ebx)
108f64: 7d 25 jge 108f8b <iproc+0x11a> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHO)
108f66: f6 43 3c 08 testb $0x8,0x3c(%ebx)
108f6a: 74 10 je 108f7c <iproc+0x10b> <== NEVER TAKEN
echo (c, tty);
108f6c: 0f b6 c1 movzbl %cl,%eax
108f6f: 89 da mov %ebx,%edx
108f71: 88 4d f4 mov %cl,-0xc(%ebp)
108f74: e8 27 fd ff ff call 108ca0 <echo>
108f79: 8a 4d f4 mov -0xc(%ebp),%cl
tty->cbuf[tty->ccount++] = c;
108f7c: 8b 43 20 mov 0x20(%ebx),%eax
108f7f: 8b 53 1c mov 0x1c(%ebx),%edx
108f82: 88 0c 02 mov %cl,(%edx,%eax,1)
108f85: 40 inc %eax
108f86: 89 43 20 mov %eax,0x20(%ebx)
}
return 0;
108f89: 31 c0 xor %eax,%eax
}
108f8b: 83 c4 14 add $0x14,%esp
108f8e: 5b pop %ebx
108f8f: c9 leave
108f90: c3 ret
001218d4 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
1218d4: 55 push %ebp
1218d5: 89 e5 mov %esp,%ebp
1218d7: 57 push %edi
1218d8: 56 push %esi
1218d9: 53 push %ebx
1218da: 83 ec 4c sub $0x4c,%esp
1218dd: 8b 5d 0c mov 0xc(%ebp),%ebx
1218e0: 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() )
1218e3: e8 64 fd ff ff call 12164c <getpid>
1218e8: 39 45 08 cmp %eax,0x8(%ebp)
1218eb: 74 0d je 1218fa <killinfo+0x26>
rtems_set_errno_and_return_minus_one( ESRCH );
1218ed: e8 fe 40 ff ff call 1159f0 <__errno>
1218f2: c7 00 03 00 00 00 movl $0x3,(%eax)
1218f8: eb 0f jmp 121909 <killinfo+0x35>
/*
* Validate the signal passed.
*/
if ( !sig )
1218fa: 85 db test %ebx,%ebx
1218fc: 75 13 jne 121911 <killinfo+0x3d>
rtems_set_errno_and_return_minus_one( EINVAL );
1218fe: e8 ed 40 ff ff call 1159f0 <__errno>
121903: c7 00 16 00 00 00 movl $0x16,(%eax)
121909: 83 c8 ff or $0xffffffff,%eax
12190c: e9 ea 01 00 00 jmp 121afb <killinfo+0x227>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
121911: 8d 4b ff lea -0x1(%ebx),%ecx
if ( !is_valid_signo(sig) )
121914: 83 f9 1f cmp $0x1f,%ecx
121917: 77 e5 ja 1218fe <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 )
121919: 6b d3 0c imul $0xc,%ebx,%edx
return 0;
12191c: 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 )
12191e: 83 ba c0 a8 12 00 01 cmpl $0x1,0x12a8c0(%edx)
121925: 0f 84 d0 01 00 00 je 121afb <killinfo+0x227>
/*
* 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 ) )
12192b: 83 fb 04 cmp $0x4,%ebx
12192e: 74 0a je 12193a <killinfo+0x66>
121930: 83 fb 08 cmp $0x8,%ebx
121933: 74 05 je 12193a <killinfo+0x66>
121935: 83 fb 0b cmp $0xb,%ebx
121938: 75 16 jne 121950 <killinfo+0x7c>
return pthread_kill( pthread_self(), sig );
12193a: e8 79 03 00 00 call 121cb8 <pthread_self>
12193f: 56 push %esi
121940: 56 push %esi
121941: 53 push %ebx
121942: 50 push %eax
121943: e8 c8 02 00 00 call 121c10 <pthread_kill>
121948: 83 c4 10 add $0x10,%esp
12194b: e9 ab 01 00 00 jmp 121afb <killinfo+0x227>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
121950: be 01 00 00 00 mov $0x1,%esi
121955: d3 e6 shl %cl,%esi
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
121957: 89 5d dc mov %ebx,-0x24(%ebp)
siginfo->si_code = SI_USER;
12195a: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
if ( !value ) {
121961: 85 ff test %edi,%edi
121963: 75 09 jne 12196e <killinfo+0x9a>
siginfo->si_value.sival_int = 0;
121965: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
12196c: eb 05 jmp 121973 <killinfo+0x9f>
} else {
siginfo->si_value = *value;
12196e: 8b 07 mov (%edi),%eax
121970: 89 45 e4 mov %eax,-0x1c(%ebp)
121973: a1 58 a3 12 00 mov 0x12a358,%eax
121978: 40 inc %eax
121979: a3 58 a3 12 00 mov %eax,0x12a358
/*
* 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;
12197e: 8b 15 a8 a8 12 00 mov 0x12a8a8,%edx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
121984: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax
12198a: 8b 80 cc 00 00 00 mov 0xcc(%eax),%eax
121990: f7 d0 not %eax
121992: 85 c6 test %eax,%esi
121994: 0f 85 e7 00 00 00 jne 121a81 <killinfo+0x1ad>
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = the_chain->first ;
12199a: a1 44 aa 12 00 mov 0x12aa44,%eax
12199f: eb 23 jmp 1219c4 <killinfo+0xf0>
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
1219a1: 89 c2 mov %eax,%edx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
1219a3: 8b 88 f8 00 00 00 mov 0xf8(%eax),%ecx
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
1219a9: 85 70 30 test %esi,0x30(%eax)
1219ac: 0f 85 cf 00 00 00 jne 121a81 <killinfo+0x1ad>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
1219b2: 8b 89 cc 00 00 00 mov 0xcc(%ecx),%ecx
1219b8: f7 d1 not %ecx
1219ba: 85 ce test %ecx,%esi
1219bc: 0f 85 bf 00 00 00 jne 121a81 <killinfo+0x1ad>
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 ) {
1219c2: 8b 00 mov (%eax),%eax
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = the_chain->first ;
1219c4: 3d 48 aa 12 00 cmp $0x12aa48,%eax
1219c9: 75 d6 jne 1219a1 <killinfo+0xcd>
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
1219cb: 0f b6 0d f4 61 12 00 movzbl 0x1261f4,%ecx
1219d2: 41 inc %ecx
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
1219d3: 31 d2 xor %edx,%edx
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
1219d5: 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 ] )
1219dc: 8b 7d cc mov -0x34(%ebp),%edi
1219df: 8b 04 bd 30 a3 12 00 mov 0x12a330(,%edi,4),%eax
1219e6: 85 c0 test %eax,%eax
1219e8: 0f 84 82 00 00 00 je 121a70 <killinfo+0x19c> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
1219ee: 8b 40 04 mov 0x4(%eax),%eax
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
1219f1: 0f b7 78 10 movzwl 0x10(%eax),%edi
1219f5: 89 7d c4 mov %edi,-0x3c(%ebp)
object_table = the_info->local_table;
1219f8: 8b 40 1c mov 0x1c(%eax),%eax
1219fb: 89 45 c0 mov %eax,-0x40(%ebp)
for ( index = 1 ; index <= maximum ; index++ ) {
1219fe: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp)
121a05: 89 5d b4 mov %ebx,-0x4c(%ebp)
121a08: eb 5b jmp 121a65 <killinfo+0x191>
the_thread = (Thread_Control *) object_table[ index ];
121a0a: 8b 5d d0 mov -0x30(%ebp),%ebx
121a0d: 8b 7d c0 mov -0x40(%ebp),%edi
121a10: 8b 04 9f mov (%edi,%ebx,4),%eax
if ( !the_thread )
121a13: 85 c0 test %eax,%eax
121a15: 74 4b je 121a62 <killinfo+0x18e>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
121a17: 8b 58 14 mov 0x14(%eax),%ebx
121a1a: 89 5d d4 mov %ebx,-0x2c(%ebp)
121a1d: 39 cb cmp %ecx,%ebx
121a1f: 77 41 ja 121a62 <killinfo+0x18e>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
121a21: 8b b8 f8 00 00 00 mov 0xf8(%eax),%edi
121a27: 8b bf cc 00 00 00 mov 0xcc(%edi),%edi
121a2d: f7 d7 not %edi
121a2f: 85 fe test %edi,%esi
121a31: 74 2f je 121a62 <killinfo+0x18e>
*
* 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 ) {
121a33: 39 cb cmp %ecx,%ebx
121a35: 72 26 jb 121a5d <killinfo+0x189>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( !_States_Is_ready( interested->current_state ) ) {
121a37: 8b 7a 10 mov 0x10(%edx),%edi
121a3a: 89 7d c8 mov %edi,-0x38(%ebp)
121a3d: 85 ff test %edi,%edi
121a3f: 74 21 je 121a62 <killinfo+0x18e> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
121a41: 8b 78 10 mov 0x10(%eax),%edi
121a44: 85 ff test %edi,%edi
121a46: 74 15 je 121a5d <killinfo+0x189>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
121a48: f7 45 c8 00 00 00 10 testl $0x10000000,-0x38(%ebp)
121a4f: 75 11 jne 121a62 <killinfo+0x18e>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
121a51: 81 e7 00 00 00 10 and $0x10000000,%edi
121a57: 74 09 je 121a62 <killinfo+0x18e>
121a59: 89 d9 mov %ebx,%ecx
121a5b: eb 03 jmp 121a60 <killinfo+0x18c>
*/
if ( !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
121a5d: 8b 4d d4 mov -0x2c(%ebp),%ecx
121a60: 89 c2 mov %eax,%edx
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
121a62: ff 45 d0 incl -0x30(%ebp)
121a65: 8b 45 c4 mov -0x3c(%ebp),%eax
121a68: 39 45 d0 cmp %eax,-0x30(%ebp)
121a6b: 76 9d jbe 121a0a <killinfo+0x136>
121a6d: 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++) {
121a70: ff 45 cc incl -0x34(%ebp)
121a73: 83 7d cc 04 cmpl $0x4,-0x34(%ebp)
121a77: 0f 85 5f ff ff ff jne 1219dc <killinfo+0x108>
}
}
}
}
if ( interested ) {
121a7d: 85 d2 test %edx,%edx
121a7f: 74 13 je 121a94 <killinfo+0x1c0>
/*
* 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 ) ) {
121a81: 51 push %ecx
mask = signo_to_mask( sig );
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
121a82: 8d 45 dc lea -0x24(%ebp),%eax
/*
* 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 ) ) {
121a85: 50 push %eax
121a86: 53 push %ebx
121a87: 52 push %edx
121a88: e8 8b 00 00 00 call 121b18 <_POSIX_signals_Unblock_thread>
121a8d: 83 c4 10 add $0x10,%esp
121a90: 84 c0 test %al,%al
121a92: 75 60 jne 121af4 <killinfo+0x220>
/*
* 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 );
121a94: 83 ec 0c sub $0xc,%esp
121a97: 56 push %esi
121a98: e8 67 00 00 00 call 121b04 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
121a9d: 6b db 0c imul $0xc,%ebx,%ebx
121aa0: 83 c4 10 add $0x10,%esp
121aa3: 83 bb b8 a8 12 00 02 cmpl $0x2,0x12a8b8(%ebx)
121aaa: 75 48 jne 121af4 <killinfo+0x220>
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
121aac: 83 ec 0c sub $0xc,%esp
121aaf: 68 38 aa 12 00 push $0x12aa38
121ab4: e8 e3 d6 fe ff call 10f19c <_Chain_Get>
if ( !psiginfo ) {
121ab9: 83 c4 10 add $0x10,%esp
121abc: 85 c0 test %eax,%eax
121abe: 75 15 jne 121ad5 <killinfo+0x201>
_Thread_Enable_dispatch();
121ac0: e8 3d ec fe ff call 110702 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
121ac5: e8 26 3f ff ff call 1159f0 <__errno>
121aca: c7 00 0b 00 00 00 movl $0xb,(%eax)
121ad0: e9 34 fe ff ff jmp 121909 <killinfo+0x35>
}
psiginfo->Info = *siginfo;
121ad5: 8d 78 08 lea 0x8(%eax),%edi
121ad8: 8d 75 dc lea -0x24(%ebp),%esi
121adb: b9 03 00 00 00 mov $0x3,%ecx
121ae0: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
121ae2: 52 push %edx
121ae3: 52 push %edx
121ae4: 50 push %eax
121ae5: 81 c3 b0 aa 12 00 add $0x12aab0,%ebx
121aeb: 53 push %ebx
121aec: e8 6f d6 fe ff call 10f160 <_Chain_Append>
121af1: 83 c4 10 add $0x10,%esp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
121af4: e8 09 ec fe ff call 110702 <_Thread_Enable_dispatch>
return 0;
121af9: 31 c0 xor %eax,%eax
}
121afb: 8d 65 f4 lea -0xc(%ebp),%esp
121afe: 5b pop %ebx
121aff: 5e pop %esi
121b00: 5f pop %edi
121b01: c9 leave
121b02: c3 ret
0011ca08 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
11ca08: 55 push %ebp
11ca09: 89 e5 mov %esp,%ebp
11ca0b: 53 push %ebx
11ca0c: 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()))
11ca0f: 83 3d 64 43 12 00 03 cmpl $0x3,0x124364
11ca16: 75 4f jne 11ca67 <libc_wrapup+0x5f> <== NEVER TAKEN
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
11ca18: 8b 1d 40 f3 11 00 mov 0x11f340,%ebx
11ca1e: 39 1d 20 20 12 00 cmp %ebx,0x122020
11ca24: 74 12 je 11ca38 <libc_wrapup+0x30>
_wrapup_reent(_global_impure_ptr);
11ca26: 83 ec 0c sub $0xc,%esp
11ca29: 53 push %ebx
11ca2a: e8 ad 05 00 00 call 11cfdc <_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;
11ca2f: 89 1d 20 20 12 00 mov %ebx,0x122020
11ca35: 83 c4 10 add $0x10,%esp
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
11ca38: 83 ec 0c sub $0xc,%esp
11ca3b: a1 20 20 12 00 mov 0x122020,%eax
11ca40: ff 70 04 pushl 0x4(%eax)
11ca43: e8 64 48 ff ff call 1112ac <fclose>
fclose (stdout);
11ca48: 5a pop %edx
11ca49: a1 20 20 12 00 mov 0x122020,%eax
11ca4e: ff 70 08 pushl 0x8(%eax)
11ca51: e8 56 48 ff ff call 1112ac <fclose>
fclose (stderr);
11ca56: 58 pop %eax
11ca57: a1 20 20 12 00 mov 0x122020,%eax
11ca5c: ff 70 0c pushl 0xc(%eax)
11ca5f: e8 48 48 ff ff call 1112ac <fclose>
11ca64: 83 c4 10 add $0x10,%esp
}
11ca67: 8b 5d fc mov -0x4(%ebp),%ebx
11ca6a: c9 leave
11ca6b: c3 ret
0011c914 <lseek>:
off_t lseek(
int fd,
off_t offset,
int whence
)
{
11c914: 55 push %ebp
11c915: 89 e5 mov %esp,%ebp
11c917: 57 push %edi
11c918: 56 push %esi
11c919: 53 push %ebx
11c91a: 83 ec 1c sub $0x1c,%esp
11c91d: 8b 5d 08 mov 0x8(%ebp),%ebx
11c920: 8b 45 0c mov 0xc(%ebp),%eax
11c923: 8b 55 10 mov 0x10(%ebp),%edx
11c926: 8b 4d 14 mov 0x14(%ebp),%ecx
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
11c929: 3b 1d 44 01 12 00 cmp 0x120144,%ebx
11c92f: 73 0f jae 11c940 <lseek+0x2c>
iop = rtems_libio_iop( fd );
11c931: 6b db 38 imul $0x38,%ebx,%ebx
11c934: 03 1d 98 40 12 00 add 0x124098,%ebx
rtems_libio_check_is_open(iop);
11c93a: f6 43 15 01 testb $0x1,0x15(%ebx)
11c93e: 75 0d jne 11c94d <lseek+0x39>
11c940: e8 0f 48 ff ff call 111154 <__errno>
11c945: c7 00 09 00 00 00 movl $0x9,(%eax)
11c94b: eb 4b jmp 11c998 <lseek+0x84>
/*
* Now process the lseek().
*/
old_offset = iop->offset;
11c94d: 8b 73 0c mov 0xc(%ebx),%esi
11c950: 8b 7b 10 mov 0x10(%ebx),%edi
11c953: 89 75 e0 mov %esi,-0x20(%ebp)
11c956: 89 7d e4 mov %edi,-0x1c(%ebp)
switch ( whence ) {
11c959: 83 f9 01 cmp $0x1,%ecx
11c95c: 74 11 je 11c96f <lseek+0x5b>
11c95e: 83 f9 02 cmp $0x2,%ecx
11c961: 74 18 je 11c97b <lseek+0x67>
11c963: 85 c9 test %ecx,%ecx
11c965: 75 26 jne 11c98d <lseek+0x79>
case SEEK_SET:
iop->offset = offset;
11c967: 89 43 0c mov %eax,0xc(%ebx)
11c96a: 89 53 10 mov %edx,0x10(%ebx)
break;
11c96d: eb 30 jmp 11c99f <lseek+0x8b>
case SEEK_CUR:
iop->offset += offset;
11c96f: 8b 75 e0 mov -0x20(%ebp),%esi
11c972: 8b 7d e4 mov -0x1c(%ebp),%edi
11c975: 01 c6 add %eax,%esi
11c977: 11 d7 adc %edx,%edi
11c979: eb 0a jmp 11c985 <lseek+0x71>
break;
case SEEK_END:
iop->offset = iop->size + offset;
11c97b: 89 c6 mov %eax,%esi
11c97d: 89 d7 mov %edx,%edi
11c97f: 03 73 04 add 0x4(%ebx),%esi
11c982: 13 7b 08 adc 0x8(%ebx),%edi
11c985: 89 73 0c mov %esi,0xc(%ebx)
11c988: 89 7b 10 mov %edi,0x10(%ebx)
break;
11c98b: eb 12 jmp 11c99f <lseek+0x8b>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
11c98d: e8 c2 47 ff ff call 111154 <__errno>
11c992: c7 00 16 00 00 00 movl $0x16,(%eax)
11c998: 83 c8 ff or $0xffffffff,%eax
11c99b: 89 c2 mov %eax,%edx
11c99d: eb 23 jmp 11c9c2 <lseek+0xae>
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
11c99f: 8b 73 20 mov 0x20(%ebx),%esi
11c9a2: 51 push %ecx
11c9a3: 52 push %edx
11c9a4: 50 push %eax
11c9a5: 53 push %ebx
11c9a6: ff 56 14 call *0x14(%esi)
if ( status == (off_t) -1 )
11c9a9: 83 c4 10 add $0x10,%esp
11c9ac: 83 fa ff cmp $0xffffffff,%edx
11c9af: 75 11 jne 11c9c2 <lseek+0xae>
11c9b1: 83 f8 ff cmp $0xffffffff,%eax
11c9b4: 75 0c jne 11c9c2 <lseek+0xae> <== NEVER TAKEN
iop->offset = old_offset;
11c9b6: 8b 75 e0 mov -0x20(%ebp),%esi
11c9b9: 8b 7d e4 mov -0x1c(%ebp),%edi
11c9bc: 89 73 0c mov %esi,0xc(%ebx)
11c9bf: 89 7b 10 mov %edi,0x10(%ebx)
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
11c9c2: 8d 65 f4 lea -0xc(%ebp),%esp
11c9c5: 5b pop %ebx
11c9c6: 5e pop %esi
11c9c7: 5f pop %edi
11c9c8: c9 leave
11c9c9: c3 ret
00107580 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
107580: 55 push %ebp
107581: 89 e5 mov %esp,%ebp
107583: 56 push %esi
107584: 53 push %ebx
107585: 8b 75 08 mov 0x8(%ebp),%esi
void *return_this;
MSBUMP(malloc_calls, 1);
107588: ff 05 b4 40 12 00 incl 0x1240b4
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
10758e: e8 07 ff ff ff call 10749a <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
return (void *) 0;
107593: 31 db xor %ebx,%ebx
malloc_deferred_frees_process();
/*
* Validate the parameters
*/
if ( !size )
107595: 85 f6 test %esi,%esi
107597: 74 78 je 107611 <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()) &&
107599: 83 3d 64 43 12 00 03 cmpl $0x3,0x124364
1075a0: 75 09 jne 1075ab <malloc+0x2b>
!malloc_is_system_state_OK() )
1075a2: e8 b5 fe ff ff call 10745c <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()) &&
1075a7: 84 c0 test %al,%al
1075a9: 74 66 je 107611 <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 );
1075ab: 6a 00 push $0x0
1075ad: 6a 00 push $0x0
1075af: 56 push %esi
1075b0: ff 35 50 01 12 00 pushl 0x120150
1075b6: e8 25 44 00 00 call 10b9e0 <_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 ) {
1075bb: 83 c4 10 add $0x10,%esp
1075be: 89 c3 mov %eax,%ebx
1075c0: 85 c0 test %eax,%eax
1075c2: 75 28 jne 1075ec <malloc+0x6c>
if (rtems_malloc_sbrk_helpers)
1075c4: a1 14 25 12 00 mov 0x122514,%eax
1075c9: 85 c0 test %eax,%eax
1075cb: 74 10 je 1075dd <malloc+0x5d>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
1075cd: 83 ec 0c sub $0xc,%esp
1075d0: 56 push %esi
1075d1: ff 50 04 call *0x4(%eax)
1075d4: 89 c3 mov %eax,%ebx
if ( !return_this ) {
1075d6: 83 c4 10 add $0x10,%esp
1075d9: 85 c0 test %eax,%eax
1075db: 75 0f jne 1075ec <malloc+0x6c>
errno = ENOMEM;
1075dd: e8 72 9b 00 00 call 111154 <__errno>
1075e2: c7 00 0c 00 00 00 movl $0xc,(%eax)
return (void *) 0;
1075e8: 31 db xor %ebx,%ebx
1075ea: eb 25 jmp 107611 <malloc+0x91>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
1075ec: a1 18 25 12 00 mov 0x122518,%eax
1075f1: 85 c0 test %eax,%eax
1075f3: 74 09 je 1075fe <malloc+0x7e>
(*rtems_malloc_dirty_helper)( return_this, size );
1075f5: 52 push %edx
1075f6: 52 push %edx
1075f7: 56 push %esi
1075f8: 53 push %ebx
1075f9: ff d0 call *%eax
1075fb: 83 c4 10 add $0x10,%esp
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
1075fe: a1 10 25 12 00 mov 0x122510,%eax
107603: 85 c0 test %eax,%eax
107605: 74 0a je 107611 <malloc+0x91>
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
107607: 83 ec 0c sub $0xc,%esp
10760a: 53 push %ebx
10760b: ff 50 04 call *0x4(%eax)
10760e: 83 c4 10 add $0x10,%esp
return return_this;
}
107611: 89 d8 mov %ebx,%eax
107613: 8d 65 f8 lea -0x8(%ebp),%esp
107616: 5b pop %ebx
107617: 5e pop %esi
107618: c9 leave
107619: c3 ret
001078dc <malloc_sbrk_extend_and_allocate>:
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
1078dc: 55 push %ebp
1078dd: 89 e5 mov %esp,%ebp
1078df: 57 push %edi
1078e0: 56 push %esi
1078e1: 53 push %ebx
1078e2: 83 ec 0c sub $0xc,%esp
1078e5: 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;
1078e8: 8b 0d bc 51 12 00 mov 0x1251bc,%ecx
if ( sbrk_amount == 0 )
return (void *) 0;
1078ee: 31 f6 xor %esi,%esi
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
1078f0: 85 c9 test %ecx,%ecx
1078f2: 74 67 je 10795b <malloc_sbrk_extend_and_allocate+0x7f><== NEVER TAKEN
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
1078f4: 8d 1c 0f lea (%edi,%ecx,1),%ebx
1078f7: 89 d8 mov %ebx,%eax
1078f9: 31 d2 xor %edx,%edx
1078fb: f7 f1 div %ecx
1078fd: 89 c3 mov %eax,%ebx
1078ff: 0f af d9 imul %ecx,%ebx
starting_address = (void *) sbrk(the_size);
107902: 83 ec 0c sub $0xc,%esp
107905: 53 push %ebx
107906: e8 51 8b ff ff call 10045c <sbrk>
if ( starting_address == (void*) -1 )
10790b: 83 c4 10 add $0x10,%esp
10790e: 83 f8 ff cmp $0xffffffff,%eax
107911: 74 48 je 10795b <malloc_sbrk_extend_and_allocate+0x7f>
return (void *) 0;
if ( !_Protected_heap_Extend(
107913: 52 push %edx
107914: 53 push %ebx
107915: 50 push %eax
107916: ff 35 50 11 12 00 pushl 0x121150
10791c: e8 3b 44 00 00 call 10bd5c <_Protected_heap_Extend>
107921: 83 c4 10 add $0x10,%esp
107924: 84 c0 test %al,%al
107926: 75 18 jne 107940 <malloc_sbrk_extend_and_allocate+0x64>
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
107928: 83 ec 0c sub $0xc,%esp
10792b: f7 db neg %ebx
10792d: 53 push %ebx
10792e: e8 29 8b ff ff call 10045c <sbrk>
errno = ENOMEM;
107933: e8 d4 9d 00 00 call 11170c <__errno>
107938: c7 00 0c 00 00 00 movl $0xc,(%eax)
10793e: eb 18 jmp 107958 <malloc_sbrk_extend_and_allocate+0x7c>
return (void *) 0;
}
MSBUMP(space_available, the_size);
107940: 01 1d 90 51 12 00 add %ebx,0x125190
107946: 6a 00 push $0x0
107948: 6a 00 push $0x0
10794a: 57 push %edi
10794b: ff 35 50 11 12 00 pushl 0x121150
107951: e8 ce 43 00 00 call 10bd24 <_Protected_heap_Allocate_aligned_with_boundary>
107956: 89 c6 mov %eax,%esi
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
107958: 83 c4 10 add $0x10,%esp
}
10795b: 89 f0 mov %esi,%eax
10795d: 8d 65 f4 lea -0xc(%ebp),%esp
107960: 5b pop %ebx
107961: 5e pop %esi
107962: 5f pop %edi
107963: c9 leave
107964: c3 ret
0010fb72 <memfile_alloc_block>:
*/
int memfile_blocks_allocated = 0;
void *memfile_alloc_block(void)
{
10fb72: 55 push %ebp
10fb73: 89 e5 mov %esp,%ebp
10fb75: 83 ec 10 sub $0x10,%esp
void *memory;
memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);
10fb78: ff 35 8c 3d 12 00 pushl 0x123d8c
10fb7e: 6a 01 push $0x1
10fb80: e8 a3 75 ff ff call 107128 <calloc>
if ( memory )
10fb85: 83 c4 10 add $0x10,%esp
10fb88: 85 c0 test %eax,%eax
10fb8a: 74 06 je 10fb92 <memfile_alloc_block+0x20><== NEVER TAKEN
memfile_blocks_allocated++;
10fb8c: ff 05 9c 3e 12 00 incl 0x123e9c
return memory;
}
10fb92: c9 leave
10fb93: c3 ret
0010ff06 <memfile_free_blocks_in_table>:
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
10ff06: 55 push %ebp
10ff07: 89 e5 mov %esp,%ebp
10ff09: 57 push %edi
10ff0a: 56 push %esi
10ff0b: 53 push %ebx
10ff0c: 83 ec 0c sub $0xc,%esp
10ff0f: 8b 75 08 mov 0x8(%ebp),%esi
*/
#if defined(RTEMS_DEBUG)
assert( block_table );
#endif
if ( !block_table )
10ff12: 85 f6 test %esi,%esi
10ff14: 74 39 je 10ff4f <memfile_free_blocks_in_table+0x49><== NEVER TAKEN
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
10ff16: 8b 3e mov (%esi),%edi
for ( i=0 ; i<entries ; i++ ) {
10ff18: 31 db xor %ebx,%ebx
10ff1a: eb 1b jmp 10ff37 <memfile_free_blocks_in_table+0x31>
if ( b[i] ) {
10ff1c: 8b 04 9f mov (%edi,%ebx,4),%eax
10ff1f: 85 c0 test %eax,%eax
10ff21: 74 13 je 10ff36 <memfile_free_blocks_in_table+0x30>
memfile_free_block( b[i] );
10ff23: 83 ec 0c sub $0xc,%esp
10ff26: 50 push %eax
10ff27: e8 c1 ff ff ff call 10feed <memfile_free_block>
b[i] = 0;
10ff2c: c7 04 9f 00 00 00 00 movl $0x0,(%edi,%ebx,4)
10ff33: 83 c4 10 add $0x10,%esp
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
10ff36: 43 inc %ebx
10ff37: 3b 5d 0c cmp 0xc(%ebp),%ebx
10ff3a: 7c e0 jl 10ff1c <memfile_free_blocks_in_table+0x16>
/*
* Now that all the blocks in the block table are free, we can
* free the block table itself.
*/
memfile_free_block( *block_table );
10ff3c: 83 ec 0c sub $0xc,%esp
10ff3f: ff 36 pushl (%esi)
10ff41: e8 a7 ff ff ff call 10feed <memfile_free_block>
*block_table = 0;
10ff46: c7 06 00 00 00 00 movl $0x0,(%esi)
10ff4c: 83 c4 10 add $0x10,%esp
}
10ff4f: 8d 65 f4 lea -0xc(%ebp),%esp
10ff52: 5b pop %ebx
10ff53: 5e pop %esi
10ff54: 5f pop %edi
10ff55: c9 leave
10ff56: c3 ret
001103a3 <memfile_ftruncate>:
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
1103a3: 55 push %ebp
1103a4: 89 e5 mov %esp,%ebp
1103a6: 53 push %ebx
1103a7: 83 ec 14 sub $0x14,%esp
1103aa: 8b 4d 08 mov 0x8(%ebp),%ecx
1103ad: 8b 45 0c mov 0xc(%ebp),%eax
1103b0: 8b 55 10 mov 0x10(%ebp),%edx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
1103b3: 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 )
1103b6: 3b 53 54 cmp 0x54(%ebx),%edx
1103b9: 7c 15 jl 1103d0 <memfile_ftruncate+0x2d><== NEVER TAKEN
1103bb: 7f 05 jg 1103c2 <memfile_ftruncate+0x1f><== NEVER TAKEN
1103bd: 3b 43 50 cmp 0x50(%ebx),%eax
1103c0: 76 0e jbe 1103d0 <memfile_ftruncate+0x2d><== ALWAYS TAKEN
return IMFS_memfile_extend( the_jnode, length );
1103c2: 51 push %ecx <== NOT EXECUTED
1103c3: 52 push %edx <== NOT EXECUTED
1103c4: 50 push %eax <== NOT EXECUTED
1103c5: 53 push %ebx <== NOT EXECUTED
1103c6: e8 b7 fc ff ff call 110082 <IMFS_memfile_extend> <== NOT EXECUTED
1103cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1103ce: eb 24 jmp 1103f4 <memfile_ftruncate+0x51><== NOT EXECUTED
* 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;
1103d0: 89 43 50 mov %eax,0x50(%ebx)
1103d3: 89 53 54 mov %edx,0x54(%ebx)
iop->size = the_jnode->info.file.size;
1103d6: 89 41 04 mov %eax,0x4(%ecx)
1103d9: 89 51 08 mov %edx,0x8(%ecx)
IMFS_update_atime( the_jnode );
1103dc: 50 push %eax
1103dd: 50 push %eax
1103de: 6a 00 push $0x0
1103e0: 8d 45 f0 lea -0x10(%ebp),%eax
1103e3: 50 push %eax
1103e4: e8 73 6f ff ff call 10735c <gettimeofday>
1103e9: 8b 45 f0 mov -0x10(%ebp),%eax
1103ec: 89 43 40 mov %eax,0x40(%ebx)
return 0;
1103ef: 83 c4 10 add $0x10,%esp
1103f2: 31 c0 xor %eax,%eax
}
1103f4: 8b 5d fc mov -0x4(%ebp),%ebx
1103f7: c9 leave
1103f8: c3 ret
001103f9 <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
1103f9: 55 push %ebp
1103fa: 89 e5 mov %esp,%ebp
1103fc: 56 push %esi
1103fd: 53 push %ebx
1103fe: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
110401: 8b 73 18 mov 0x18(%ebx),%esi
if (the_jnode->type == IMFS_LINEAR_FILE) {
110404: 83 7e 4c 06 cmpl $0x6,0x4c(%esi)
110408: 75 1a jne 110424 <memfile_lseek+0x2b>
if (iop->offset > the_jnode->info.linearfile.size)
11040a: 8b 56 50 mov 0x50(%esi),%edx
11040d: 8b 46 54 mov 0x54(%esi),%eax
110410: 39 43 10 cmp %eax,0x10(%ebx)
110413: 7c 41 jl 110456 <memfile_lseek+0x5d> <== NEVER TAKEN
110415: 7f 05 jg 11041c <memfile_lseek+0x23> <== NEVER TAKEN
110417: 39 53 0c cmp %edx,0xc(%ebx)
11041a: 76 3a jbe 110456 <memfile_lseek+0x5d> <== ALWAYS TAKEN
iop->offset = the_jnode->info.linearfile.size;
11041c: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED
11041f: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED
110422: eb 32 jmp 110456 <memfile_lseek+0x5d> <== NOT EXECUTED
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
110424: 50 push %eax
110425: ff 73 10 pushl 0x10(%ebx)
110428: ff 73 0c pushl 0xc(%ebx)
11042b: 56 push %esi
11042c: e8 51 fc ff ff call 110082 <IMFS_memfile_extend>
110431: 83 c4 10 add $0x10,%esp
110434: 85 c0 test %eax,%eax
110436: 74 12 je 11044a <memfile_lseek+0x51> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOSPC );
110438: e8 17 0d 00 00 call 111154 <__errno> <== NOT EXECUTED
11043d: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED
110443: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
110446: 89 c2 mov %eax,%edx <== NOT EXECUTED
110448: eb 12 jmp 11045c <memfile_lseek+0x63> <== NOT EXECUTED
iop->size = the_jnode->info.file.size;
11044a: 8b 46 50 mov 0x50(%esi),%eax
11044d: 8b 56 54 mov 0x54(%esi),%edx
110450: 89 43 04 mov %eax,0x4(%ebx)
110453: 89 53 08 mov %edx,0x8(%ebx)
}
return iop->offset;
110456: 8b 43 0c mov 0xc(%ebx),%eax
110459: 8b 53 10 mov 0x10(%ebx),%edx
}
11045c: 8d 65 f8 lea -0x8(%ebp),%esp
11045f: 5b pop %ebx
110460: 5e pop %esi
110461: c9 leave
110462: c3 ret
00110314 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
110314: 55 push %ebp
110315: 89 e5 mov %esp,%ebp
110317: 56 push %esi
110318: 53 push %ebx
110319: 8b 75 08 mov 0x8(%ebp),%esi
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
11031c: 8b 5e 18 mov 0x18(%esi),%ebx
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
11031f: f7 46 14 04 02 00 00 testl $0x204,0x14(%esi)
110326: 74 54 je 11037c <memfile_open+0x68>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
110328: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx)
11032c: 75 4e jne 11037c <memfile_open+0x68> <== ALWAYS TAKEN
uint32_t count = the_jnode->info.linearfile.size;
11032e: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
110331: 8b 53 58 mov 0x58(%ebx),%edx <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
110334: c7 43 4c 05 00 00 00 movl $0x5,0x4c(%ebx) <== NOT EXECUTED
the_jnode->info.file.size = 0;
11033b: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED
110342: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
110349: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
110350: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
110357: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED
if ((count != 0)
11035e: 85 c0 test %eax,%eax <== NOT EXECUTED
110360: 74 1a je 11037c <memfile_open+0x68> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
110362: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
110365: 50 push %eax <== NOT EXECUTED
110366: 52 push %edx <== NOT EXECUTED
110367: 6a 00 push $0x0 <== NOT EXECUTED
110369: 6a 00 push $0x0 <== NOT EXECUTED
11036b: 53 push %ebx <== NOT EXECUTED
11036c: e8 03 fe ff ff call 110174 <IMFS_memfile_write> <== NOT EXECUTED
110371: 89 c2 mov %eax,%edx <== NOT EXECUTED
110373: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
return -1;
110376: 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))
110379: 42 inc %edx <== NOT EXECUTED
11037a: 74 20 je 11039c <memfile_open+0x88> <== NOT EXECUTED
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
11037c: f6 46 15 02 testb $0x2,0x15(%esi)
110380: 74 0c je 11038e <memfile_open+0x7a>
iop->offset = the_jnode->info.file.size;
110382: 8b 43 50 mov 0x50(%ebx),%eax
110385: 8b 53 54 mov 0x54(%ebx),%edx
110388: 89 46 0c mov %eax,0xc(%esi)
11038b: 89 56 10 mov %edx,0x10(%esi)
iop->size = the_jnode->info.file.size;
11038e: 8b 43 50 mov 0x50(%ebx),%eax
110391: 8b 53 54 mov 0x54(%ebx),%edx
110394: 89 46 04 mov %eax,0x4(%esi)
110397: 89 56 08 mov %edx,0x8(%esi)
return 0;
11039a: 31 c0 xor %eax,%eax
}
11039c: 8d 65 f8 lea -0x8(%ebp),%esp
11039f: 5b pop %ebx
1103a0: 5e pop %esi
1103a1: c9 leave
1103a2: c3 ret
00107638 <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
107638: 55 push %ebp
107639: 89 e5 mov %esp,%ebp
10763b: 57 push %edi
10763c: 56 push %esi
10763d: 53 push %ebx
10763e: 83 ec 3c sub $0x3c,%esp
107641: 8b 7d 08 mov 0x8(%ebp),%edi
107644: 8b 75 0c mov 0xc(%ebp),%esi
107647: 8b 55 10 mov 0x10(%ebp),%edx
10764a: 8b 4d 14 mov 0x14(%ebp),%ecx
rtems_filesystem_location_info_t temp_loc;
int i;
const char *name_start;
int result;
if ( !(mode & (S_IFREG|S_IFCHR|S_IFBLK|S_IFIFO) ) )
10764d: f7 c6 00 f0 00 00 test $0xf000,%esi
107653: 75 10 jne 107665 <mknod+0x2d> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
107655: e8 fa 9a 00 00 call 111154 <__errno> <== NOT EXECUTED
10765a: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
107660: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
107663: eb 5b jmp 1076c0 <mknod+0x88> <== NOT EXECUTED
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
107665: 50 push %eax
107666: 8d 5d cc lea -0x34(%ebp),%ebx
107669: 53 push %ebx
10766a: 8d 45 e4 lea -0x1c(%ebp),%eax
10766d: 50 push %eax
10766e: 57 push %edi
10766f: 89 55 c4 mov %edx,-0x3c(%ebp)
107672: 89 4d c0 mov %ecx,-0x40(%ebp)
107675: e8 de 08 00 00 call 107f58 <rtems_filesystem_get_start_loc>
result = (*temp_loc.ops->evalformake_h)(
10767a: 83 c4 0c add $0xc,%esp
10767d: 8d 45 e0 lea -0x20(%ebp),%eax
107680: 50 push %eax
107681: 53 push %ebx
107682: 03 7d e4 add -0x1c(%ebp),%edi
107685: 57 push %edi
107686: 8b 45 d8 mov -0x28(%ebp),%eax
107689: ff 50 04 call *0x4(%eax)
10768c: 89 c7 mov %eax,%edi
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
10768e: 83 c4 10 add $0x10,%esp
return -1;
107691: 83 c8 ff or $0xffffffff,%eax
result = (*temp_loc.ops->evalformake_h)(
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
107694: 85 ff test %edi,%edi
107696: 8b 55 c4 mov -0x3c(%ebp),%edx
107699: 8b 4d c0 mov -0x40(%ebp),%ecx
10769c: 75 22 jne 1076c0 <mknod+0x88>
return -1;
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
10769e: 83 ec 0c sub $0xc,%esp
1076a1: 53 push %ebx
1076a2: 51 push %ecx
1076a3: 52 push %edx
1076a4: 56 push %esi
1076a5: ff 75 e0 pushl -0x20(%ebp)
1076a8: 8b 45 d8 mov -0x28(%ebp),%eax
1076ab: ff 50 14 call *0x14(%eax)
rtems_filesystem_freenode( &temp_loc );
1076ae: 83 c4 14 add $0x14,%esp
1076b1: 53 push %ebx
1076b2: 89 45 c4 mov %eax,-0x3c(%ebp)
1076b5: e8 16 fc ff ff call 1072d0 <rtems_filesystem_freenode>
return result;
1076ba: 83 c4 10 add $0x10,%esp
1076bd: 8b 45 c4 mov -0x3c(%ebp),%eax
}
1076c0: 8d 65 f4 lea -0xc(%ebp),%esp
1076c3: 5b pop %ebx
1076c4: 5e pop %esi
1076c5: 5f pop %edi
1076c6: c9 leave
1076c7: c3 ret
00107751 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
107751: 55 push %ebp
107752: 89 e5 mov %esp,%ebp
107754: 57 push %edi
107755: 56 push %esi
107756: 53 push %ebx
107757: 83 ec 4c sub $0x4c,%esp
10775a: 8b 75 08 mov 0x8(%ebp),%esi
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
10775d: 83 7d 14 01 cmpl $0x1,0x14(%ebp)
107761: 77 15 ja 107778 <mount+0x27>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
107763: 83 ec 0c sub $0xc,%esp
107766: ff 75 10 pushl 0x10(%ebp)
107769: e8 bd 6b 00 00 call 10e32b <rtems_filesystem_get_mount_handler>
10776e: 89 45 b4 mov %eax,-0x4c(%ebp)
if ( !mount_h )
107771: 83 c4 10 add $0x10,%esp
107774: 85 c0 test %eax,%eax
107776: 75 10 jne 107788 <mount+0x37>
rtems_set_errno_and_return_minus_one( EINVAL );
107778: e8 d7 99 00 00 call 111154 <__errno>
10777d: c7 00 16 00 00 00 movl $0x16,(%eax)
107783: e9 dc 00 00 00 jmp 107864 <mount+0x113>
{
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;
107788: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10778c: 0f 95 45 bf setne -0x41(%ebp)
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
107790: 8b 45 0c mov 0xc(%ebp),%eax
107793: 89 45 b8 mov %eax,-0x48(%ebp)
107796: 80 7d bf 00 cmpb $0x0,-0x41(%ebp)
10779a: 75 07 jne 1077a3 <mount+0x52>
10779c: c7 45 b8 90 e8 11 00 movl $0x11e890,-0x48(%ebp)
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
1077a3: 83 ca ff or $0xffffffff,%edx
1077a6: 31 c0 xor %eax,%eax
1077a8: 89 d1 mov %edx,%ecx
1077aa: 8b 7d 10 mov 0x10(%ebp),%edi
1077ad: f2 ae repnz scas %es:(%edi),%al
1077af: f7 d1 not %ecx
1077b1: 89 4d c0 mov %ecx,-0x40(%ebp)
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
1077b4: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
1077bb: 85 f6 test %esi,%esi
1077bd: 74 0b je 1077ca <mount+0x79>
1077bf: 89 d1 mov %edx,%ecx
1077c1: 89 f7 mov %esi,%edi
1077c3: f2 ae repnz scas %es:(%edi),%al
1077c5: f7 d1 not %ecx
1077c7: 89 4d c4 mov %ecx,-0x3c(%ebp)
size_t target_length = strlen( target );
1077ca: 31 c0 xor %eax,%eax
1077cc: 83 c9 ff or $0xffffffff,%ecx
1077cf: 8b 7d b8 mov -0x48(%ebp),%edi
1077d2: f2 ae repnz scas %es:(%edi),%al
1077d4: f7 d1 not %ecx
1077d6: 49 dec %ecx
1077d7: 89 4d b0 mov %ecx,-0x50(%ebp)
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_length + 1;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
1077da: 53 push %ebx
1077db: 53 push %ebx
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_length = strlen( target );
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_length + 1;
1077dc: 8b 55 c0 mov -0x40(%ebp),%edx
1077df: 8d 44 11 75 lea 0x75(%ecx,%edx,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_length = strlen( target );
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
1077e3: 03 45 c4 add -0x3c(%ebp),%eax
+ filesystemtype_size + source_size + target_length + 1;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
1077e6: 50 push %eax
1077e7: 6a 01 push $0x1
1077e9: e8 3a f9 ff ff call 107128 <calloc>
1077ee: 89 c3 mov %eax,%ebx
if ( mt_entry != NULL ) {
1077f0: 83 c4 10 add $0x10,%esp
1077f3: 85 c0 test %eax,%eax
1077f5: 74 62 je 107859 <mount+0x108> <== NEVER TAKEN
char *str = (char *) mt_entry + sizeof( *mt_entry );
1077f7: 8d 78 74 lea 0x74(%eax),%edi
strcpy( str, filesystemtype );
1077fa: 51 push %ecx
1077fb: 51 push %ecx
1077fc: ff 75 10 pushl 0x10(%ebp)
1077ff: 57 push %edi
107800: e8 6b a5 00 00 call 111d70 <strcpy>
mt_entry->type = str;
107805: 89 7b 6c mov %edi,0x6c(%ebx)
str += filesystemtype_size;
107808: 03 7d c0 add -0x40(%ebp),%edi
if ( source_or_null != NULL ) {
10780b: 83 c4 10 add $0x10,%esp
10780e: 85 f6 test %esi,%esi
107810: 74 12 je 107824 <mount+0xd3>
strcpy( str, source_or_null );
107812: 52 push %edx
107813: 52 push %edx
107814: 56 push %esi
107815: 57 push %edi
107816: e8 55 a5 00 00 call 111d70 <strcpy>
mt_entry->dev = str;
10781b: 89 7b 70 mov %edi,0x70(%ebx)
str += source_size;
10781e: 03 7d c4 add -0x3c(%ebp),%edi
107821: 83 c4 10 add $0x10,%esp
}
strcpy( str, target );
107824: 50 push %eax
107825: 50 push %eax
107826: ff 75 b8 pushl -0x48(%ebp)
107829: 57 push %edi
10782a: e8 41 a5 00 00 call 111d70 <strcpy>
mt_entry->target = str;
10782f: 89 7b 68 mov %edi,0x68(%ebx)
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
107832: 89 5b 2c mov %ebx,0x2c(%ebx)
mt_entry->options = options;
107835: 8b 4d 14 mov 0x14(%ebp),%ecx
107838: 89 4b 30 mov %ecx,0x30(%ebx)
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
10783b: 8d 7b 38 lea 0x38(%ebx),%edi
10783e: be d0 e8 11 00 mov $0x11e8d0,%esi
107843: b9 0c 00 00 00 mov $0xc,%ecx
107848: 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 ) {
10784a: 83 c4 10 add $0x10,%esp
10784d: 80 7d bf 00 cmpb $0x0,-0x41(%ebp)
107851: 0f 84 a3 00 00 00 je 1078fa <mount+0x1a9>
107857: eb 13 jmp 10786c <mount+0x11b>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
107859: e8 f6 98 00 00 call 111154 <__errno> <== NOT EXECUTED
10785e: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
107864: 83 c8 ff or $0xffffffff,%eax
107867: e9 26 01 00 00 jmp 107992 <mount+0x241>
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
10786c: 83 ec 0c sub $0xc,%esp
10786f: 6a 01 push $0x1
107871: 8d 75 d4 lea -0x2c(%ebp),%esi
107874: 56 push %esi
107875: 6a 07 push $0x7
107877: ff 75 b0 pushl -0x50(%ebp)
10787a: ff 75 0c pushl 0xc(%ebp)
10787d: e8 67 f9 ff ff call 1071e9 <rtems_filesystem_evaluate_path>
107882: 83 c4 20 add $0x20,%esp
107885: 40 inc %eax
107886: 0f 84 df 00 00 00 je 10796b <mount+0x21a> <== NEVER TAKEN
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
10788c: 83 ec 0c sub $0xc,%esp
10788f: 56 push %esi
107890: 8b 45 e0 mov -0x20(%ebp),%eax
107893: ff 50 10 call *0x10(%eax)
107896: 83 c4 10 add $0x10,%esp
107899: 48 dec %eax
10789a: 74 10 je 1078ac <mount+0x15b>
errno = ENOTDIR;
10789c: e8 b3 98 00 00 call 111154 <__errno>
1078a1: c7 00 14 00 00 00 movl $0x14,(%eax)
goto cleanup_and_bail;
1078a7: e9 c1 00 00 00 jmp 10796d <mount+0x21c>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
1078ac: 57 push %edi
1078ad: 57 push %edi
1078ae: ff 75 d4 pushl -0x2c(%ebp)
1078b1: 68 c8 76 10 00 push $0x1076c8
1078b6: e8 4e fe ff ff call 107709 <rtems_filesystem_mount_iterate>
1078bb: 83 c4 10 add $0x10,%esp
1078be: 84 c0 test %al,%al
1078c0: 74 10 je 1078d2 <mount+0x181>
errno = EBUSY;
1078c2: e8 8d 98 00 00 call 111154 <__errno>
1078c7: c7 00 10 00 00 00 movl $0x10,(%eax)
goto cleanup_and_bail;
1078cd: e9 9b 00 00 00 jmp 10796d <mount+0x21c>
* 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;
1078d2: 8b 45 d4 mov -0x2c(%ebp),%eax
1078d5: 89 43 08 mov %eax,0x8(%ebx)
mt_entry->mt_point_node.handlers = loc.handlers;
1078d8: 8b 45 dc mov -0x24(%ebp),%eax
1078db: 89 43 10 mov %eax,0x10(%ebx)
mt_entry->mt_point_node.ops = loc.ops;
1078de: 8b 45 e0 mov -0x20(%ebp),%eax
1078e1: 89 43 14 mov %eax,0x14(%ebx)
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
1078e4: 8b 55 e4 mov -0x1c(%ebp),%edx
1078e7: 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 ) ) {
1078ea: 83 ec 0c sub $0xc,%esp
1078ed: 53 push %ebx
1078ee: ff 50 20 call *0x20(%eax)
1078f1: 83 c4 10 add $0x10,%esp
1078f4: 85 c0 test %eax,%eax
1078f6: 74 1d je 107915 <mount+0x1c4> <== ALWAYS TAKEN
1078f8: eb 73 jmp 10796d <mount+0x21c> <== 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;
1078fa: 31 f6 xor %esi,%esi
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
1078fc: 81 3d 34 1f 12 00 38 cmpl $0x121f38,0x121f34
107903: 1f 12 00
107906: 74 0d je 107915 <mount+0x1c4> <== ALWAYS TAKEN
errno = EINVAL;
107908: e8 47 98 00 00 call 111154 <__errno> <== NOT EXECUTED
10790d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
goto cleanup_and_bail;
107913: eb 58 jmp 10796d <mount+0x21c> <== 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 ) ) {
107915: 51 push %ecx
107916: 51 push %ecx
107917: ff 75 18 pushl 0x18(%ebp)
10791a: 53 push %ebx
10791b: ff 55 b4 call *-0x4c(%ebp)
10791e: 83 c4 10 add $0x10,%esp
107921: 85 c0 test %eax,%eax
107923: 74 0f je 107934 <mount+0x1e3> <== ALWAYS TAKEN
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
107925: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107928: 53 push %ebx <== NOT EXECUTED
107929: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
10792c: ff 50 28 call *0x28(%eax) <== NOT EXECUTED
goto cleanup_and_bail;
10792f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107932: eb 39 jmp 10796d <mount+0x21c> <== NOT EXECUTED
}
/*
* Add the mount table entry to the mount table chain
*/
rtems_libio_lock();
107934: e8 a0 fd ff ff call 1076d9 <rtems_libio_lock>
107939: 52 push %edx
10793a: 52 push %edx
10793b: 53 push %ebx
10793c: 68 34 1f 12 00 push $0x121f34
107941: e8 ee 30 00 00 call 10aa34 <_Chain_Append>
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
107946: e8 a8 fd ff ff call 1076f3 <rtems_libio_unlock>
if ( !has_target )
10794b: 83 c4 10 add $0x10,%esp
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
10794e: 31 c0 xor %eax,%eax
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
107950: 80 7d bf 00 cmpb $0x0,-0x41(%ebp)
107954: 75 3c jne 107992 <mount+0x241>
rtems_filesystem_root = mt_entry->mt_fs_root;
107956: 8b 3d 54 1f 12 00 mov 0x121f54,%edi
10795c: 83 c7 18 add $0x18,%edi
10795f: 8d 73 1c lea 0x1c(%ebx),%esi
107962: b9 05 00 00 00 mov $0x5,%ecx
107967: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
107969: eb 27 jmp 107992 <mount+0x241>
)
{
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;
10796b: 31 f6 xor %esi,%esi <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
10796d: 83 ec 0c sub $0xc,%esp
107970: 53 push %ebx
107971: e8 6e f9 ff ff call 1072e4 <free>
if ( loc_to_free )
107976: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( loc_to_free );
return -1;
107979: 83 c8 ff or $0xffffffff,%eax
cleanup_and_bail:
free( mt_entry );
if ( loc_to_free )
10797c: 85 f6 test %esi,%esi
10797e: 74 12 je 107992 <mount+0x241> <== NEVER TAKEN
rtems_filesystem_freenode( loc_to_free );
107980: 83 ec 0c sub $0xc,%esp
107983: 56 push %esi
107984: 89 45 ac mov %eax,-0x54(%ebp)
107987: e8 44 f9 ff ff call 1072d0 <rtems_filesystem_freenode>
10798c: 83 c4 10 add $0x10,%esp
10798f: 8b 45 ac mov -0x54(%ebp),%eax
return -1;
}
107992: 8d 65 f4 lea -0xc(%ebp),%esp
107995: 5b pop %ebx
107996: 5e pop %esi
107997: 5f pop %edi
107998: c9 leave
107999: c3 ret
00107cc8 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
107cc8: 55 push %ebp
107cc9: 89 e5 mov %esp,%ebp
107ccb: 57 push %edi
107ccc: 56 push %esi
107ccd: 53 push %ebx
107cce: 83 ec 1c sub $0x1c,%esp
107cd1: 8b 4d 08 mov 0x8(%ebp),%ecx
107cd4: 8b 5d 0c mov 0xc(%ebp),%ebx
107cd7: 8b 75 10 mov 0x10(%ebp),%esi
107cda: 8b 7d 14 mov 0x14(%ebp),%edi
107cdd: 8b 55 18 mov 0x18(%ebp),%edx
int rv = -1;
if (target != NULL) {
107ce0: 85 db test %ebx,%ebx
107ce2: 74 3b je 107d1f <mount_and_make_target_path+0x57>
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
107ce4: 50 push %eax
107ce5: 50 push %eax
107ce6: 68 ff 01 00 00 push $0x1ff
107ceb: 53 push %ebx
107cec: 89 55 e0 mov %edx,-0x20(%ebp)
107cef: 89 4d e4 mov %ecx,-0x1c(%ebp)
107cf2: e8 d1 08 00 00 call 1085c8 <rtems_mkdir>
if (rv == 0) {
107cf7: 83 c4 10 add $0x10,%esp
107cfa: 85 c0 test %eax,%eax
107cfc: 8b 55 e0 mov -0x20(%ebp),%edx
107cff: 8b 4d e4 mov -0x1c(%ebp),%ecx
107d02: 75 29 jne 107d2d <mount_and_make_target_path+0x65><== NEVER TAKEN
rv = mount(
107d04: 89 55 18 mov %edx,0x18(%ebp)
107d07: 89 7d 14 mov %edi,0x14(%ebp)
107d0a: 89 75 10 mov %esi,0x10(%ebp)
107d0d: 89 5d 0c mov %ebx,0xc(%ebp)
107d10: 89 4d 08 mov %ecx,0x8(%ebp)
} else {
errno = EINVAL;
}
return rv;
}
107d13: 8d 65 f4 lea -0xc(%ebp),%esp
107d16: 5b pop %ebx
107d17: 5e pop %esi
107d18: 5f pop %edi
107d19: c9 leave
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
107d1a: e9 a2 00 00 00 jmp 107dc1 <mount>
options,
data
);
}
} else {
errno = EINVAL;
107d1f: e8 80 9a 00 00 call 1117a4 <__errno>
107d24: c7 00 16 00 00 00 movl $0x16,(%eax)
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
107d2a: 83 c8 ff or $0xffffffff,%eax
} else {
errno = EINVAL;
}
return rv;
}
107d2d: 8d 65 f4 lea -0xc(%ebp),%esp
107d30: 5b pop %ebx
107d31: 5e pop %esi
107d32: 5f pop %edi
107d33: c9 leave
107d34: c3 ret
001079f5 <newlib_create_hook>:
*/
bool newlib_create_hook(
rtems_tcb *current_task __attribute__((unused)),
rtems_tcb *creating_task
)
{
1079f5: 55 push %ebp
1079f6: 89 e5 mov %esp,%ebp
1079f8: 57 push %edi
1079f9: 56 push %esi
1079fa: 53 push %ebx
1079fb: 83 ec 1c sub $0x1c,%esp
struct _reent *ptr;
if (_Thread_libc_reent == 0)
1079fe: 83 3d 6c 42 12 00 00 cmpl $0x0,0x12426c
107a05: 75 14 jne 107a1b <newlib_create_hook+0x26>
{
_REENT = _global_impure_ptr;
107a07: a1 40 f3 11 00 mov 0x11f340,%eax
107a0c: a3 20 20 12 00 mov %eax,0x122020
RTEMS_INLINE_ROUTINE void _Thread_Set_libc_reent (
struct _reent **libc_reent
)
{
_Thread_libc_reent = libc_reent;
107a11: c7 05 6c 42 12 00 20 movl $0x122020,0x12426c
107a18: 20 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));
107a1b: 83 ec 0c sub $0xc,%esp
107a1e: 68 24 04 00 00 push $0x424
107a23: e8 16 55 00 00 call 10cf3e <_Workspace_Allocate>
107a28: 89 c2 mov %eax,%edx
#endif
if (ptr) {
107a2a: 83 c4 10 add $0x10,%esp
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
creating_task->libc_reent = ptr;
return TRUE;
}
return FALSE;
107a2d: 31 c0 xor %eax,%eax
* hooks run with thread dispatching disabled.
*/
ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent));
#endif
if (ptr) {
107a2f: 85 d2 test %edx,%edx
107a31: 0f 84 28 02 00 00 je 107c5f <newlib_create_hook+0x26a><== NEVER TAKEN
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
107a37: c7 02 00 00 00 00 movl $0x0,(%edx)
107a3d: 8d b2 ec 02 00 00 lea 0x2ec(%edx),%esi
107a43: 89 72 04 mov %esi,0x4(%edx)
107a46: 8d 8a 54 03 00 00 lea 0x354(%edx),%ecx
107a4c: 89 4a 08 mov %ecx,0x8(%edx)
107a4f: 8d 8a bc 03 00 00 lea 0x3bc(%edx),%ecx
107a55: 89 4a 0c mov %ecx,0xc(%edx)
107a58: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
107a5f: 8d 4a 14 lea 0x14(%edx),%ecx
107a62: bb 19 00 00 00 mov $0x19,%ebx
107a67: 89 cf mov %ecx,%edi
107a69: 89 d9 mov %ebx,%ecx
107a6b: f3 aa rep stos %al,%es:(%edi)
107a6d: 89 cb mov %ecx,%ebx
107a6f: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx)
107a76: c7 42 34 1e e6 11 00 movl $0x11e61e,0x34(%edx)
107a7d: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx)
107a84: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx)
107a8b: c7 42 40 00 00 00 00 movl $0x0,0x40(%edx)
107a92: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx)
107a99: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx)
107aa0: c7 42 4c 00 00 00 00 movl $0x0,0x4c(%edx)
107aa7: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx)
107aae: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx)
107ab5: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx)
107abc: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx)
107ac3: c6 42 60 00 movb $0x0,0x60(%edx)
107ac7: 8d 42 7c lea 0x7c(%edx),%eax
107aca: 89 45 e4 mov %eax,-0x1c(%ebp)
107acd: b1 09 mov $0x9,%cl
107acf: 89 c7 mov %eax,%edi
107ad1: 89 d8 mov %ebx,%eax
107ad3: f3 ab rep stos %eax,%es:(%edi)
107ad5: c7 82 a0 00 00 00 00 movl $0x0,0xa0(%edx)
107adc: 00 00 00
107adf: c7 82 a4 00 00 00 01 movl $0x1,0xa4(%edx)
107ae6: 00 00 00
107ae9: c7 82 a8 00 00 00 00 movl $0x0,0xa8(%edx)
107af0: 00 00 00
107af3: 66 c7 82 ac 00 00 00 movw $0x330e,0xac(%edx)
107afa: 0e 33
107afc: 66 c7 82 ae 00 00 00 movw $0xabcd,0xae(%edx)
107b03: cd ab
107b05: 66 c7 82 b0 00 00 00 movw $0x1234,0xb0(%edx)
107b0c: 34 12
107b0e: 66 c7 82 b2 00 00 00 movw $0xe66d,0xb2(%edx)
107b15: 6d e6
107b17: 66 c7 82 b4 00 00 00 movw $0xdeec,0xb4(%edx)
107b1e: ec de
107b20: 66 c7 82 b6 00 00 00 movw $0x5,0xb6(%edx)
107b27: 05 00
107b29: 66 c7 82 b8 00 00 00 movw $0xb,0xb8(%edx)
107b30: 0b 00
107b32: c7 82 bc 00 00 00 00 movl $0x0,0xbc(%edx)
107b39: 00 00 00
107b3c: c7 82 c0 00 00 00 00 movl $0x0,0xc0(%edx)
107b43: 00 00 00
107b46: c7 82 c4 00 00 00 00 movl $0x0,0xc4(%edx)
107b4d: 00 00 00
107b50: c7 82 c8 00 00 00 00 movl $0x0,0xc8(%edx)
107b57: 00 00 00
107b5a: c7 82 cc 00 00 00 00 movl $0x0,0xcc(%edx)
107b61: 00 00 00
107b64: c7 82 d0 00 00 00 00 movl $0x0,0xd0(%edx)
107b6b: 00 00 00
107b6e: c7 82 f8 00 00 00 00 movl $0x0,0xf8(%edx)
107b75: 00 00 00
107b78: c7 82 fc 00 00 00 00 movl $0x0,0xfc(%edx)
107b7f: 00 00 00
107b82: c7 82 00 01 00 00 00 movl $0x0,0x100(%edx)
107b89: 00 00 00
107b8c: c7 82 04 01 00 00 00 movl $0x0,0x104(%edx)
107b93: 00 00 00
107b96: c7 82 08 01 00 00 00 movl $0x0,0x108(%edx)
107b9d: 00 00 00
107ba0: c7 82 0c 01 00 00 00 movl $0x0,0x10c(%edx)
107ba7: 00 00 00
107baa: c7 82 10 01 00 00 00 movl $0x0,0x110(%edx)
107bb1: 00 00 00
107bb4: c7 82 14 01 00 00 00 movl $0x0,0x114(%edx)
107bbb: 00 00 00
107bbe: c7 82 18 01 00 00 00 movl $0x0,0x118(%edx)
107bc5: 00 00 00
107bc8: c7 82 1c 01 00 00 00 movl $0x0,0x11c(%edx)
107bcf: 00 00 00
107bd2: c6 82 d4 00 00 00 00 movb $0x0,0xd4(%edx)
107bd9: c6 82 dc 00 00 00 00 movb $0x0,0xdc(%edx)
107be0: c7 82 f4 00 00 00 00 movl $0x0,0xf4(%edx)
107be7: 00 00 00
107bea: c7 82 48 01 00 00 00 movl $0x0,0x148(%edx)
107bf1: 00 00 00
107bf4: c7 82 4c 01 00 00 00 movl $0x0,0x14c(%edx)
107bfb: 00 00 00
107bfe: c7 82 50 01 00 00 00 movl $0x0,0x150(%edx)
107c05: 00 00 00
107c08: c7 82 54 01 00 00 00 movl $0x0,0x154(%edx)
107c0f: 00 00 00
107c12: c7 82 d4 02 00 00 00 movl $0x0,0x2d4(%edx)
107c19: 00 00 00
107c1c: c7 82 d4 01 00 00 00 movl $0x0,0x1d4(%edx)
107c23: 00 00 00
107c26: c7 82 dc 02 00 00 00 movl $0x0,0x2dc(%edx)
107c2d: 00 00 00
107c30: c7 82 e0 02 00 00 00 movl $0x0,0x2e0(%edx)
107c37: 00 00 00
107c3a: c7 82 e4 02 00 00 00 movl $0x0,0x2e4(%edx)
107c41: 00 00 00
107c44: c7 82 e8 02 00 00 00 movl $0x0,0x2e8(%edx)
107c4b: 00 00 00
107c4e: b1 4e mov $0x4e,%cl
107c50: 89 f7 mov %esi,%edi
107c52: f3 ab rep stos %eax,%es:(%edi)
creating_task->libc_reent = ptr;
107c54: 8b 45 0c mov 0xc(%ebp),%eax
107c57: 89 90 f0 00 00 00 mov %edx,0xf0(%eax)
return TRUE;
107c5d: b0 01 mov $0x1,%al
}
return FALSE;
}
107c5f: 8d 65 f4 lea -0xc(%ebp),%esp
107c62: 5b pop %ebx
107c63: 5e pop %esi
107c64: 5f pop %edi
107c65: c9 leave
107c66: c3 ret
00107c67 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
107c67: 55 push %ebp
107c68: 89 e5 mov %esp,%ebp
107c6a: 57 push %edi
107c6b: 56 push %esi
107c6c: 53 push %ebx
107c6d: 83 ec 0c sub $0xc,%esp
107c70: 8b 7d 08 mov 0x8(%ebp),%edi
107c73: 8b 75 0c mov 0xc(%ebp),%esi
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
107c76: 39 f7 cmp %esi,%edi
107c78: 75 08 jne 107c82 <newlib_delete_hook+0x1b>
ptr = _REENT;
107c7a: 8b 1d 20 20 12 00 mov 0x122020,%ebx
107c80: eb 06 jmp 107c88 <newlib_delete_hook+0x21>
} else {
ptr = deleted_task->libc_reent;
107c82: 8b 9e f0 00 00 00 mov 0xf0(%esi),%ebx
}
if (ptr && ptr != _global_impure_ptr) {
107c88: 85 db test %ebx,%ebx
107c8a: 74 20 je 107cac <newlib_delete_hook+0x45><== NEVER TAKEN
107c8c: 3b 1d 40 f3 11 00 cmp 0x11f340,%ebx
107c92: 74 18 je 107cac <newlib_delete_hook+0x45>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
107c94: 50 push %eax
107c95: 50 push %eax
107c96: 68 a4 79 10 00 push $0x1079a4
107c9b: 53 push %ebx
107c9c: e8 9b 9c 00 00 call 11193c <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
107ca1: 89 1c 24 mov %ebx,(%esp)
107ca4: e8 ae 52 00 00 call 10cf57 <_Workspace_Free>
107ca9: 83 c4 10 add $0x10,%esp
#endif
}
deleted_task->libc_reent = NULL;
107cac: c7 86 f0 00 00 00 00 movl $0x0,0xf0(%esi)
107cb3: 00 00 00
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
107cb6: 39 f7 cmp %esi,%edi
107cb8: 75 0a jne 107cc4 <newlib_delete_hook+0x5d>
_REENT = 0;
107cba: c7 05 20 20 12 00 00 movl $0x0,0x122020
107cc1: 00 00 00
}
}
107cc4: 8d 65 f4 lea -0xc(%ebp),%esp
107cc7: 5b pop %ebx
107cc8: 5e pop %esi
107cc9: 5f pop %edi
107cca: c9 leave
107ccb: c3 ret
001079a4 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
1079a4: 55 push %ebp
1079a5: 89 e5 mov %esp,%ebp
1079a7: 53 push %ebx
1079a8: 83 ec 10 sub $0x10,%esp
1079ab: 8b 5d 08 mov 0x8(%ebp),%ebx
switch ( fileno(fp) ) {
1079ae: 53 push %ebx
1079af: e8 74 9b 00 00 call 111528 <fileno>
1079b4: 83 c4 10 add $0x10,%esp
1079b7: 83 f8 02 cmp $0x2,%eax
1079ba: 77 26 ja 1079e2 <newlib_free_buffers+0x3e><== NEVER TAKEN
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
1079bc: f6 43 0c 80 testb $0x80,0xc(%ebx)
1079c0: 74 2c je 1079ee <newlib_free_buffers+0x4a><== ALWAYS TAKEN
free( fp->_bf._base );
1079c2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1079c5: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1079c8: e8 17 f9 ff ff call 1072e4 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
1079cd: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
1079d3: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED
1079d9: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED
1079e0: eb 09 jmp 1079eb <newlib_free_buffers+0x47><== NOT EXECUTED
}
break;
default:
fclose(fp);
1079e2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1079e5: 53 push %ebx <== NOT EXECUTED
1079e6: e8 c1 98 00 00 call 1112ac <fclose> <== NOT EXECUTED
1079eb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return 0;
}
1079ee: 31 c0 xor %eax,%eax
1079f0: 8b 5d fc mov -0x4(%ebp),%ebx
1079f3: c9 leave
1079f4: c3 ret
00107598 <null_initialize>:
rtems_device_driver null_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *pargp __attribute__((unused))
)
{
107598: 55 push %ebp
107599: 89 e5 mov %esp,%ebp
10759b: 53 push %ebx
10759c: 83 ec 04 sub $0x4,%esp
10759f: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_device_driver status;
if ( !initialized ) {
1075a2: 80 3d 24 6e 12 00 00 cmpb $0x0,0x126e24
1075a9: 75 2b jne 1075d6 <null_initialize+0x3e>
initialized = 1;
1075ab: c6 05 24 6e 12 00 01 movb $0x1,0x126e24
status = rtems_io_register_name(
1075b2: 50 push %eax
1075b3: 6a 00 push $0x0
1075b5: 53 push %ebx
1075b6: 68 9c ed 11 00 push $0x11ed9c
1075bb: e8 0c 05 00 00 call 107acc <rtems_io_register_name>
"/dev/null",
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
1075c0: 83 c4 10 add $0x10,%esp
1075c3: 85 c0 test %eax,%eax
1075c5: 74 09 je 1075d0 <null_initialize+0x38> <== ALWAYS TAKEN
rtems_fatal_error_occurred(status);
1075c7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1075ca: 50 push %eax <== NOT EXECUTED
1075cb: e8 78 3f 00 00 call 10b548 <rtems_fatal_error_occurred><== NOT EXECUTED
NULL_major = major;
1075d0: 89 1d 30 71 12 00 mov %ebx,0x127130
}
return RTEMS_SUCCESSFUL;
}
1075d6: 31 c0 xor %eax,%eax
1075d8: 8b 5d fc mov -0x4(%ebp),%ebx
1075db: c9 leave
1075dc: c3 ret
001075f2 <null_write>:
rtems_device_driver null_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void *pargp
)
{
1075f2: 55 push %ebp
1075f3: 89 e5 mov %esp,%ebp
1075f5: 8b 45 10 mov 0x10(%ebp),%eax
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp;
if ( rw_args )
1075f8: 85 c0 test %eax,%eax
1075fa: 74 06 je 107602 <null_write+0x10> <== ALWAYS TAKEN
rw_args->bytes_moved = rw_args->count;
1075fc: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED
1075ff: 89 50 18 mov %edx,0x18(%eax) <== NOT EXECUTED
return NULL_SUCCESSFUL;
}
107602: 31 c0 xor %eax,%eax
107604: c9 leave
107605: c3 ret
00107d2c <open>:
int open(
const char *pathname,
int flags,
...
)
{
107d2c: 55 push %ebp
107d2d: 89 e5 mov %esp,%ebp
107d2f: 57 push %edi
107d30: 56 push %esi
107d31: 53 push %ebx
107d32: 83 ec 3c sub $0x3c,%esp
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
107d35: 8b 45 0c mov 0xc(%ebp),%eax
107d38: 40 inc %eax
if ( ( status & _FREAD ) == _FREAD )
107d39: 89 c6 mov %eax,%esi
107d3b: 83 e6 01 and $0x1,%esi
eval_flags |= RTEMS_LIBIO_PERMS_READ;
107d3e: f7 de neg %esi
107d40: 83 e6 04 and $0x4,%esi
if ( ( status & _FWRITE ) == _FWRITE )
107d43: a8 02 test $0x2,%al
107d45: 74 03 je 107d4a <open+0x1e>
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
107d47: 83 ce 02 or $0x2,%esi
va_start(ap, flags);
mode = va_arg( ap, int );
107d4a: 8b 45 10 mov 0x10(%ebp),%eax
107d4d: 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();
107d50: e8 ba 63 00 00 call 10e10f <rtems_libio_allocate>
107d55: 89 c3 mov %eax,%ebx
if ( iop == 0 ) {
107d57: 85 c0 test %eax,%eax
107d59: 0f 84 56 01 00 00 je 107eb5 <open+0x189>
}
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
107d5f: 83 c9 ff or $0xffffffff,%ecx
107d62: 8b 7d 08 mov 0x8(%ebp),%edi
107d65: 31 c0 xor %eax,%eax
107d67: f2 ae repnz scas %es:(%edi),%al
107d69: f7 d1 not %ecx
107d6b: 49 dec %ecx
107d6c: 83 ec 0c sub $0xc,%esp
107d6f: 6a 01 push $0x1
107d71: 8d 45 d4 lea -0x2c(%ebp),%eax
107d74: 50 push %eax
107d75: 56 push %esi
107d76: 51 push %ecx
107d77: ff 75 08 pushl 0x8(%ebp)
107d7a: e8 6a f4 ff ff call 1071e9 <rtems_filesystem_evaluate_path>
107d7f: 89 c6 mov %eax,%esi
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
107d81: 83 c4 20 add $0x20,%esp
107d84: 83 f8 ff cmp $0xffffffff,%eax
107d87: 75 6c jne 107df5 <open+0xc9>
if ( errno != ENOENT ) {
107d89: e8 c6 93 00 00 call 111154 <__errno>
107d8e: 83 38 02 cmpl $0x2,(%eax)
107d91: 75 27 jne 107dba <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) ) {
107d93: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
107d9a: 0f 84 1c 01 00 00 je 107ebc <open+0x190>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
107da0: 6a 00 push $0x0
107da2: 6a 00 push $0x0
107da4: 8b 45 c4 mov -0x3c(%ebp),%eax
107da7: 80 cc 80 or $0x80,%ah
107daa: 50 push %eax
107dab: ff 75 08 pushl 0x8(%ebp)
107dae: e8 85 f8 ff ff call 107638 <mknod>
if ( rc ) {
107db3: 83 c4 10 add $0x10,%esp
107db6: 85 c0 test %eax,%eax
107db8: 74 0e je 107dc8 <open+0x9c> <== ALWAYS TAKEN
rc = errno;
107dba: e8 95 93 00 00 call 111154 <__errno>
107dbf: 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;
107dc1: 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;
107dc3: e9 10 01 00 00 jmp 107ed8 <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(
107dc8: 89 f1 mov %esi,%ecx
107dca: 8b 7d 08 mov 0x8(%ebp),%edi
107dcd: 31 c0 xor %eax,%eax
107dcf: f2 ae repnz scas %es:(%edi),%al
107dd1: f7 d1 not %ecx
107dd3: 49 dec %ecx
107dd4: 83 ec 0c sub $0xc,%esp
107dd7: 6a 01 push $0x1
107dd9: 8d 45 d4 lea -0x2c(%ebp),%eax
107ddc: 50 push %eax
107ddd: 6a 00 push $0x0
107ddf: 51 push %ecx
107de0: ff 75 08 pushl 0x8(%ebp)
107de3: e8 01 f4 ff ff call 1071e9 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
107de8: 83 c4 20 add $0x20,%esp
107deb: 85 c0 test %eax,%eax
107ded: 0f 85 d2 00 00 00 jne 107ec5 <open+0x199> <== NEVER TAKEN
107df3: eb 13 jmp 107e08 <open+0xdc>
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
107df5: 8b 45 0c mov 0xc(%ebp),%eax
107df8: 25 00 0a 00 00 and $0xa00,%eax
107dfd: 3d 00 0a 00 00 cmp $0xa00,%eax
107e02: 0f 84 c6 00 00 00 je 107ece <open+0x1a2>
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
107e08: 8b 73 14 mov 0x14(%ebx),%esi
107e0b: 83 ec 0c sub $0xc,%esp
107e0e: ff 75 0c pushl 0xc(%ebp)
107e11: e8 86 62 00 00 call 10e09c <rtems_libio_fcntl_flags>
107e16: 09 f0 or %esi,%eax
107e18: 89 43 14 mov %eax,0x14(%ebx)
iop->pathinfo = loc;
107e1b: 8d 7b 18 lea 0x18(%ebx),%edi
107e1e: 8d 75 d4 lea -0x2c(%ebp),%esi
107e21: b9 05 00 00 00 mov $0x5,%ecx
107e26: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
107e28: 8b 43 20 mov 0x20(%ebx),%eax
107e2b: ff 75 c4 pushl -0x3c(%ebp)
107e2e: ff 75 0c pushl 0xc(%ebp)
107e31: ff 75 08 pushl 0x8(%ebp)
107e34: 53 push %ebx
107e35: ff 10 call *(%eax)
if ( rc ) {
107e37: 83 c4 20 add $0x20,%esp
107e3a: 85 c0 test %eax,%eax
107e3c: 74 0f je 107e4d <open+0x121>
rc = errno;
107e3e: e8 11 93 00 00 call 111154 <__errno>
107e43: 8b 30 mov (%eax),%esi
rc = EEXIST;
loc_to_free = &loc;
goto done;
}
loc_to_free = &loc;
107e45: 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;
107e48: e9 8b 00 00 00 jmp 107ed8 <open+0x1ac>
}
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
107e4d: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
107e54: 0f 84 ae 00 00 00 je 107f08 <open+0x1dc>
rc = ftruncate( iop - rtems_libio_iops, 0 );
107e5a: 50 push %eax
107e5b: 6a 00 push $0x0
107e5d: 6a 00 push $0x0
107e5f: 89 d8 mov %ebx,%eax
107e61: 2b 05 98 40 12 00 sub 0x124098,%eax
107e67: c1 f8 03 sar $0x3,%eax
107e6a: 69 c0 b7 6d db b6 imul $0xb6db6db7,%eax,%eax
107e70: 50 push %eax
107e71: e8 3e 61 00 00 call 10dfb4 <ftruncate>
107e76: 89 c6 mov %eax,%esi
if ( rc ) {
107e78: 83 c4 10 add $0x10,%esp
107e7b: 85 c0 test %eax,%eax
107e7d: 0f 84 85 00 00 00 je 107f08 <open+0x1dc>
if(errno) rc = errno;
107e83: e8 cc 92 00 00 call 111154 <__errno>
107e88: 83 38 00 cmpl $0x0,(%eax)
107e8b: 74 07 je 107e94 <open+0x168> <== NEVER TAKEN
107e8d: e8 c2 92 00 00 call 111154 <__errno>
107e92: 8b 30 mov (%eax),%esi
close( iop - rtems_libio_iops );
107e94: 83 ec 0c sub $0xc,%esp
107e97: 2b 1d 98 40 12 00 sub 0x124098,%ebx
107e9d: c1 fb 03 sar $0x3,%ebx
107ea0: 69 db b7 6d db b6 imul $0xb6db6db7,%ebx,%ebx
107ea6: 53 push %ebx
107ea7: e8 98 60 00 00 call 10df44 <close>
107eac: 83 c4 10 add $0x10,%esp
/* those are released by close(): */
iop = 0;
loc_to_free = NULL;
107eaf: 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;
107eb1: 31 db xor %ebx,%ebx
107eb3: eb 23 jmp 107ed8 <open+0x1ac>
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
rc = ENFILE;
107eb5: be 17 00 00 00 mov $0x17,%esi
107eba: eb 40 jmp 107efc <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;
107ebc: 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;
107ebe: be 02 00 00 00 mov $0x2,%esi
107ec3: eb 17 jmp 107edc <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;
107ec5: 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;
107ec7: be 0d 00 00 00 mov $0xd,%esi <== NOT EXECUTED
107ecc: eb 0e jmp 107edc <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;
107ece: 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;
107ed1: be 11 00 00 00 mov $0x11,%esi
107ed6: eb 04 jmp 107edc <open+0x1b0>
* Single exit and clean up path.
*/
done:
va_end(ap);
if ( rc ) {
107ed8: 85 f6 test %esi,%esi
107eda: 74 2c je 107f08 <open+0x1dc> <== NEVER TAKEN
if ( iop )
107edc: 85 db test %ebx,%ebx
107ede: 74 0c je 107eec <open+0x1c0>
rtems_libio_free( iop );
107ee0: 83 ec 0c sub $0xc,%esp
107ee3: 53 push %ebx
107ee4: e8 9f 62 00 00 call 10e188 <rtems_libio_free>
107ee9: 83 c4 10 add $0x10,%esp
if ( loc_to_free )
107eec: 85 ff test %edi,%edi
107eee: 74 0c je 107efc <open+0x1d0>
rtems_filesystem_freenode( loc_to_free );
107ef0: 83 ec 0c sub $0xc,%esp
107ef3: 57 push %edi
107ef4: e8 d7 f3 ff ff call 1072d0 <rtems_filesystem_freenode>
107ef9: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( rc );
107efc: e8 53 92 00 00 call 111154 <__errno>
107f01: 89 30 mov %esi,(%eax)
107f03: 83 c8 ff or $0xffffffff,%eax
107f06: eb 0f jmp 107f17 <open+0x1eb>
}
return iop - rtems_libio_iops;
107f08: 2b 1d 98 40 12 00 sub 0x124098,%ebx
107f0e: c1 fb 03 sar $0x3,%ebx
107f11: 69 c3 b7 6d db b6 imul $0xb6db6db7,%ebx,%eax
}
107f17: 8d 65 f4 lea -0xc(%ebp),%esp
107f1a: 5b pop %ebx
107f1b: 5e pop %esi
107f1c: 5f pop %edi
107f1d: c9 leave
107f1e: c3 ret
00108b83 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
108b83: 55 push %ebp
108b84: 89 e5 mov %esp,%ebp
108b86: 56 push %esi
108b87: 53 push %ebx
108b88: 83 ec 10 sub $0x10,%esp
108b8b: 89 d3 mov %edx,%ebx
108b8d: 88 45 f4 mov %al,-0xc(%ebp)
int i;
if (tty->termios.c_oflag & OPOST) {
108b90: 8b 52 34 mov 0x34(%edx),%edx
108b93: f6 c2 01 test $0x1,%dl
108b96: 0f 84 ed 00 00 00 je 108c89 <oproc+0x106> <== NEVER TAKEN
switch (c) {
108b9c: 3c 09 cmp $0x9,%al
108b9e: 74 75 je 108c15 <oproc+0x92>
108ba0: 77 0d ja 108baf <oproc+0x2c> <== ALWAYS TAKEN
108ba2: 3c 08 cmp $0x8,%al <== NOT EXECUTED
108ba4: 0f 85 aa 00 00 00 jne 108c54 <oproc+0xd1> <== NOT EXECUTED
108baa: e9 98 00 00 00 jmp 108c47 <oproc+0xc4> <== NOT EXECUTED
108baf: 3c 0a cmp $0xa,%al
108bb1: 74 0a je 108bbd <oproc+0x3a>
108bb3: 3c 0d cmp $0xd,%al
108bb5: 0f 85 99 00 00 00 jne 108c54 <oproc+0xd1> <== ALWAYS TAKEN
108bbb: eb 32 jmp 108bef <oproc+0x6c> <== NOT EXECUTED
case '\n':
if (tty->termios.c_oflag & ONLRET)
108bbd: f6 c2 20 test $0x20,%dl
108bc0: 74 07 je 108bc9 <oproc+0x46> <== ALWAYS TAKEN
tty->column = 0;
108bc2: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
108bc9: 80 e2 04 and $0x4,%dl
108bcc: 0f 84 b7 00 00 00 je 108c89 <oproc+0x106> <== NEVER TAKEN
rtems_termios_puts ("\r", 1, tty);
108bd2: 56 push %esi
108bd3: 53 push %ebx
108bd4: 6a 01 push $0x1
108bd6: 68 00 e9 11 00 push $0x11e900
108bdb: e8 83 fe ff ff call 108a63 <rtems_termios_puts>
tty->column = 0;
108be0: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx)
108be7: 83 c4 10 add $0x10,%esp
108bea: e9 9a 00 00 00 jmp 108c89 <oproc+0x106>
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
108bef: f6 c2 10 test $0x10,%dl <== NOT EXECUTED
108bf2: 74 0a je 108bfe <oproc+0x7b> <== NOT EXECUTED
108bf4: 83 7b 28 00 cmpl $0x0,0x28(%ebx) <== NOT EXECUTED
108bf8: 0f 84 9b 00 00 00 je 108c99 <oproc+0x116> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
108bfe: f6 c2 08 test $0x8,%dl <== NOT EXECUTED
108c01: 74 09 je 108c0c <oproc+0x89> <== NOT EXECUTED
c = '\n';
108c03: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
108c07: 80 e2 20 and $0x20,%dl <== NOT EXECUTED
108c0a: 74 7d je 108c89 <oproc+0x106> <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
108c0c: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED
break;
108c13: eb 74 jmp 108c89 <oproc+0x106> <== NOT EXECUTED
case '\t':
i = 8 - (tty->column & 7);
108c15: 8b 4b 28 mov 0x28(%ebx),%ecx
108c18: 89 ce mov %ecx,%esi
108c1a: 83 e6 07 and $0x7,%esi
108c1d: b8 08 00 00 00 mov $0x8,%eax
108c22: 29 f0 sub %esi,%eax
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
108c24: 81 e2 00 18 00 00 and $0x1800,%edx
108c2a: 81 fa 00 18 00 00 cmp $0x1800,%edx
108c30: 8d 14 08 lea (%eax,%ecx,1),%edx
108c33: 75 0d jne 108c42 <oproc+0xbf> <== NEVER TAKEN
tty->column += i;
108c35: 89 53 28 mov %edx,0x28(%ebx)
rtems_termios_puts ( " ", i, tty);
108c38: 51 push %ecx
108c39: 53 push %ebx
108c3a: 50 push %eax
108c3b: 68 30 e5 11 00 push $0x11e530
108c40: eb 4f jmp 108c91 <oproc+0x10e>
return;
}
tty->column += i;
108c42: 89 53 28 mov %edx,0x28(%ebx) <== NOT EXECUTED
break;
108c45: eb 42 jmp 108c89 <oproc+0x106> <== NOT EXECUTED
case '\b':
if (tty->column > 0)
108c47: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
108c4a: 85 c0 test %eax,%eax <== NOT EXECUTED
108c4c: 7e 3b jle 108c89 <oproc+0x106> <== NOT EXECUTED
tty->column--;
108c4e: 48 dec %eax <== NOT EXECUTED
108c4f: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
108c52: eb 35 jmp 108c89 <oproc+0x106> <== NOT EXECUTED
break;
default:
if (tty->termios.c_oflag & OLCUC)
108c54: 80 e2 02 and $0x2,%dl
108c57: 74 1c je 108c75 <oproc+0xf2> <== ALWAYS TAKEN
c = toupper(c);
108c59: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
108c5c: 8b 15 0c 20 12 00 mov 0x12200c,%edx <== NOT EXECUTED
108c62: 0f be 54 02 01 movsbl 0x1(%edx,%eax,1),%edx <== NOT EXECUTED
108c67: 83 e2 03 and $0x3,%edx <== NOT EXECUTED
108c6a: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED
108c6d: 75 03 jne 108c72 <oproc+0xef> <== NOT EXECUTED
108c6f: 83 e8 20 sub $0x20,%eax <== NOT EXECUTED
108c72: 88 45 f4 mov %al,-0xc(%ebp) <== NOT EXECUTED
if (!iscntrl(c))
108c75: 0f b6 45 f4 movzbl -0xc(%ebp),%eax
108c79: 8b 15 0c 20 12 00 mov 0x12200c,%edx
108c7f: f6 44 02 01 20 testb $0x20,0x1(%edx,%eax,1)
108c84: 75 03 jne 108c89 <oproc+0x106> <== NEVER TAKEN
tty->column++;
108c86: ff 43 28 incl 0x28(%ebx)
break;
}
}
rtems_termios_puts (&c, 1, tty);
108c89: 52 push %edx
108c8a: 53 push %ebx
108c8b: 6a 01 push $0x1
108c8d: 8d 45 f4 lea -0xc(%ebp),%eax
108c90: 50 push %eax
108c91: e8 cd fd ff ff call 108a63 <rtems_termios_puts>
108c96: 83 c4 10 add $0x10,%esp
}
108c99: 8d 65 f8 lea -0x8(%ebp),%esp
108c9c: 5b pop %ebx
108c9d: 5e pop %esi
108c9e: c9 leave
108c9f: c3 ret
0010eec8 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
10eec8: 55 push %ebp
10eec9: 89 e5 mov %esp,%ebp
10eecb: 57 push %edi
10eecc: 56 push %esi
10eecd: 53 push %ebx
10eece: 83 ec 34 sub $0x34,%esp
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
10eed1: 68 ff 01 00 00 push $0x1ff
10eed6: 68 c8 06 12 00 push $0x1206c8
10eedb: e8 bc 14 00 00 call 11039c <rtems_mkdir>
10eee0: 83 c4 10 add $0x10,%esp
return -1;
10eee3: 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)
10eeea: 85 c0 test %eax,%eax
10eeec: 0f 85 e8 00 00 00 jne 10efda <pipe_create+0x112> <== NEVER TAKEN
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
10eef2: 8d 5d d9 lea -0x27(%ebp),%ebx
10eef5: be cd 06 12 00 mov $0x1206cd,%esi
10eefa: b9 0a 00 00 00 mov $0xa,%ecx
10eeff: 89 df mov %ebx,%edi
10ef01: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
10ef03: 0f b7 05 c0 5e 12 00 movzwl 0x125ec0,%eax
10ef0a: 8d 50 01 lea 0x1(%eax),%edx
10ef0d: 66 89 15 c0 5e 12 00 mov %dx,0x125ec0
10ef14: 57 push %edi
10ef15: 50 push %eax
10ef16: 68 d8 06 12 00 push $0x1206d8
10ef1b: 8d 45 e3 lea -0x1d(%ebp),%eax
10ef1e: 50 push %eax
10ef1f: e8 a8 44 00 00 call 1133cc <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
10ef24: 59 pop %ecx
10ef25: 5e pop %esi
10ef26: 68 80 01 00 00 push $0x180
10ef2b: 53 push %ebx
10ef2c: e8 2f 12 00 00 call 110160 <mkfifo>
10ef31: 83 c4 10 add $0x10,%esp
10ef34: 85 c0 test %eax,%eax
10ef36: 74 0a je 10ef42 <pipe_create+0x7a>
if (errno != EEXIST){
10ef38: e8 a3 3a 00 00 call 1129e0 <__errno>
10ef3d: e9 98 00 00 00 jmp 10efda <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);
10ef42: 52 push %edx
10ef43: 52 push %edx
10ef44: 68 00 40 00 00 push $0x4000
10ef49: 53 push %ebx
10ef4a: e8 65 9e ff ff call 108db4 <open>
10ef4f: 8b 55 08 mov 0x8(%ebp),%edx
10ef52: 89 02 mov %eax,(%edx)
if (filsdes[0] < 0) {
10ef54: 83 c4 10 add $0x10,%esp
10ef57: 85 c0 test %eax,%eax
10ef59: 79 0d jns 10ef68 <pipe_create+0xa0>
err = errno;
10ef5b: e8 80 3a 00 00 call 1129e0 <__errno>
10ef60: 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);
10ef62: 83 ec 0c sub $0xc,%esp
10ef65: 53 push %ebx
10ef66: eb 51 jmp 10efb9 <pipe_create+0xf1>
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
10ef68: 31 d2 xor %edx,%edx
10ef6a: 3b 05 44 21 12 00 cmp 0x122144,%eax
10ef70: 73 09 jae 10ef7b <pipe_create+0xb3> <== NEVER TAKEN
10ef72: 6b d0 38 imul $0x38,%eax,%edx
10ef75: 03 15 c0 60 12 00 add 0x1260c0,%edx
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
10ef7b: 83 62 14 fe andl $0xfffffffe,0x14(%edx)
filsdes[1] = open(fifopath, O_WRONLY);
10ef7f: 50 push %eax
10ef80: 50 push %eax
10ef81: 6a 01 push $0x1
10ef83: 8d 45 d9 lea -0x27(%ebp),%eax
10ef86: 50 push %eax
10ef87: e8 28 9e ff ff call 108db4 <open>
10ef8c: 8b 55 08 mov 0x8(%ebp),%edx
10ef8f: 89 42 04 mov %eax,0x4(%edx)
if (filsdes[1] < 0) {
10ef92: 83 c4 10 add $0x10,%esp
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
10ef95: 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) {
10ef97: 85 c0 test %eax,%eax
10ef99: 79 17 jns 10efb2 <pipe_create+0xea>
err = errno;
10ef9b: e8 40 3a 00 00 call 1129e0 <__errno>
10efa0: 8b 30 mov (%eax),%esi
close(filsdes[0]);
10efa2: 83 ec 0c sub $0xc,%esp
10efa5: 8b 45 08 mov 0x8(%ebp),%eax
10efa8: ff 30 pushl (%eax)
10efaa: e8 c5 8f ff ff call 107f74 <close>
10efaf: 83 c4 10 add $0x10,%esp
}
unlink(fifopath);
10efb2: 83 ec 0c sub $0xc,%esp
10efb5: 8d 45 d9 lea -0x27(%ebp),%eax
10efb8: 50 push %eax
10efb9: e8 46 ba ff ff call 10aa04 <unlink>
10efbe: 83 c4 10 add $0x10,%esp
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
10efc1: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
10efc8: 85 f6 test %esi,%esi
10efca: 74 0e je 10efda <pipe_create+0x112>
rtems_set_errno_and_return_minus_one(err);
10efcc: e8 0f 3a 00 00 call 1129e0 <__errno>
10efd1: 89 30 mov %esi,(%eax)
10efd3: c7 45 d4 ff ff ff ff movl $0xffffffff,-0x2c(%ebp)
return 0;
}
10efda: 8b 45 d4 mov -0x2c(%ebp),%eax
10efdd: 8d 65 f4 lea -0xc(%ebp),%esp
10efe0: 5b pop %ebx
10efe1: 5e pop %esi
10efe2: 5f pop %edi
10efe3: c9 leave
10efe4: c3 ret
0010fad6 <pipe_ioctl>:
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
10fad6: 55 push %ebp
10fad7: 89 e5 mov %esp,%ebp
10fad9: 56 push %esi
10fada: 53 push %ebx
10fadb: 8b 5d 08 mov 0x8(%ebp),%ebx
10fade: 8b 75 10 mov 0x10(%ebp),%esi
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
10fae1: b8 ea ff ff ff mov $0xffffffea,%eax
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
10fae6: 81 7d 0c 7f 66 04 40 cmpl $0x4004667f,0xc(%ebp)
10faed: 75 36 jne 10fb25 <pipe_ioctl+0x4f>
if (buffer == NULL)
return -EFAULT;
10faef: b0 f2 mov $0xf2,%al
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
10faf1: 85 f6 test %esi,%esi
10faf3: 74 30 je 10fb25 <pipe_ioctl+0x4f>
return -EFAULT;
if (! PIPE_LOCK(pipe))
10faf5: 51 push %ecx
10faf6: 6a 00 push $0x0
10faf8: 6a 00 push $0x0
10fafa: ff 73 28 pushl 0x28(%ebx)
10fafd: e8 06 b9 ff ff call 10b408 <rtems_semaphore_obtain>
10fb02: 89 c2 mov %eax,%edx
10fb04: 83 c4 10 add $0x10,%esp
return -EINTR;
10fb07: b8 fc ff ff ff mov $0xfffffffc,%eax
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
if (! PIPE_LOCK(pipe))
10fb0c: 85 d2 test %edx,%edx
10fb0e: 75 15 jne 10fb25 <pipe_ioctl+0x4f> <== NEVER TAKEN
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
10fb10: 8b 43 0c mov 0xc(%ebx),%eax
10fb13: 89 06 mov %eax,(%esi)
PIPE_UNLOCK(pipe);
10fb15: 83 ec 0c sub $0xc,%esp
10fb18: ff 73 28 pushl 0x28(%ebx)
10fb1b: e8 d4 b9 ff ff call 10b4f4 <rtems_semaphore_release>
return 0;
10fb20: 83 c4 10 add $0x10,%esp
10fb23: 31 c0 xor %eax,%eax
}
return -EINVAL;
}
10fb25: 8d 65 f8 lea -0x8(%ebp),%esp
10fb28: 5b pop %ebx
10fb29: 5e pop %esi
10fb2a: c9 leave
10fb2b: c3 ret
0010f2bc <pipe_lock>:
free(pipe->Buffer);
free(pipe);
}
static rtems_status_code pipe_lock(void)
{
10f2bc: 55 push %ebp
10f2bd: 89 e5 mov %esp,%ebp
10f2bf: 53 push %ebx
10f2c0: 83 ec 04 sub $0x4,%esp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
10f2c3: 83 3d c4 5e 12 00 00 cmpl $0x0,0x125ec4
10f2ca: 75 55 jne 10f321 <pipe_lock+0x65>
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 );
10f2cc: 52 push %edx
10f2cd: 6a 00 push $0x0
10f2cf: 6a 00 push $0x0
10f2d1: ff 35 c8 60 12 00 pushl 0x1260c8
10f2d7: e8 2c c1 ff ff call 10b408 <rtems_semaphore_obtain>
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
10f2dc: 83 c4 10 add $0x10,%esp
free(pipe);
}
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
10f2df: 31 db xor %ebx,%ebx
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
10f2e1: 83 3d c4 5e 12 00 00 cmpl $0x0,0x125ec4
10f2e8: 75 1d jne 10f307 <pipe_lock+0x4b> <== NEVER TAKEN
sc = rtems_semaphore_create(
10f2ea: 83 ec 0c sub $0xc,%esp
10f2ed: 68 c4 5e 12 00 push $0x125ec4
10f2f2: 6a 00 push $0x0
10f2f4: 6a 54 push $0x54
10f2f6: 6a 01 push $0x1
10f2f8: 68 45 50 49 50 push $0x50495045
10f2fd: e8 de be ff ff call 10b1e0 <rtems_semaphore_create>
10f302: 89 c3 mov %eax,%ebx
10f304: 83 c4 20 add $0x20,%esp
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10f307: 83 ec 0c sub $0xc,%esp
10f30a: ff 35 c8 60 12 00 pushl 0x1260c8
10f310: e8 df c1 ff ff call 10b4f4 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
10f315: 83 c4 10 add $0x10,%esp
}
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
return -ENOMEM;
10f318: b8 f4 ff ff ff mov $0xfffffff4,%eax
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
10f31d: 85 db test %ebx,%ebx
10f31f: 75 1d jne 10f33e <pipe_lock+0x82>
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
10f321: 50 push %eax
10f322: 6a 00 push $0x0
10f324: 6a 00 push $0x0
10f326: ff 35 c4 5e 12 00 pushl 0x125ec4
10f32c: e8 d7 c0 ff ff call 10b408 <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
10f331: 83 c4 10 add $0x10,%esp
return 0;
} else {
return -ENOMEM;
10f334: 83 f8 01 cmp $0x1,%eax
10f337: 19 c0 sbb %eax,%eax
10f339: f7 d0 not %eax
10f33b: 83 e0 f4 and $0xfffffff4,%eax
}
}
10f33e: 8b 5d fc mov -0x4(%ebp),%ebx
10f341: c9 leave
10f342: c3 ret
0010f7bc <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
10f7bc: 55 push %ebp
10f7bd: 89 e5 mov %esp,%ebp
10f7bf: 57 push %edi
10f7c0: 56 push %esi
10f7c1: 53 push %ebx
10f7c2: 83 ec 30 sub $0x30,%esp
10f7c5: 8b 5d 08 mov 0x8(%ebp),%ebx
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
10f7c8: 6a 00 push $0x0
10f7ca: 6a 00 push $0x0
10f7cc: ff 73 28 pushl 0x28(%ebx)
10f7cf: e8 34 bc ff ff call 10b408 <rtems_semaphore_obtain>
10f7d4: 83 c4 10 add $0x10,%esp
return -EINTR;
10f7d7: 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))
10f7de: 85 c0 test %eax,%eax
10f7e0: 0f 85 2f 01 00 00 jne 10f915 <pipe_read+0x159> <== NEVER TAKEN
10f7e6: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
10f7ed: e9 f0 00 00 00 jmp 10f8e2 <pipe_read+0x126>
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
10f7f2: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10f7f6: 0f 84 f2 00 00 00 je 10f8ee <pipe_read+0x132>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
10f7fc: 8b 45 14 mov 0x14(%ebp),%eax
10f7ff: f6 40 14 01 testb $0x1,0x14(%eax)
10f803: 0f 85 e9 00 00 00 jne 10f8f2 <pipe_read+0x136>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
10f809: ff 43 18 incl 0x18(%ebx)
PIPE_UNLOCK(pipe);
10f80c: 83 ec 0c sub $0xc,%esp
10f80f: ff 73 28 pushl 0x28(%ebx)
10f812: e8 dd bc ff ff call 10b4f4 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
10f817: 5e pop %esi
10f818: 5f pop %edi
10f819: 6a 00 push $0x0
10f81b: ff 73 2c pushl 0x2c(%ebx)
10f81e: e8 31 18 00 00 call 111054 <rtems_barrier_wait>
10f823: 83 c4 0c add $0xc,%esp
10f826: 83 f8 01 cmp $0x1,%eax
10f829: 19 f6 sbb %esi,%esi
10f82b: f7 d6 not %esi
10f82d: 83 e6 fc and $0xfffffffc,%esi
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
10f830: 6a 00 push $0x0
10f832: 6a 00 push $0x0
10f834: ff 73 28 pushl 0x28(%ebx)
10f837: e8 cc bb ff ff call 10b408 <rtems_semaphore_obtain>
10f83c: 83 c4 10 add $0x10,%esp
10f83f: 85 c0 test %eax,%eax
10f841: 0f 85 c0 00 00 00 jne 10f907 <pipe_read+0x14b> <== NEVER TAKEN
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
10f847: ff 4b 18 decl 0x18(%ebx)
if (ret != 0)
10f84a: 85 f6 test %esi,%esi
10f84c: 0f 85 a5 00 00 00 jne 10f8f7 <pipe_read+0x13b> <== NEVER TAKEN
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
10f852: 8b 53 0c mov 0xc(%ebx),%edx
10f855: 85 d2 test %edx,%edx
10f857: 74 99 je 10f7f2 <pipe_read+0x36>
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
10f859: 8b 45 10 mov 0x10(%ebp),%eax
10f85c: 2b 45 d4 sub -0x2c(%ebp),%eax
10f85f: 89 55 d0 mov %edx,-0x30(%ebp)
10f862: 39 c2 cmp %eax,%edx
10f864: 76 03 jbe 10f869 <pipe_read+0xad>
10f866: 89 45 d0 mov %eax,-0x30(%ebp)
chunk1 = pipe->Size - pipe->Start;
10f869: 8b 73 08 mov 0x8(%ebx),%esi
10f86c: 8b 43 04 mov 0x4(%ebx),%eax
10f86f: 29 f0 sub %esi,%eax
if (chunk > chunk1) {
10f871: 39 45 d0 cmp %eax,-0x30(%ebp)
10f874: 8b 7d 0c mov 0xc(%ebp),%edi
10f877: 8b 4d d4 mov -0x2c(%ebp),%ecx
10f87a: 8d 14 0f lea (%edi,%ecx,1),%edx
10f87d: 7e 1b jle 10f89a <pipe_read+0xde>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
10f87f: 03 33 add (%ebx),%esi
10f881: 89 d7 mov %edx,%edi
10f883: 89 c1 mov %eax,%ecx
10f885: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
10f887: 8b 55 d4 mov -0x2c(%ebp),%edx
10f88a: 01 c2 add %eax,%edx
10f88c: 03 55 0c add 0xc(%ebp),%edx
10f88f: 8b 4d d0 mov -0x30(%ebp),%ecx
10f892: 29 c1 sub %eax,%ecx
10f894: 8b 33 mov (%ebx),%esi
10f896: 89 d7 mov %edx,%edi
10f898: eb 07 jmp 10f8a1 <pipe_read+0xe5>
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
10f89a: 03 33 add (%ebx),%esi
10f89c: 89 d7 mov %edx,%edi
10f89e: 8b 4d d0 mov -0x30(%ebp),%ecx
10f8a1: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
pipe->Start += chunk;
10f8a3: 8b 45 d0 mov -0x30(%ebp),%eax
10f8a6: 03 43 08 add 0x8(%ebx),%eax
pipe->Start %= pipe->Size;
10f8a9: 31 d2 xor %edx,%edx
10f8ab: f7 73 04 divl 0x4(%ebx)
10f8ae: 89 53 08 mov %edx,0x8(%ebx)
pipe->Length -= chunk;
10f8b1: 8b 43 0c mov 0xc(%ebx),%eax
10f8b4: 2b 45 d0 sub -0x30(%ebp),%eax
10f8b7: 89 43 0c mov %eax,0xc(%ebx)
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
10f8ba: 85 c0 test %eax,%eax
10f8bc: 75 07 jne 10f8c5 <pipe_read+0x109>
pipe->Start = 0;
10f8be: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
if (pipe->waitingWriters > 0)
10f8c5: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx)
10f8c9: 74 11 je 10f8dc <pipe_read+0x120>
PIPE_WAKEUPWRITERS(pipe);
10f8cb: 51 push %ecx
10f8cc: 51 push %ecx
10f8cd: 8d 45 e4 lea -0x1c(%ebp),%eax
10f8d0: 50 push %eax
10f8d1: ff 73 30 pushl 0x30(%ebx)
10f8d4: e8 23 17 00 00 call 110ffc <rtems_barrier_release>
10f8d9: 83 c4 10 add $0x10,%esp
read += chunk;
10f8dc: 8b 4d d0 mov -0x30(%ebp),%ecx
10f8df: 01 4d d4 add %ecx,-0x2c(%ebp)
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
10f8e2: 8b 7d 10 mov 0x10(%ebp),%edi
10f8e5: 39 7d d4 cmp %edi,-0x2c(%ebp)
10f8e8: 0f 82 64 ff ff ff jb 10f852 <pipe_read+0x96>
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
10f8ee: 31 f6 xor %esi,%esi
10f8f0: eb 05 jmp 10f8f7 <pipe_read+0x13b>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
10f8f2: be f5 ff ff ff mov $0xfffffff5,%esi
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
10f8f7: 83 ec 0c sub $0xc,%esp
10f8fa: ff 73 28 pushl 0x28(%ebx)
10f8fd: e8 f2 bb ff ff call 10b4f4 <rtems_semaphore_release>
10f902: 83 c4 10 add $0x10,%esp
10f905: eb 05 jmp 10f90c <pipe_read+0x150>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
10f907: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
10f90c: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10f910: 7f 03 jg 10f915 <pipe_read+0x159>
return read;
return ret;
10f912: 89 75 d4 mov %esi,-0x2c(%ebp)
}
10f915: 8b 45 d4 mov -0x2c(%ebp),%eax
10f918: 8d 65 f4 lea -0xc(%ebp),%esp
10f91b: 5b pop %ebx
10f91c: 5e pop %esi
10f91d: 5f pop %edi
10f91e: c9 leave
10f91f: c3 ret
0010f3a5 <pipe_release>:
*/
int pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
10f3a5: 55 push %ebp
10f3a6: 89 e5 mov %esp,%ebp
10f3a8: 57 push %edi
10f3a9: 56 push %esi
10f3aa: 53 push %ebx
10f3ab: 83 ec 1c sub $0x1c,%esp
10f3ae: 8b 7d 08 mov 0x8(%ebp),%edi
pipe_control_t *pipe = *pipep;
10f3b1: 8b 1f mov (%edi),%ebx
uint32_t mode;
if (pipe_lock())
10f3b3: e8 04 ff ff ff call 10f2bc <pipe_lock>
10f3b8: 85 c0 test %eax,%eax
10f3ba: 75 14 jne 10f3d0 <pipe_release+0x2b> <== NEVER TAKEN
/* WARN pipe not freed and pipep not set to NULL! */
/* FIXME */
rtems_fatal_error_occurred(0xdeadbeef);
if (!PIPE_LOCK(pipe))
10f3bc: 50 push %eax
10f3bd: 6a 00 push $0x0
10f3bf: 6a 00 push $0x0
10f3c1: ff 73 28 pushl 0x28(%ebx)
10f3c4: e8 3f c0 ff ff call 10b408 <rtems_semaphore_obtain>
10f3c9: 83 c4 10 add $0x10,%esp
10f3cc: 85 c0 test %eax,%eax
10f3ce: 74 0d je 10f3dd <pipe_release+0x38> <== ALWAYS TAKEN
/* WARN pipe not released! */
/* FIXME */
rtems_fatal_error_occurred(0xdeadbeef);
10f3d0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10f3d3: 68 ef be ad de push $0xdeadbeef <== NOT EXECUTED
10f3d8: e8 af c5 ff ff call 10b98c <rtems_fatal_error_occurred><== NOT EXECUTED
mode = LIBIO_ACCMODE(iop);
10f3dd: 8b 45 0c mov 0xc(%ebp),%eax
10f3e0: 8b 40 14 mov 0x14(%eax),%eax
10f3e3: 89 c6 mov %eax,%esi
10f3e5: 83 e6 06 and $0x6,%esi
if (mode & LIBIO_FLAGS_READ)
10f3e8: a8 02 test $0x2,%al
10f3ea: 74 03 je 10f3ef <pipe_release+0x4a>
pipe->Readers --;
10f3ec: ff 4b 10 decl 0x10(%ebx)
if (mode & LIBIO_FLAGS_WRITE)
10f3ef: f7 c6 04 00 00 00 test $0x4,%esi
10f3f5: 74 03 je 10f3fa <pipe_release+0x55>
pipe->Writers --;
10f3f7: ff 4b 14 decl 0x14(%ebx)
PIPE_UNLOCK(pipe);
10f3fa: 83 ec 0c sub $0xc,%esp
10f3fd: ff 73 28 pushl 0x28(%ebx)
10f400: e8 ef c0 ff ff call 10b4f4 <rtems_semaphore_release>
if (pipe->Readers == 0 && pipe->Writers == 0) {
10f405: 8b 43 10 mov 0x10(%ebx),%eax
10f408: 83 c4 10 add $0x10,%esp
10f40b: 85 c0 test %eax,%eax
10f40d: 75 15 jne 10f424 <pipe_release+0x7f>
10f40f: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10f413: 75 0f jne 10f424 <pipe_release+0x7f>
#if 0
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
10f415: 89 d8 mov %ebx,%eax
10f417: e8 27 ff ff ff call 10f343 <pipe_free>
*pipep = NULL;
10f41c: c7 07 00 00 00 00 movl $0x0,(%edi)
10f422: eb 30 jmp 10f454 <pipe_release+0xaf>
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
10f424: 83 fe 04 cmp $0x4,%esi
10f427: 74 0f je 10f438 <pipe_release+0x93>
10f429: 85 c0 test %eax,%eax
10f42b: 75 0b jne 10f438 <pipe_release+0x93> <== NEVER TAKEN
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
10f42d: 56 push %esi
10f42e: 56 push %esi
10f42f: 8d 45 e4 lea -0x1c(%ebp),%eax
10f432: 50 push %eax
10f433: ff 73 30 pushl 0x30(%ebx)
10f436: eb 14 jmp 10f44c <pipe_release+0xa7>
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
10f438: 83 fe 02 cmp $0x2,%esi
10f43b: 74 17 je 10f454 <pipe_release+0xaf> <== NEVER TAKEN
10f43d: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10f441: 75 11 jne 10f454 <pipe_release+0xaf> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
10f443: 51 push %ecx
10f444: 51 push %ecx
10f445: 8d 45 e4 lea -0x1c(%ebp),%eax
10f448: 50 push %eax
10f449: ff 73 2c pushl 0x2c(%ebx)
10f44c: e8 ab 1b 00 00 call 110ffc <rtems_barrier_release>
10f451: 83 c4 10 add $0x10,%esp
pipe_unlock();
10f454: e8 25 ff ff ff call 10f37e <pipe_unlock>
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return -errno;
#endif
return 0;
}
10f459: 31 c0 xor %eax,%eax
10f45b: 8d 65 f4 lea -0xc(%ebp),%esp
10f45e: 5b pop %ebx
10f45f: 5e pop %esi
10f460: 5f pop %edi
10f461: c9 leave
10f462: c3 ret
0010f37e <pipe_unlock>:
return -ENOMEM;
}
}
static void pipe_unlock(void)
{
10f37e: 55 push %ebp
10f37f: 89 e5 mov %esp,%ebp
10f381: 83 ec 14 sub $0x14,%esp
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
10f384: ff 35 c4 5e 12 00 pushl 0x125ec4
10f38a: e8 65 c1 ff ff call 10b4f4 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL) {
10f38f: 83 c4 10 add $0x10,%esp
10f392: 85 c0 test %eax,%eax
10f394: 74 0d je 10f3a3 <pipe_unlock+0x25> <== ALWAYS TAKEN
/* FIXME */
rtems_fatal_error_occurred(0xdeadbeef);
10f396: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10f399: 68 ef be ad de push $0xdeadbeef <== NOT EXECUTED
10f39e: e8 e9 c5 ff ff call 10b98c <rtems_fatal_error_occurred><== NOT EXECUTED
}
}
10f3a3: c9 leave
10f3a4: c3 ret
0010f920 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
10f920: 55 push %ebp
10f921: 89 e5 mov %esp,%ebp
10f923: 57 push %edi
10f924: 56 push %esi
10f925: 53 push %ebx
10f926: 83 ec 2c sub $0x2c,%esp
10f929: 8b 5d 08 mov 0x8(%ebp),%ebx
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
10f92c: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
)
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
10f933: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10f937: 0f 84 8e 01 00 00 je 10facb <pipe_write+0x1ab> <== NEVER TAKEN
return 0;
if (! PIPE_LOCK(pipe))
10f93d: 52 push %edx
10f93e: 6a 00 push $0x0
10f940: 6a 00 push $0x0
10f942: ff 73 28 pushl 0x28(%ebx)
10f945: e8 be ba ff ff call 10b408 <rtems_semaphore_obtain>
10f94a: 83 c4 10 add $0x10,%esp
return -EINTR;
10f94d: c7 45 d4 fc ff ff ff movl $0xfffffffc,-0x2c(%ebp)
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
10f954: 85 c0 test %eax,%eax
10f956: 0f 85 6f 01 00 00 jne 10facb <pipe_write+0x1ab> <== NEVER TAKEN
return -EINTR;
if (pipe->Readers == 0) {
10f95c: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10f960: 0f 84 16 01 00 00 je 10fa7c <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;
10f966: bf 01 00 00 00 mov $0x1,%edi
10f96b: 8b 45 10 mov 0x10(%ebp),%eax
10f96e: 3b 43 04 cmp 0x4(%ebx),%eax
10f971: 77 02 ja 10f975 <pipe_write+0x55> <== NEVER TAKEN
10f973: 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;
10f975: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
10f97c: e9 eb 00 00 00 jmp 10fa6c <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)) {
10f981: 8b 4d 14 mov 0x14(%ebp),%ecx
10f984: f6 41 14 01 testb $0x1,0x14(%ecx)
10f988: 0f 85 fc 00 00 00 jne 10fa8a <pipe_write+0x16a>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
10f98e: ff 43 1c incl 0x1c(%ebx)
PIPE_UNLOCK(pipe);
10f991: 83 ec 0c sub $0xc,%esp
10f994: ff 73 28 pushl 0x28(%ebx)
10f997: e8 58 bb ff ff call 10b4f4 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
10f99c: 5e pop %esi
10f99d: 58 pop %eax
10f99e: 6a 00 push $0x0
10f9a0: ff 73 30 pushl 0x30(%ebx)
10f9a3: e8 ac 16 00 00 call 111054 <rtems_barrier_wait>
10f9a8: 83 c4 0c add $0xc,%esp
10f9ab: 83 f8 01 cmp $0x1,%eax
10f9ae: 19 f6 sbb %esi,%esi
10f9b0: f7 d6 not %esi
10f9b2: 83 e6 fc and $0xfffffffc,%esi
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
10f9b5: 6a 00 push $0x0
10f9b7: 6a 00 push $0x0
10f9b9: ff 73 28 pushl 0x28(%ebx)
10f9bc: e8 47 ba ff ff call 10b408 <rtems_semaphore_obtain>
10f9c1: 83 c4 10 add $0x10,%esp
10f9c4: 85 c0 test %eax,%eax
10f9c6: 0f 85 f1 00 00 00 jne 10fabd <pipe_write+0x19d> <== NEVER TAKEN
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
10f9cc: ff 4b 1c decl 0x1c(%ebx)
if (ret != 0)
10f9cf: 85 f6 test %esi,%esi
10f9d1: 0f 85 bf 00 00 00 jne 10fa96 <pipe_write+0x176> <== NEVER TAKEN
goto out_locked;
if (pipe->Readers == 0) {
10f9d7: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10f9db: 0f 84 b0 00 00 00 je 10fa91 <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) {
10f9e1: 8b 73 04 mov 0x4(%ebx),%esi
10f9e4: 8b 43 0c mov 0xc(%ebx),%eax
10f9e7: 89 f1 mov %esi,%ecx
10f9e9: 29 c1 sub %eax,%ecx
10f9eb: 39 f9 cmp %edi,%ecx
10f9ed: 72 92 jb 10f981 <pipe_write+0x61>
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
10f9ef: 8b 55 10 mov 0x10(%ebp),%edx
10f9f2: 2b 55 d4 sub -0x2c(%ebp),%edx
10f9f5: 89 4d d0 mov %ecx,-0x30(%ebp)
10f9f8: 39 d1 cmp %edx,%ecx
10f9fa: 76 03 jbe 10f9ff <pipe_write+0xdf>
10f9fc: 89 55 d0 mov %edx,-0x30(%ebp)
chunk1 = pipe->Size - PIPE_WSTART(pipe);
10f9ff: 03 43 08 add 0x8(%ebx),%eax
10fa02: 31 d2 xor %edx,%edx
10fa04: f7 f6 div %esi
10fa06: 29 d6 sub %edx,%esi
10fa08: 89 75 cc mov %esi,-0x34(%ebp)
if (chunk > chunk1) {
10fa0b: 39 75 d0 cmp %esi,-0x30(%ebp)
10fa0e: 8b 4d 0c mov 0xc(%ebp),%ecx
10fa11: 8b 45 d4 mov -0x2c(%ebp),%eax
10fa14: 8d 34 01 lea (%ecx,%eax,1),%esi
10fa17: 7e 20 jle 10fa39 <pipe_write+0x119>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
10fa19: 8b 03 mov (%ebx),%eax
10fa1b: 01 d0 add %edx,%eax
10fa1d: 89 c7 mov %eax,%edi
10fa1f: 8b 4d cc mov -0x34(%ebp),%ecx
10fa22: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
10fa24: 8b 03 mov (%ebx),%eax
10fa26: 8b 4d d0 mov -0x30(%ebp),%ecx
10fa29: 2b 4d cc sub -0x34(%ebp),%ecx
10fa2c: 8b 75 cc mov -0x34(%ebp),%esi
10fa2f: 03 75 d4 add -0x2c(%ebp),%esi
10fa32: 03 75 0c add 0xc(%ebp),%esi
10fa35: 89 c7 mov %eax,%edi
10fa37: eb 09 jmp 10fa42 <pipe_write+0x122>
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
10fa39: 8b 03 mov (%ebx),%eax
10fa3b: 01 d0 add %edx,%eax
10fa3d: 89 c7 mov %eax,%edi
10fa3f: 8b 4d d0 mov -0x30(%ebp),%ecx
10fa42: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
pipe->Length += chunk;
10fa44: 8b 45 d0 mov -0x30(%ebp),%eax
10fa47: 01 43 0c add %eax,0xc(%ebx)
if (pipe->waitingReaders > 0)
10fa4a: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
10fa4e: 74 11 je 10fa61 <pipe_write+0x141>
PIPE_WAKEUPREADERS(pipe);
10fa50: 51 push %ecx
10fa51: 51 push %ecx
10fa52: 8d 4d e4 lea -0x1c(%ebp),%ecx
10fa55: 51 push %ecx
10fa56: ff 73 2c pushl 0x2c(%ebx)
10fa59: e8 9e 15 00 00 call 110ffc <rtems_barrier_release>
10fa5e: 83 c4 10 add $0x10,%esp
written += chunk;
10fa61: 8b 45 d0 mov -0x30(%ebp),%eax
10fa64: 01 45 d4 add %eax,-0x2c(%ebp)
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
10fa67: 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) {
10fa6c: 8b 4d 10 mov 0x10(%ebp),%ecx
10fa6f: 39 4d d4 cmp %ecx,-0x2c(%ebp)
10fa72: 0f 82 69 ff ff ff jb 10f9e1 <pipe_write+0xc1>
10fa78: 31 f6 xor %esi,%esi
10fa7a: eb 1a jmp 10fa96 <pipe_write+0x176>
if (! PIPE_LOCK(pipe))
return -EINTR;
if (pipe->Readers == 0) {
ret = -EPIPE;
10fa7c: 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;
10fa81: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
10fa88: eb 0c jmp 10fa96 <pipe_write+0x176>
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
10fa8a: be f5 ff ff ff mov $0xfffffff5,%esi
10fa8f: eb 05 jmp 10fa96 <pipe_write+0x176>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
10fa91: 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);
10fa96: 83 ec 0c sub $0xc,%esp
10fa99: ff 73 28 pushl 0x28(%ebx)
10fa9c: e8 53 ba ff ff call 10b4f4 <rtems_semaphore_release>
10faa1: 83 c4 10 add $0x10,%esp
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
10faa4: 83 fe e0 cmp $0xffffffe0,%esi
10faa7: 75 19 jne 10fac2 <pipe_write+0x1a2>
kill(getpid(), SIGPIPE);
10faa9: e8 9e 06 00 00 call 11014c <getpid>
10faae: 52 push %edx
10faaf: 52 push %edx
10fab0: 6a 0d push $0xd
10fab2: 50 push %eax
10fab3: e8 30 0b 00 00 call 1105e8 <kill>
10fab8: 83 c4 10 add $0x10,%esp
10fabb: eb 05 jmp 10fac2 <pipe_write+0x1a2>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
10fabd: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
10fac2: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10fac6: 7f 03 jg 10facb <pipe_write+0x1ab>
10fac8: 89 75 d4 mov %esi,-0x2c(%ebp)
return written;
return ret;
}
10facb: 8b 45 d4 mov -0x2c(%ebp),%eax
10face: 8d 65 f4 lea -0xc(%ebp),%esp
10fad1: 5b pop %ebx
10fad2: 5e pop %esi
10fad3: 5f pop %edi
10fad4: c9 leave
10fad5: c3 ret
0010a788 <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
10a788: 55 push %ebp
10a789: 89 e5 mov %esp,%ebp
10a78b: 53 push %ebx
10a78c: 83 ec 04 sub $0x4,%esp
10a78f: 8b 45 0c mov 0xc(%ebp),%eax
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
10a792: ff 05 44 bb 12 00 incl 0x12bb44
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
10a798: 8d 58 ff lea -0x1(%eax),%ebx
10a79b: 85 c3 test %eax,%ebx
10a79d: 75 0d jne 10a7ac <posix_memalign+0x24> <== NEVER TAKEN
10a79f: 83 f8 03 cmp $0x3,%eax
10a7a2: 76 08 jbe 10a7ac <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 );
}
10a7a4: 59 pop %ecx
10a7a5: 5b pop %ebx
10a7a6: c9 leave
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
10a7a7: e9 74 01 00 00 jmp 10a920 <rtems_memalign>
}
10a7ac: b8 16 00 00 00 mov $0x16,%eax
10a7b1: 5a pop %edx
10a7b2: 5b pop %ebx
10a7b3: c9 leave
10a7b4: c3 ret
0010e704 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
10e704: 55 push %ebp
10e705: 89 e5 mov %esp,%ebp
10e707: 8b 55 08 mov 0x8(%ebp),%edx
10e70a: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10e70d: b8 16 00 00 00 mov $0x16,%eax
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
10e712: 85 d2 test %edx,%edx
10e714: 74 1e je 10e734 <pthread_attr_setschedpolicy+0x30>
10e716: 83 3a 00 cmpl $0x0,(%edx)
10e719: 74 19 je 10e734 <pthread_attr_setschedpolicy+0x30>
return EINVAL;
switch ( policy ) {
10e71b: 83 f9 04 cmp $0x4,%ecx
10e71e: 77 0f ja 10e72f <pthread_attr_setschedpolicy+0x2b>
10e720: b0 01 mov $0x1,%al
10e722: d3 e0 shl %cl,%eax
10e724: a8 17 test $0x17,%al
10e726: 74 07 je 10e72f <pthread_attr_setschedpolicy+0x2b><== NEVER TAKEN
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
10e728: 89 4a 14 mov %ecx,0x14(%edx)
return 0;
10e72b: 31 c0 xor %eax,%eax
10e72d: eb 05 jmp 10e734 <pthread_attr_setschedpolicy+0x30>
default:
return ENOTSUP;
10e72f: b8 86 00 00 00 mov $0x86,%eax
}
}
10e734: c9 leave
10e735: c3 ret
0010a578 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
10a578: 55 push %ebp
10a579: 89 e5 mov %esp,%ebp
10a57b: 57 push %edi
10a57c: 56 push %esi
10a57d: 53 push %ebx
10a57e: 83 ec 1c sub $0x1c,%esp
10a581: 8b 5d 08 mov 0x8(%ebp),%ebx
10a584: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Error check parameters
*/
if ( !barrier )
return EINVAL;
10a587: b8 16 00 00 00 mov $0x16,%eax
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
10a58c: 85 db test %ebx,%ebx
10a58e: 0f 84 96 00 00 00 je 10a62a <pthread_barrier_init+0xb2>
return EINVAL;
if ( count == 0 )
10a594: 85 f6 test %esi,%esi
10a596: 0f 84 8e 00 00 00 je 10a62a <pthread_barrier_init+0xb2>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10a59c: 8b 7d 0c mov 0xc(%ebp),%edi
10a59f: 85 ff test %edi,%edi
10a5a1: 75 0f jne 10a5b2 <pthread_barrier_init+0x3a>
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
10a5a3: 83 ec 0c sub $0xc,%esp
10a5a6: 8d 7d d8 lea -0x28(%ebp),%edi
10a5a9: 57 push %edi
10a5aa: e8 19 ff ff ff call 10a4c8 <pthread_barrierattr_init>
10a5af: 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;
10a5b2: 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 )
10a5b7: 83 3f 00 cmpl $0x0,(%edi)
10a5ba: 74 6e je 10a62a <pthread_barrier_init+0xb2>
return EINVAL;
switch ( the_attr->process_shared ) {
10a5bc: 83 7f 04 00 cmpl $0x0,0x4(%edi)
10a5c0: 75 68 jne 10a62a <pthread_barrier_init+0xb2><== NEVER TAKEN
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
10a5c2: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
the_attributes.maximum_count = count;
10a5c9: 89 75 e4 mov %esi,-0x1c(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a5cc: a1 f4 61 12 00 mov 0x1261f4,%eax
10a5d1: 40 inc %eax
10a5d2: a3 f4 61 12 00 mov %eax,0x1261f4
* 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 );
10a5d7: 83 ec 0c sub $0xc,%esp
10a5da: 68 c0 65 12 00 push $0x1265c0
10a5df: e8 14 1e 00 00 call 10c3f8 <_Objects_Allocate>
10a5e4: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
10a5e6: 83 c4 10 add $0x10,%esp
10a5e9: 85 c0 test %eax,%eax
10a5eb: 75 0c jne 10a5f9 <pthread_barrier_init+0x81>
_Thread_Enable_dispatch();
10a5ed: e8 0c 2a 00 00 call 10cffe <_Thread_Enable_dispatch>
return EAGAIN;
10a5f2: b8 0b 00 00 00 mov $0xb,%eax
10a5f7: eb 31 jmp 10a62a <pthread_barrier_init+0xb2>
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
10a5f9: 50 push %eax
10a5fa: 50 push %eax
10a5fb: 8d 45 e0 lea -0x20(%ebp),%eax
10a5fe: 50 push %eax
10a5ff: 8d 46 10 lea 0x10(%esi),%eax
10a602: 50 push %eax
10a603: e8 9c 14 00 00 call 10baa4 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10a608: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a60b: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a60e: 8b 15 dc 65 12 00 mov 0x1265dc,%edx
10a614: 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;
10a617: 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;
10a61e: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10a620: e8 d9 29 00 00 call 10cffe <_Thread_Enable_dispatch>
return 0;
10a625: 83 c4 10 add $0x10,%esp
10a628: 31 c0 xor %eax,%eax
}
10a62a: 8d 65 f4 lea -0xc(%ebp),%esp
10a62d: 5b pop %ebx
10a62e: 5e pop %esi
10a62f: 5f pop %edi
10a630: c9 leave
10a631: c3 ret
00109f30 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
109f30: 55 push %ebp
109f31: 89 e5 mov %esp,%ebp
109f33: 56 push %esi
109f34: 53 push %ebx
109f35: 8b 5d 08 mov 0x8(%ebp),%ebx
109f38: 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 )
109f3b: 85 db test %ebx,%ebx
109f3d: 74 4b je 109f8a <pthread_cleanup_push+0x5a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
109f3f: a1 cc 61 12 00 mov 0x1261cc,%eax
109f44: 40 inc %eax
109f45: a3 cc 61 12 00 mov %eax,0x1261cc
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
109f4a: 83 ec 0c sub $0xc,%esp
109f4d: 6a 10 push $0x10
109f4f: e8 2a 3b 00 00 call 10da7e <_Workspace_Allocate>
if ( handler ) {
109f54: 83 c4 10 add $0x10,%esp
109f57: 85 c0 test %eax,%eax
109f59: 74 24 je 109f7f <pthread_cleanup_push+0x4f><== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
109f5b: 8b 15 1c 67 12 00 mov 0x12671c,%edx
handler_stack = &thread_support->Cancellation_Handlers;
109f61: 8b 92 f8 00 00 00 mov 0xf8(%edx),%edx
109f67: 81 c2 e0 00 00 00 add $0xe0,%edx
handler->routine = routine;
109f6d: 89 58 08 mov %ebx,0x8(%eax)
handler->arg = arg;
109f70: 89 70 0c mov %esi,0xc(%eax)
_Chain_Append( handler_stack, &handler->Node );
109f73: 51 push %ecx
109f74: 51 push %ecx
109f75: 50 push %eax
109f76: 52 push %edx
109f77: e8 7c 15 00 00 call 10b4f8 <_Chain_Append>
109f7c: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
}
109f7f: 8d 65 f8 lea -0x8(%ebp),%esp
109f82: 5b pop %ebx
109f83: 5e pop %esi
109f84: c9 leave
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
109f85: e9 70 2a 00 00 jmp 10c9fa <_Thread_Enable_dispatch>
}
109f8a: 8d 65 f8 lea -0x8(%ebp),%esp
109f8d: 5b pop %ebx
109f8e: 5e pop %esi
109f8f: c9 leave
109f90: c3 ret
0010aca0 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
10aca0: 55 push %ebp
10aca1: 89 e5 mov %esp,%ebp
10aca3: 56 push %esi
10aca4: 53 push %ebx
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
10aca5: 8b 5d 0c mov 0xc(%ebp),%ebx
10aca8: 85 db test %ebx,%ebx
10acaa: 75 05 jne 10acb1 <pthread_cond_init+0x11>
else the_attr = &_POSIX_Condition_variables_Default_attributes;
10acac: bb 4c 0e 12 00 mov $0x120e4c,%ebx
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return EINVAL;
10acb1: b8 16 00 00 00 mov $0x16,%eax
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
10acb6: 83 7b 04 01 cmpl $0x1,0x4(%ebx)
10acba: 74 76 je 10ad32 <pthread_cond_init+0x92><== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
10acbc: 83 3b 00 cmpl $0x0,(%ebx)
10acbf: 74 71 je 10ad32 <pthread_cond_init+0x92>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10acc1: a1 04 74 12 00 mov 0x127404,%eax
10acc6: 40 inc %eax
10acc7: a3 04 74 12 00 mov %eax,0x127404
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
_Objects_Allocate( &_POSIX_Condition_variables_Information );
10accc: 83 ec 0c sub $0xc,%esp
10accf: 68 68 78 12 00 push $0x127868
10acd4: e8 fb 22 00 00 call 10cfd4 <_Objects_Allocate>
10acd9: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
10acdb: 83 c4 10 add $0x10,%esp
10acde: 85 c0 test %eax,%eax
10ace0: 75 0c jne 10acee <pthread_cond_init+0x4e>
_Thread_Enable_dispatch();
10ace2: e8 f3 2e 00 00 call 10dbda <_Thread_Enable_dispatch>
return ENOMEM;
10ace7: b8 0c 00 00 00 mov $0xc,%eax
10acec: eb 44 jmp 10ad32 <pthread_cond_init+0x92>
}
the_cond->process_shared = the_attr->process_shared;
10acee: 8b 43 04 mov 0x4(%ebx),%eax
10acf1: 89 46 10 mov %eax,0x10(%esi)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
10acf4: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
/* XXX some more initialization might need to go here */
_Thread_queue_Initialize(
10acfb: 6a 74 push $0x74
10acfd: 68 00 08 00 00 push $0x800
10ad02: 6a 00 push $0x0
10ad04: 8d 46 18 lea 0x18(%esi),%eax
10ad07: 50 push %eax
10ad08: e8 c7 35 00 00 call 10e2d4 <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10ad0d: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10ad10: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10ad13: 8b 15 84 78 12 00 mov 0x127884,%edx
10ad19: 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;
10ad1c: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
10ad23: 8b 55 08 mov 0x8(%ebp),%edx
10ad26: 89 02 mov %eax,(%edx)
_Thread_Enable_dispatch();
10ad28: e8 ad 2e 00 00 call 10dbda <_Thread_Enable_dispatch>
return 0;
10ad2d: 83 c4 10 add $0x10,%esp
10ad30: 31 c0 xor %eax,%eax
}
10ad32: 8d 65 f8 lea -0x8(%ebp),%esp
10ad35: 5b pop %ebx
10ad36: 5e pop %esi
10ad37: c9 leave
10ad38: c3 ret
0010ab54 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
10ab54: 55 push %ebp
10ab55: 89 e5 mov %esp,%ebp
10ab57: 8b 55 08 mov 0x8(%ebp),%edx
if ( !attr || attr->is_initialized == false )
return EINVAL;
10ab5a: b8 16 00 00 00 mov $0x16,%eax
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
10ab5f: 85 d2 test %edx,%edx
10ab61: 74 0d je 10ab70 <pthread_condattr_destroy+0x1c>
10ab63: 83 3a 00 cmpl $0x0,(%edx)
10ab66: 74 08 je 10ab70 <pthread_condattr_destroy+0x1c><== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
10ab68: c7 02 00 00 00 00 movl $0x0,(%edx)
return 0;
10ab6e: 30 c0 xor %al,%al
}
10ab70: c9 leave
10ab71: c3 ret
0010a27c <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
10a27c: 55 push %ebp
10a27d: 89 e5 mov %esp,%ebp
10a27f: 57 push %edi
10a280: 56 push %esi
10a281: 53 push %ebx
10a282: 83 ec 5c sub $0x5c,%esp
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
10a285: c7 45 b4 0e 00 00 00 movl $0xe,-0x4c(%ebp)
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
10a28c: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a290: 0f 84 0f 02 00 00 je 10a4a5 <pthread_create+0x229>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
10a296: 8b 5d 0c mov 0xc(%ebp),%ebx
10a299: 85 db test %ebx,%ebx
10a29b: 75 05 jne 10a2a2 <pthread_create+0x26>
10a29d: bb bc f9 11 00 mov $0x11f9bc,%ebx
if ( !the_attr->is_initialized )
return EINVAL;
10a2a2: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
if ( !the_attr->is_initialized )
10a2a9: 83 3b 00 cmpl $0x0,(%ebx)
10a2ac: 0f 84 f3 01 00 00 je 10a4a5 <pthread_create+0x229>
* stack space if it is allowed to allocate it itself.
*
* NOTE: If the user provides the stack we will let it drop below
* twice the minimum.
*/
if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) )
10a2b2: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a2b6: 74 0e je 10a2c6 <pthread_create+0x4a>
10a2b8: a1 14 12 12 00 mov 0x121214,%eax
10a2bd: 39 43 08 cmp %eax,0x8(%ebx)
10a2c0: 0f 82 df 01 00 00 jb 10a4a5 <pthread_create+0x229>
* If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
* inherits scheduling attributes from the creating thread. If it is
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
10a2c6: 8b 43 10 mov 0x10(%ebx),%eax
10a2c9: 83 f8 01 cmp $0x1,%eax
10a2cc: 74 0b je 10a2d9 <pthread_create+0x5d>
10a2ce: 83 f8 02 cmp $0x2,%eax
10a2d1: 0f 85 c7 01 00 00 jne 10a49e <pthread_create+0x222>
10a2d7: eb 1f jmp 10a2f8 <pthread_create+0x7c>
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a2d9: a1 24 57 12 00 mov 0x125724,%eax
10a2de: 8b b0 f8 00 00 00 mov 0xf8(%eax),%esi
schedpolicy = api->schedpolicy;
10a2e4: 8b 86 80 00 00 00 mov 0x80(%esi),%eax
10a2ea: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = api->schedparam;
10a2ed: 8d 7d c4 lea -0x3c(%ebp),%edi
10a2f0: 81 c6 84 00 00 00 add $0x84,%esi
10a2f6: eb 0c jmp 10a304 <pthread_create+0x88>
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
10a2f8: 8b 43 14 mov 0x14(%ebx),%eax
10a2fb: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = the_attr->schedparam;
10a2fe: 8d 7d c4 lea -0x3c(%ebp),%edi
10a301: 8d 73 18 lea 0x18(%ebx),%esi
10a304: b9 07 00 00 00 mov $0x7,%ecx
10a309: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
return ENOTSUP;
10a30b: c7 45 b4 86 00 00 00 movl $0x86,-0x4c(%ebp)
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
10a312: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10a316: 0f 85 89 01 00 00 jne 10a4a5 <pthread_create+0x229>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
10a31c: 83 ec 0c sub $0xc,%esp
10a31f: ff 75 c4 pushl -0x3c(%ebp)
10a322: e8 d1 57 00 00 call 10faf8 <_POSIX_Priority_Is_valid>
10a327: 83 c4 10 add $0x10,%esp
return EINVAL;
10a32a: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
10a331: 84 c0 test %al,%al
10a333: 0f 84 6c 01 00 00 je 10a4a5 <pthread_create+0x229> <== NEVER TAKEN
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
10a339: 8b 45 c4 mov -0x3c(%ebp),%eax
10a33c: 89 45 a8 mov %eax,-0x58(%ebp)
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
10a33f: 0f b6 3d 18 12 12 00 movzbl 0x121218,%edi
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
10a346: 8d 45 e0 lea -0x20(%ebp),%eax
10a349: 50 push %eax
10a34a: 8d 45 e4 lea -0x1c(%ebp),%eax
10a34d: 50 push %eax
10a34e: 8d 45 c4 lea -0x3c(%ebp),%eax
10a351: 50 push %eax
10a352: ff 75 ac pushl -0x54(%ebp)
10a355: e8 be 57 00 00 call 10fb18 <_POSIX_Thread_Translate_sched_param>
10a35a: 89 45 b4 mov %eax,-0x4c(%ebp)
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
10a35d: 83 c4 10 add $0x10,%esp
10a360: 85 c0 test %eax,%eax
10a362: 0f 85 3d 01 00 00 jne 10a4a5 <pthread_create+0x229>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10a368: 83 ec 0c sub $0xc,%esp
10a36b: ff 35 7c 52 12 00 pushl 0x12527c
10a371: e8 4e 15 00 00 call 10b8c4 <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
10a376: c7 04 24 20 54 12 00 movl $0x125420,(%esp)
10a37d: e8 b6 1e 00 00 call 10c238 <_Objects_Allocate>
10a382: 89 45 b0 mov %eax,-0x50(%ebp)
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
10a385: 83 c4 10 add $0x10,%esp
10a388: 85 c0 test %eax,%eax
10a38a: 75 05 jne 10a391 <pthread_create+0x115>
_RTEMS_Unlock_allocator();
10a38c: 83 ec 0c sub $0xc,%esp
10a38f: eb 53 jmp 10a3e4 <pthread_create+0x168>
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
10a391: 8b 4d e0 mov -0x20(%ebp),%ecx
10a394: 8b 75 e4 mov -0x1c(%ebp),%esi
10a397: 8b 53 08 mov 0x8(%ebx),%edx
10a39a: a1 14 12 12 00 mov 0x121214,%eax
10a39f: d1 e0 shl %eax
10a3a1: 39 d0 cmp %edx,%eax
10a3a3: 73 02 jae 10a3a7 <pthread_create+0x12b>
10a3a5: 89 d0 mov %edx,%eax
10a3a7: 52 push %edx
10a3a8: 6a 00 push $0x0
10a3aa: 6a 00 push $0x0
10a3ac: 51 push %ecx
10a3ad: 56 push %esi
10a3ae: 6a 01 push $0x1
10a3b0: 81 e7 ff 00 00 00 and $0xff,%edi
10a3b6: 2b 7d a8 sub -0x58(%ebp),%edi
10a3b9: 57 push %edi
10a3ba: 6a 01 push $0x1
10a3bc: 50 push %eax
10a3bd: ff 73 04 pushl 0x4(%ebx)
10a3c0: ff 75 b0 pushl -0x50(%ebp)
10a3c3: 68 20 54 12 00 push $0x125420
10a3c8: e8 07 2b 00 00 call 10ced4 <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
10a3cd: 83 c4 30 add $0x30,%esp
10a3d0: 84 c0 test %al,%al
10a3d2: 75 2a jne 10a3fe <pthread_create+0x182>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
10a3d4: 56 push %esi
10a3d5: 56 push %esi
10a3d6: ff 75 b0 pushl -0x50(%ebp)
10a3d9: 68 20 54 12 00 push $0x125420
10a3de: e8 4d 21 00 00 call 10c530 <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
10a3e3: 5b pop %ebx
10a3e4: ff 35 7c 52 12 00 pushl 0x12527c
10a3ea: e8 1d 15 00 00 call 10b90c <_API_Mutex_Unlock>
return EAGAIN;
10a3ef: 83 c4 10 add $0x10,%esp
10a3f2: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp)
10a3f9: e9 a7 00 00 00 jmp 10a4a5 <pthread_create+0x229>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10a3fe: 8b 45 b0 mov -0x50(%ebp),%eax
10a401: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx
api->Attributes = *the_attr;
10a407: b9 0f 00 00 00 mov $0xf,%ecx
10a40c: 89 d7 mov %edx,%edi
10a40e: 89 de mov %ebx,%esi
10a410: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
api->detachstate = the_attr->detachstate;
10a412: 8b 43 38 mov 0x38(%ebx),%eax
10a415: 89 42 3c mov %eax,0x3c(%edx)
api->schedpolicy = schedpolicy;
10a418: 8b 45 ac mov -0x54(%ebp),%eax
10a41b: 89 82 80 00 00 00 mov %eax,0x80(%edx)
api->schedparam = schedparam;
10a421: 8d ba 84 00 00 00 lea 0x84(%edx),%edi
10a427: 8d 75 c4 lea -0x3c(%ebp),%esi
10a42a: b1 07 mov $0x7,%cl
10a42c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
10a42e: 83 ec 0c sub $0xc,%esp
10a431: 6a 00 push $0x0
10a433: ff 75 14 pushl 0x14(%ebp)
10a436: ff 75 10 pushl 0x10(%ebp)
10a439: 6a 01 push $0x1
10a43b: ff 75 b0 pushl -0x50(%ebp)
10a43e: 89 55 a4 mov %edx,-0x5c(%ebp)
10a441: e8 16 34 00 00 call 10d85c <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
10a446: 83 c4 20 add $0x20,%esp
10a449: 83 7d ac 04 cmpl $0x4,-0x54(%ebp)
10a44d: 8b 55 a4 mov -0x5c(%ebp),%edx
10a450: 75 2e jne 10a480 <pthread_create+0x204>
_Watchdog_Insert_ticks(
10a452: 83 ec 0c sub $0xc,%esp
&api->Sporadic_timer,
_Timespec_To_ticks( &api->schedparam.sched_ss_repl_period )
10a455: 8d 82 8c 00 00 00 lea 0x8c(%edx),%eax
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
10a45b: 50 push %eax
10a45c: e8 a3 35 00 00 call 10da04 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a461: 8b 55 a4 mov -0x5c(%ebp),%edx
10a464: 89 82 b0 00 00 00 mov %eax,0xb0(%edx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a46a: 58 pop %eax
10a46b: 59 pop %ecx
10a46c: 81 c2 a4 00 00 00 add $0xa4,%edx
10a472: 52 push %edx
10a473: 68 9c 52 12 00 push $0x12529c
10a478: e8 3b 38 00 00 call 10dcb8 <_Watchdog_Insert>
10a47d: 83 c4 10 add $0x10,%esp
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
10a480: 8b 45 b0 mov -0x50(%ebp),%eax
10a483: 8b 50 08 mov 0x8(%eax),%edx
10a486: 8b 45 08 mov 0x8(%ebp),%eax
10a489: 89 10 mov %edx,(%eax)
_RTEMS_Unlock_allocator();
10a48b: 83 ec 0c sub $0xc,%esp
10a48e: ff 35 7c 52 12 00 pushl 0x12527c
10a494: e8 73 14 00 00 call 10b90c <_API_Mutex_Unlock>
return 0;
10a499: 83 c4 10 add $0x10,%esp
10a49c: eb 07 jmp 10a4a5 <pthread_create+0x229>
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
10a49e: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
10a4a5: 8b 45 b4 mov -0x4c(%ebp),%eax
10a4a8: 8d 65 f4 lea -0xc(%ebp),%esp
10a4ab: 5b pop %ebx
10a4ac: 5e pop %esi
10a4ad: 5f pop %edi
10a4ae: c9 leave
10a4af: c3 ret
00110d5c <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
110d5c: 55 push %ebp
110d5d: 89 e5 mov %esp,%ebp
110d5f: 83 ec 10 sub $0x10,%esp
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
110d62: ff 75 08 pushl 0x8(%ebp)
110d65: ff 35 34 47 12 00 pushl 0x124734
110d6b: e8 88 ff ff ff call 110cf8 <_POSIX_Thread_Exit>
110d70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
110d73: c9 leave <== NOT EXECUTED
110d74: c3 ret <== NOT EXECUTED
0010a0fc <pthread_key_create>:
int pthread_key_create(
pthread_key_t *key,
void (*destructor)( void * )
)
{
10a0fc: 55 push %ebp
10a0fd: 89 e5 mov %esp,%ebp
10a0ff: 57 push %edi
10a100: 56 push %esi
10a101: 53 push %ebx
10a102: 83 ec 28 sub $0x28,%esp
10a105: a1 34 62 12 00 mov 0x126234,%eax
10a10a: 40 inc %eax
10a10b: a3 34 62 12 00 mov %eax,0x126234
* the inactive chain of free keys control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void )
{
return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information );
10a110: 68 58 66 12 00 push $0x126658
10a115: e8 72 1f 00 00 call 10c08c <_Objects_Allocate>
10a11a: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch();
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
10a11c: 83 c4 10 add $0x10,%esp
10a11f: 85 c0 test %eax,%eax
10a121: 75 0f jne 10a132 <pthread_key_create+0x36>
_Thread_Enable_dispatch();
10a123: e8 6a 2b 00 00 call 10cc92 <_Thread_Enable_dispatch>
return EAGAIN;
10a128: b8 0b 00 00 00 mov $0xb,%eax
10a12d: e9 a9 00 00 00 jmp 10a1db <pthread_key_create+0xdf>
}
the_key->destructor = destructor;
10a132: 8b 45 0c mov 0xc(%ebp),%eax
10a135: 89 43 10 mov %eax,0x10(%ebx)
* APIs are optional.
*
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1;
10a138: be 01 00 00 00 mov $0x1,%esi
the_api <= OBJECTS_APIS_LAST;
the_api++ ) {
if ( _Objects_Information_table[ the_api ] ) {
10a13d: 8b 04 b5 0c 62 12 00 mov 0x12620c(,%esi,4),%eax
10a144: 85 c0 test %eax,%eax
10a146: 74 63 je 10a1ab <pthread_key_create+0xaf><== NEVER TAKEN
true,
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
10a148: 8b 40 04 mov 0x4(%eax),%eax
10a14b: 0f b7 40 10 movzwl 0x10(%eax),%eax
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
10a14f: 8d 0c 85 04 00 00 00 lea 0x4(,%eax,4),%ecx
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
10a156: 83 ec 0c sub $0xc,%esp
10a159: 51 push %ecx
10a15a: 89 4d e4 mov %ecx,-0x1c(%ebp)
10a15d: e8 20 3c 00 00 call 10dd82 <_Workspace_Allocate>
if ( !table ) {
10a162: 83 c4 10 add $0x10,%esp
10a165: 85 c0 test %eax,%eax
10a167: 8b 4d e4 mov -0x1c(%ebp),%ecx
10a16a: 75 33 jne 10a19f <pthread_key_create+0xa3>
for ( --the_api;
10a16c: 4e dec %esi
10a16d: eb 10 jmp 10a17f <pthread_key_create+0x83>
the_api >= 1;
the_api-- )
_Workspace_Free( the_key->Values[ the_api ] );
10a16f: 83 ec 0c sub $0xc,%esp
10a172: ff 74 b3 14 pushl 0x14(%ebx,%esi,4)
10a176: e8 20 3c 00 00 call 10dd9b <_Workspace_Free>
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
if ( !table ) {
for ( --the_api;
the_api >= 1;
the_api-- )
10a17b: 4e dec %esi
10a17c: 83 c4 10 add $0x10,%esp
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
if ( !table ) {
for ( --the_api;
10a17f: 85 f6 test %esi,%esi
10a181: 75 ec jne 10a16f <pthread_key_create+0x73>
*/
RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free (
POSIX_Keys_Control *the_key
)
{
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
10a183: 50 push %eax
10a184: 50 push %eax
10a185: 53 push %ebx
10a186: 68 58 66 12 00 push $0x126658
10a18b: e8 f4 21 00 00 call 10c384 <_Objects_Free>
the_api >= 1;
the_api-- )
_Workspace_Free( the_key->Values[ the_api ] );
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
10a190: e8 fd 2a 00 00 call 10cc92 <_Thread_Enable_dispatch>
return ENOMEM;
10a195: 83 c4 10 add $0x10,%esp
10a198: b8 0c 00 00 00 mov $0xc,%eax
10a19d: eb 3c jmp 10a1db <pthread_key_create+0xdf>
}
the_key->Values[ the_api ] = table;
10a19f: 89 44 b3 14 mov %eax,0x14(%ebx,%esi,4)
memset( table, '\0', bytes_to_allocate );
10a1a3: 89 c7 mov %eax,%edi
10a1a5: 31 c0 xor %eax,%eax
10a1a7: f3 aa rep stos %al,%es:(%edi)
10a1a9: eb 08 jmp 10a1b3 <pthread_key_create+0xb7>
} else {
the_key->Values[ the_api ] = NULL;
10a1ab: c7 44 b3 14 00 00 00 movl $0x0,0x14(%ebx,%esi,4) <== NOT EXECUTED
10a1b2: 00
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1;
the_api <= OBJECTS_APIS_LAST;
the_api++ ) {
10a1b3: 46 inc %esi
* APIs are optional.
*
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1;
10a1b4: 83 fe 04 cmp $0x4,%esi
10a1b7: 75 84 jne 10a13d <pthread_key_create+0x41>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10a1b9: 8b 43 08 mov 0x8(%ebx),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a1bc: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a1bf: 8b 15 74 66 12 00 mov 0x126674,%edx
10a1c5: 89 1c 8a mov %ebx,(%edx,%ecx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10a1c8: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
}
_Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 );
*key = the_key->Object.id;
10a1cf: 8b 55 08 mov 0x8(%ebp),%edx
10a1d2: 89 02 mov %eax,(%edx)
_Thread_Enable_dispatch();
10a1d4: e8 b9 2a 00 00 call 10cc92 <_Thread_Enable_dispatch>
return 0;
10a1d9: 31 c0 xor %eax,%eax
}
10a1db: 8d 65 f4 lea -0xc(%ebp),%esp
10a1de: 5b pop %ebx
10a1df: 5e pop %esi
10a1e0: 5f pop %edi
10a1e1: c9 leave
10a1e2: c3 ret
0010a1e4 <pthread_key_delete>:
*/
int pthread_key_delete(
pthread_key_t key
)
{
10a1e4: 55 push %ebp
10a1e5: 89 e5 mov %esp,%ebp
10a1e7: 56 push %esi
10a1e8: 53 push %ebx
10a1e9: 83 ec 14 sub $0x14,%esp
register POSIX_Keys_Control *the_key;
Objects_Locations location;
uint32_t the_api;
the_key = _POSIX_Keys_Get( key, &location );
10a1ec: 8d 45 f4 lea -0xc(%ebp),%eax
pthread_key_t id,
Objects_Locations *location
)
{
return (POSIX_Keys_Control *)
_Objects_Get( &_POSIX_Keys_Information, (Objects_Id) id, location );
10a1ef: 50 push %eax
10a1f0: ff 75 08 pushl 0x8(%ebp)
10a1f3: 68 58 66 12 00 push $0x126658
10a1f8: e8 bb 22 00 00 call 10c4b8 <_Objects_Get>
10a1fd: 89 c6 mov %eax,%esi
switch ( location ) {
10a1ff: 83 c4 10 add $0x10,%esp
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10a202: b8 16 00 00 00 mov $0x16,%eax
register POSIX_Keys_Control *the_key;
Objects_Locations location;
uint32_t the_api;
the_key = _POSIX_Keys_Get( key, &location );
switch ( location ) {
10a207: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10a20b: 75 46 jne 10a253 <pthread_key_delete+0x6f>
case OBJECTS_LOCAL:
_Objects_Close( &_POSIX_Keys_Information, &the_key->Object );
10a20d: 52 push %edx
10a20e: 52 push %edx
10a20f: 56 push %esi
10a210: 68 58 66 12 00 push $0x126658
10a215: e8 de 1e 00 00 call 10c0f8 <_Objects_Close>
10a21a: 83 c4 10 add $0x10,%esp
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ )
10a21d: bb 01 00 00 00 mov $0x1,%ebx
if ( the_key->Values[ the_api ] )
10a222: 8b 44 9e 14 mov 0x14(%esi,%ebx,4),%eax
10a226: 85 c0 test %eax,%eax
10a228: 74 0c je 10a236 <pthread_key_delete+0x52><== NEVER TAKEN
_Workspace_Free( the_key->Values[ the_api ] );
10a22a: 83 ec 0c sub $0xc,%esp
10a22d: 50 push %eax
10a22e: e8 68 3b 00 00 call 10dd9b <_Workspace_Free>
10a233: 83 c4 10 add $0x10,%esp
switch ( location ) {
case OBJECTS_LOCAL:
_Objects_Close( &_POSIX_Keys_Information, &the_key->Object );
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ )
10a236: 43 inc %ebx
10a237: 83 fb 04 cmp $0x4,%ebx
10a23a: 75 e6 jne 10a222 <pthread_key_delete+0x3e>
*/
RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free (
POSIX_Keys_Control *the_key
)
{
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
10a23c: 50 push %eax
10a23d: 50 push %eax
10a23e: 56 push %esi
10a23f: 68 58 66 12 00 push $0x126658
10a244: e8 3b 21 00 00 call 10c384 <_Objects_Free>
* NOTE: The destructor is not called and it is the responsibility
* of the application to free the memory.
*/
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
10a249: e8 44 2a 00 00 call 10cc92 <_Thread_Enable_dispatch>
return 0;
10a24e: 83 c4 10 add $0x10,%esp
10a251: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10a253: 8d 65 f8 lea -0x8(%ebp),%esp
10a256: 5b pop %ebx
10a257: 5e pop %esi
10a258: c9 leave
10a259: c3 ret
0010bfd4 <pthread_mutex_unlock>:
*/
int pthread_mutex_unlock(
pthread_mutex_t *mutex
)
{
10bfd4: 55 push %ebp
10bfd5: 89 e5 mov %esp,%ebp
10bfd7: 53 push %ebx
10bfd8: 83 ec 1c sub $0x1c,%esp
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
CORE_mutex_Status status;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
10bfdb: 8d 45 f4 lea -0xc(%ebp),%eax
10bfde: 50 push %eax
10bfdf: ff 75 08 pushl 0x8(%ebp)
10bfe2: e8 a9 fc ff ff call 10bc90 <_POSIX_Mutex_Get>
switch ( location ) {
10bfe7: 83 c4 10 add $0x10,%esp
10bfea: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10bfee: 75 23 jne 10c013 <pthread_mutex_unlock+0x3f><== NEVER TAKEN
case OBJECTS_LOCAL:
status = _CORE_mutex_Surrender(
10bff0: 52 push %edx
10bff1: 6a 00 push $0x0
10bff3: ff 70 08 pushl 0x8(%eax)
10bff6: 83 c0 14 add $0x14,%eax
10bff9: 50 push %eax
10bffa: e8 ad 19 00 00 call 10d9ac <_CORE_mutex_Surrender>
10bfff: 89 c3 mov %eax,%ebx
&the_mutex->Mutex,
the_mutex->Object.id,
NULL
);
_Thread_Enable_dispatch();
10c001: e8 20 2c 00 00 call 10ec26 <_Thread_Enable_dispatch>
return _POSIX_Mutex_Translate_core_mutex_return_code( status );
10c006: 89 1c 24 mov %ebx,(%esp)
10c009: e8 a2 ff ff ff call 10bfb0 <_POSIX_Mutex_Translate_core_mutex_return_code>
10c00e: 83 c4 10 add $0x10,%esp
10c011: eb 05 jmp 10c018 <pthread_mutex_unlock+0x44>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10c013: b8 16 00 00 00 mov $0x16,%eax
}
10c018: 8b 5d fc mov -0x4(%ebp),%ebx
10c01b: c9 leave
10c01c: c3 ret
0010bbfc <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
10bbfc: 55 push %ebp
10bbfd: 89 e5 mov %esp,%ebp
10bbff: 8b 55 08 mov 0x8(%ebp),%edx
10bc02: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10bc05: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
10bc0a: 85 d2 test %edx,%edx
10bc0c: 74 0f je 10bc1d <pthread_mutexattr_setpshared+0x21>
10bc0e: 83 3a 00 cmpl $0x0,(%edx)
10bc11: 74 0a je 10bc1d <pthread_mutexattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10bc13: 83 f9 01 cmp $0x1,%ecx
10bc16: 77 05 ja 10bc1d <pthread_mutexattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10bc18: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10bc1b: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10bc1d: c9 leave
10bc1e: c3 ret
00109e24 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
109e24: 55 push %ebp
109e25: 89 e5 mov %esp,%ebp
109e27: 8b 55 08 mov 0x8(%ebp),%edx
109e2a: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
109e2d: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
109e32: 85 d2 test %edx,%edx
109e34: 74 0f je 109e45 <pthread_mutexattr_settype+0x21>
109e36: 83 3a 00 cmpl $0x0,(%edx)
109e39: 74 0a je 109e45 <pthread_mutexattr_settype+0x21><== NEVER TAKEN
return EINVAL;
switch ( type ) {
109e3b: 83 f9 03 cmp $0x3,%ecx
109e3e: 77 05 ja 109e45 <pthread_mutexattr_settype+0x21>
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
109e40: 89 4a 10 mov %ecx,0x10(%edx)
return 0;
109e43: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
109e45: c9 leave
109e46: c3 ret
0010a8c8 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
10a8c8: 55 push %ebp
10a8c9: 89 e5 mov %esp,%ebp
10a8cb: 56 push %esi
10a8cc: 53 push %ebx
10a8cd: 83 ec 10 sub $0x10,%esp
10a8d0: 8b 5d 08 mov 0x8(%ebp),%ebx
10a8d3: 8b 75 0c mov 0xc(%ebp),%esi
if ( !once_control || !init_routine )
10a8d6: 85 f6 test %esi,%esi
10a8d8: 74 51 je 10a92b <pthread_once+0x63>
10a8da: 85 db test %ebx,%ebx
10a8dc: 74 4d je 10a92b <pthread_once+0x63>
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
10a8de: 31 c0 xor %eax,%eax
)
{
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
10a8e0: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a8e4: 75 4a jne 10a930 <pthread_once+0x68>
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
10a8e6: 52 push %edx
10a8e7: 8d 45 f4 lea -0xc(%ebp),%eax
10a8ea: 50 push %eax
10a8eb: 68 00 01 00 00 push $0x100
10a8f0: 68 00 01 00 00 push $0x100
10a8f5: e8 9e 0a 00 00 call 10b398 <rtems_task_mode>
if ( !once_control->init_executed ) {
10a8fa: 83 c4 10 add $0x10,%esp
10a8fd: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a901: 75 0f jne 10a912 <pthread_once+0x4a> <== NEVER TAKEN
once_control->is_initialized = true;
10a903: c7 03 01 00 00 00 movl $0x1,(%ebx)
once_control->init_executed = true;
10a909: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
(*init_routine)();
10a910: ff d6 call *%esi
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
10a912: 50 push %eax
10a913: 8d 45 f4 lea -0xc(%ebp),%eax
10a916: 50 push %eax
10a917: 68 00 01 00 00 push $0x100
10a91c: ff 75 f4 pushl -0xc(%ebp)
10a91f: e8 74 0a 00 00 call 10b398 <rtems_task_mode>
10a924: 83 c4 10 add $0x10,%esp
}
return 0;
10a927: 31 c0 xor %eax,%eax
10a929: eb 05 jmp 10a930 <pthread_once+0x68>
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
10a92b: b8 16 00 00 00 mov $0x16,%eax
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
10a930: 8d 65 f8 lea -0x8(%ebp),%esp
10a933: 5b pop %ebx
10a934: 5e pop %esi
10a935: c9 leave
10a936: c3 ret
0010af40 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
10af40: 55 push %ebp
10af41: 89 e5 mov %esp,%ebp
10af43: 56 push %esi
10af44: 53 push %ebx
10af45: 83 ec 10 sub $0x10,%esp
10af48: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Error check parameters
*/
if ( !rwlock )
return EINVAL;
10af4b: b8 16 00 00 00 mov $0x16,%eax
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
10af50: 85 db test %ebx,%ebx
10af52: 0f 84 84 00 00 00 je 10afdc <pthread_rwlock_init+0x9c>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10af58: 8b 75 0c mov 0xc(%ebp),%esi
10af5b: 85 f6 test %esi,%esi
10af5d: 75 0f jne 10af6e <pthread_rwlock_init+0x2e>
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
10af5f: 83 ec 0c sub $0xc,%esp
10af62: 8d 75 ec lea -0x14(%ebp),%esi
10af65: 56 push %esi
10af66: e8 55 09 00 00 call 10b8c0 <pthread_rwlockattr_init>
10af6b: 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;
10af6e: 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 )
10af73: 83 3e 00 cmpl $0x0,(%esi)
10af76: 74 64 je 10afdc <pthread_rwlock_init+0x9c><== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
10af78: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10af7c: 75 5e jne 10afdc <pthread_rwlock_init+0x9c><== NEVER TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10af7e: a1 f4 71 12 00 mov 0x1271f4,%eax
10af83: 40 inc %eax
10af84: a3 f4 71 12 00 mov %eax,0x1271f4
* 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 );
10af89: 83 ec 0c sub $0xc,%esp
10af8c: 68 00 74 12 00 push $0x127400
10af91: e8 3a 23 00 00 call 10d2d0 <_Objects_Allocate>
10af96: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
10af98: 83 c4 10 add $0x10,%esp
10af9b: 85 c0 test %eax,%eax
10af9d: 75 0c jne 10afab <pthread_rwlock_init+0x6b>
_Thread_Enable_dispatch();
10af9f: e8 32 2f 00 00 call 10ded6 <_Thread_Enable_dispatch>
return EAGAIN;
10afa4: b8 0b 00 00 00 mov $0xb,%eax
10afa9: eb 31 jmp 10afdc <pthread_rwlock_init+0x9c>
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
10afab: 50 push %eax
10afac: 50 push %eax
10afad: 8d 45 f4 lea -0xc(%ebp),%eax
10afb0: 50 push %eax
10afb1: 8d 46 10 lea 0x10(%esi),%eax
10afb4: 50 push %eax
10afb5: e8 6e 1b 00 00 call 10cb28 <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10afba: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10afbd: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10afc0: 8b 15 1c 74 12 00 mov 0x12741c,%edx
10afc6: 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;
10afc9: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
10afd0: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10afd2: e8 ff 2e 00 00 call 10ded6 <_Thread_Enable_dispatch>
return 0;
10afd7: 83 c4 10 add $0x10,%esp
10afda: 31 c0 xor %eax,%eax
}
10afdc: 8d 65 f8 lea -0x8(%ebp),%esp
10afdf: 5b pop %ebx
10afe0: 5e pop %esi
10afe1: c9 leave
10afe2: c3 ret
0010afe4 <pthread_rwlock_rdlock>:
*/
int pthread_rwlock_rdlock(
pthread_rwlock_t *rwlock
)
{
10afe4: 55 push %ebp
10afe5: 89 e5 mov %esp,%ebp
10afe7: 56 push %esi
10afe8: 53 push %ebx
10afe9: 83 ec 10 sub $0x10,%esp
10afec: 8b 5d 08 mov 0x8(%ebp),%ebx
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
return EINVAL;
10afef: be 16 00 00 00 mov $0x16,%esi
)
{
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
10aff4: 85 db test %ebx,%ebx
10aff6: 74 4b je 10b043 <pthread_rwlock_rdlock+0x5f><== NEVER TAKEN
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get (
pthread_rwlock_t *RWLock,
Objects_Locations *location
)
{
return (POSIX_RWLock_Control *) _Objects_Get(
10aff8: 50 push %eax
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10aff9: 8d 45 f4 lea -0xc(%ebp),%eax
10affc: 50 push %eax
10affd: ff 33 pushl (%ebx)
10afff: 68 00 74 12 00 push $0x127400
10b004: e8 f3 26 00 00 call 10d6fc <_Objects_Get>
switch ( location ) {
10b009: 83 c4 10 add $0x10,%esp
10b00c: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10b010: 75 31 jne 10b043 <pthread_rwlock_rdlock+0x5f>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
10b012: 83 ec 0c sub $0xc,%esp
10b015: 6a 00 push $0x0
10b017: 6a 00 push $0x0
10b019: 6a 01 push $0x1
10b01b: ff 33 pushl (%ebx)
10b01d: 83 c0 10 add $0x10,%eax
10b020: 50 push %eax
10b021: e8 36 1b 00 00 call 10cb5c <_CORE_RWLock_Obtain_for_reading>
true, /* we are willing to wait forever */
0,
NULL
);
_Thread_Enable_dispatch();
10b026: 83 c4 20 add $0x20,%esp
10b029: e8 a8 2e 00 00 call 10ded6 <_Thread_Enable_dispatch>
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b02e: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b031: a1 44 77 12 00 mov 0x127744,%eax
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b036: ff 70 34 pushl 0x34(%eax)
10b039: e8 66 01 00 00 call 10b1a4 <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b03e: 89 c6 mov %eax,%esi
10b040: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b043: 89 f0 mov %esi,%eax
10b045: 8d 65 f8 lea -0x8(%ebp),%esp
10b048: 5b pop %ebx
10b049: 5e pop %esi
10b04a: c9 leave
10b04b: c3 ret
0010b04c <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10b04c: 55 push %ebp
10b04d: 89 e5 mov %esp,%ebp
10b04f: 57 push %edi
10b050: 56 push %esi
10b051: 53 push %ebx
10b052: 83 ec 2c sub $0x2c,%esp
10b055: 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;
10b058: 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 )
10b05d: 85 ff test %edi,%edi
10b05f: 0f 84 89 00 00 00 je 10b0ee <pthread_rwlock_timedrdlock+0xa2>
*
* 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 );
10b065: 50 push %eax
10b066: 50 push %eax
10b067: 8d 45 e0 lea -0x20(%ebp),%eax
10b06a: 50 push %eax
10b06b: ff 75 0c pushl 0xc(%ebp)
10b06e: e8 09 58 00 00 call 11087c <_POSIX_Absolute_timeout_to_ticks>
10b073: 89 c6 mov %eax,%esi
10b075: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b078: 8d 45 e4 lea -0x1c(%ebp),%eax
10b07b: 50 push %eax
10b07c: ff 37 pushl (%edi)
10b07e: 68 00 74 12 00 push $0x127400
10b083: e8 74 26 00 00 call 10d6fc <_Objects_Get>
switch ( location ) {
10b088: 83 c4 10 add $0x10,%esp
10b08b: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b08f: 75 5d jne 10b0ee <pthread_rwlock_timedrdlock+0xa2>
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,
10b091: 83 fe 03 cmp $0x3,%esi
10b094: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
10b097: 83 ec 0c sub $0xc,%esp
10b09a: 6a 00 push $0x0
10b09c: ff 75 e0 pushl -0x20(%ebp)
10b09f: 0f b6 ca movzbl %dl,%ecx
10b0a2: 51 push %ecx
10b0a3: ff 37 pushl (%edi)
10b0a5: 83 c0 10 add $0x10,%eax
10b0a8: 50 push %eax
10b0a9: 88 55 d4 mov %dl,-0x2c(%ebp)
10b0ac: e8 ab 1a 00 00 call 10cb5c <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b0b1: 83 c4 20 add $0x20,%esp
10b0b4: e8 1d 2e 00 00 call 10ded6 <_Thread_Enable_dispatch>
if ( !do_wait ) {
10b0b9: 8a 55 d4 mov -0x2c(%ebp),%dl
10b0bc: 84 d2 test %dl,%dl
10b0be: 75 19 jne 10b0d9 <pthread_rwlock_timedrdlock+0x8d>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
10b0c0: a1 44 77 12 00 mov 0x127744,%eax
10b0c5: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b0c9: 75 0e jne 10b0d9 <pthread_rwlock_timedrdlock+0x8d>
switch (status) {
10b0cb: 85 f6 test %esi,%esi
10b0cd: 74 1f je 10b0ee <pthread_rwlock_timedrdlock+0xa2><== NEVER TAKEN
case POSIX_ABSOLUTE_TIMEOUT_INVALID:
return EINVAL;
case POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST:
case POSIX_ABSOLUTE_TIMEOUT_IS_NOW:
return ETIMEDOUT;
10b0cf: bb 74 00 00 00 mov $0x74,%ebx
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
switch (status) {
10b0d4: 83 fe 02 cmp $0x2,%esi
10b0d7: 76 15 jbe 10b0ee <pthread_rwlock_timedrdlock+0xa2><== ALWAYS TAKEN
break;
}
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b0d9: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b0dc: a1 44 77 12 00 mov 0x127744,%eax
break;
}
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b0e1: ff 70 34 pushl 0x34(%eax)
10b0e4: e8 bb 00 00 00 call 10b1a4 <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b0e9: 89 c3 mov %eax,%ebx
10b0eb: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b0ee: 89 d8 mov %ebx,%eax
10b0f0: 8d 65 f4 lea -0xc(%ebp),%esp
10b0f3: 5b pop %ebx
10b0f4: 5e pop %esi
10b0f5: 5f pop %edi
10b0f6: c9 leave
10b0f7: c3 ret
0010b0f8 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10b0f8: 55 push %ebp
10b0f9: 89 e5 mov %esp,%ebp
10b0fb: 57 push %edi
10b0fc: 56 push %esi
10b0fd: 53 push %ebx
10b0fe: 83 ec 2c sub $0x2c,%esp
10b101: 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;
10b104: 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 )
10b109: 85 ff test %edi,%edi
10b10b: 0f 84 89 00 00 00 je 10b19a <pthread_rwlock_timedwrlock+0xa2>
*
* 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 );
10b111: 50 push %eax
10b112: 50 push %eax
10b113: 8d 45 e0 lea -0x20(%ebp),%eax
10b116: 50 push %eax
10b117: ff 75 0c pushl 0xc(%ebp)
10b11a: e8 5d 57 00 00 call 11087c <_POSIX_Absolute_timeout_to_ticks>
10b11f: 89 c6 mov %eax,%esi
10b121: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b124: 8d 45 e4 lea -0x1c(%ebp),%eax
10b127: 50 push %eax
10b128: ff 37 pushl (%edi)
10b12a: 68 00 74 12 00 push $0x127400
10b12f: e8 c8 25 00 00 call 10d6fc <_Objects_Get>
switch ( location ) {
10b134: 83 c4 10 add $0x10,%esp
10b137: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b13b: 75 5d jne 10b19a <pthread_rwlock_timedwrlock+0xa2>
(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,
10b13d: 83 fe 03 cmp $0x3,%esi
10b140: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
10b143: 83 ec 0c sub $0xc,%esp
10b146: 6a 00 push $0x0
10b148: ff 75 e0 pushl -0x20(%ebp)
10b14b: 0f b6 ca movzbl %dl,%ecx
10b14e: 51 push %ecx
10b14f: ff 37 pushl (%edi)
10b151: 83 c0 10 add $0x10,%eax
10b154: 50 push %eax
10b155: 88 55 d4 mov %dl,-0x2c(%ebp)
10b158: e8 b7 1a 00 00 call 10cc14 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b15d: 83 c4 20 add $0x20,%esp
10b160: e8 71 2d 00 00 call 10ded6 <_Thread_Enable_dispatch>
if ( !do_wait &&
10b165: 8a 55 d4 mov -0x2c(%ebp),%dl
10b168: 84 d2 test %dl,%dl
10b16a: 75 19 jne 10b185 <pthread_rwlock_timedwrlock+0x8d>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
10b16c: a1 44 77 12 00 mov 0x127744,%eax
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
10b171: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b175: 75 0e jne 10b185 <pthread_rwlock_timedwrlock+0x8d>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
switch (status) {
10b177: 85 f6 test %esi,%esi
10b179: 74 1f je 10b19a <pthread_rwlock_timedwrlock+0xa2><== NEVER TAKEN
case POSIX_ABSOLUTE_TIMEOUT_INVALID:
return EINVAL;
case POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST:
case POSIX_ABSOLUTE_TIMEOUT_IS_NOW:
return ETIMEDOUT;
10b17b: bb 74 00 00 00 mov $0x74,%ebx
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
switch (status) {
10b180: 83 fe 02 cmp $0x2,%esi
10b183: 76 15 jbe 10b19a <pthread_rwlock_timedwrlock+0xa2><== ALWAYS TAKEN
case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:
break;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b185: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b188: a1 44 77 12 00 mov 0x127744,%eax
case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:
break;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b18d: ff 70 34 pushl 0x34(%eax)
10b190: e8 0f 00 00 00 call 10b1a4 <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b195: 89 c3 mov %eax,%ebx
10b197: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b19a: 89 d8 mov %ebx,%eax
10b19c: 8d 65 f4 lea -0xc(%ebp),%esp
10b19f: 5b pop %ebx
10b1a0: 5e pop %esi
10b1a1: 5f pop %edi
10b1a2: c9 leave
10b1a3: c3 ret
0010b8e0 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
10b8e0: 55 push %ebp
10b8e1: 89 e5 mov %esp,%ebp
10b8e3: 8b 55 08 mov 0x8(%ebp),%edx
10b8e6: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr )
return EINVAL;
10b8e9: b8 16 00 00 00 mov $0x16,%eax
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
10b8ee: 85 d2 test %edx,%edx
10b8f0: 74 0f je 10b901 <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
if ( !attr->is_initialized )
10b8f2: 83 3a 00 cmpl $0x0,(%edx)
10b8f5: 74 0a je 10b901 <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10b8f7: 83 f9 01 cmp $0x1,%ecx
10b8fa: 77 05 ja 10b901 <pthread_rwlockattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10b8fc: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10b8ff: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10b901: c9 leave
10b902: c3 ret
0010c778 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
10c778: 55 push %ebp
10c779: 89 e5 mov %esp,%ebp
10c77b: 57 push %edi
10c77c: 56 push %esi
10c77d: 53 push %ebx
10c77e: 83 ec 2c sub $0x2c,%esp
10c781: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
10c784: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp)
int rc;
/*
* Check all the parameters
*/
if ( !param )
10c78b: 85 f6 test %esi,%esi
10c78d: 0f 84 00 01 00 00 je 10c893 <pthread_setschedparam+0x11b><== NEVER TAKEN
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
10c793: 8d 45 e0 lea -0x20(%ebp),%eax
10c796: 50 push %eax
10c797: 8d 45 e4 lea -0x1c(%ebp),%eax
10c79a: 50 push %eax
10c79b: 56 push %esi
10c79c: ff 75 0c pushl 0xc(%ebp)
10c79f: e8 c4 51 00 00 call 111968 <_POSIX_Thread_Translate_sched_param>
10c7a4: 89 45 d4 mov %eax,-0x2c(%ebp)
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
10c7a7: 83 c4 10 add $0x10,%esp
10c7aa: 85 c0 test %eax,%eax
10c7ac: 0f 85 e1 00 00 00 jne 10c893 <pthread_setschedparam+0x11b><== NEVER TAKEN
10c7b2: 53 push %ebx
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _POSIX_Threads_Get( thread, &location );
10c7b3: 8d 45 dc lea -0x24(%ebp),%eax
10c7b6: 50 push %eax
10c7b7: ff 75 08 pushl 0x8(%ebp)
10c7ba: 68 80 94 12 00 push $0x129480
10c7bf: e8 88 1c 00 00 call 10e44c <_Objects_Get>
10c7c4: 89 c2 mov %eax,%edx
switch ( location ) {
10c7c6: 83 c4 10 add $0x10,%esp
10c7c9: 83 7d dc 00 cmpl $0x0,-0x24(%ebp)
10c7cd: 0f 85 b9 00 00 00 jne 10c88c <pthread_setschedparam+0x114><== NEVER TAKEN
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10c7d3: 8b 98 f8 00 00 00 mov 0xf8(%eax),%ebx
if ( api->schedpolicy == SCHED_SPORADIC )
10c7d9: 83 bb 80 00 00 00 04 cmpl $0x4,0x80(%ebx)
10c7e0: 75 18 jne 10c7fa <pthread_setschedparam+0x82>
(void) _Watchdog_Remove( &api->Sporadic_timer );
10c7e2: 83 ec 0c sub $0xc,%esp
10c7e5: 8d 83 a4 00 00 00 lea 0xa4(%ebx),%eax
10c7eb: 50 push %eax
10c7ec: 89 55 d0 mov %edx,-0x30(%ebp)
10c7ef: e8 50 34 00 00 call 10fc44 <_Watchdog_Remove>
10c7f4: 83 c4 10 add $0x10,%esp
10c7f7: 8b 55 d0 mov -0x30(%ebp),%edx
api->schedpolicy = policy;
10c7fa: 8b 45 0c mov 0xc(%ebp),%eax
10c7fd: 89 83 80 00 00 00 mov %eax,0x80(%ebx)
api->schedparam = *param;
10c803: 8d bb 84 00 00 00 lea 0x84(%ebx),%edi
10c809: b9 07 00 00 00 mov $0x7,%ecx
10c80e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_thread->budget_algorithm = budget_algorithm;
10c810: 8b 45 e4 mov -0x1c(%ebp),%eax
10c813: 89 42 7c mov %eax,0x7c(%edx)
the_thread->budget_callout = budget_callout;
10c816: 8b 45 e0 mov -0x20(%ebp),%eax
10c819: 89 82 80 00 00 00 mov %eax,0x80(%edx)
switch ( api->schedpolicy ) {
10c81f: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10c823: 78 60 js 10c885 <pthread_setschedparam+0x10d><== NEVER TAKEN
10c825: 83 7d 0c 02 cmpl $0x2,0xc(%ebp)
10c829: 7e 08 jle 10c833 <pthread_setschedparam+0xbb>
10c82b: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
10c82f: 75 54 jne 10c885 <pthread_setschedparam+0x10d><== NEVER TAKEN
10c831: eb 24 jmp 10c857 <pthread_setschedparam+0xdf>
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c833: a1 04 92 12 00 mov 0x129204,%eax
10c838: 89 42 78 mov %eax,0x78(%edx)
10c83b: 0f b6 05 18 52 12 00 movzbl 0x125218,%eax
10c842: 2b 83 84 00 00 00 sub 0x84(%ebx),%eax
the_thread->real_priority =
10c848: 89 42 18 mov %eax,0x18(%edx)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
10c84b: 51 push %ecx
10c84c: 6a 01 push $0x1
10c84e: 50 push %eax
10c84f: 52 push %edx
10c850: e8 3f 1f 00 00 call 10e794 <_Thread_Change_priority>
10c855: eb 2b jmp 10c882 <pthread_setschedparam+0x10a>
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
10c857: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
10c85d: 89 83 a0 00 00 00 mov %eax,0xa0(%ebx)
_Watchdog_Remove( &api->Sporadic_timer );
10c863: 83 ec 0c sub $0xc,%esp
10c866: 81 c3 a4 00 00 00 add $0xa4,%ebx
10c86c: 53 push %ebx
10c86d: 89 55 d0 mov %edx,-0x30(%ebp)
10c870: e8 cf 33 00 00 call 10fc44 <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
10c875: 58 pop %eax
10c876: 5a pop %edx
10c877: 8b 55 d0 mov -0x30(%ebp),%edx
10c87a: 52 push %edx
10c87b: 6a 00 push $0x0
10c87d: e8 e1 fd ff ff call 10c663 <_POSIX_Threads_Sporadic_budget_TSR>
break;
10c882: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10c885: e8 9c 23 00 00 call 10ec26 <_Thread_Enable_dispatch>
return 0;
10c88a: eb 07 jmp 10c893 <pthread_setschedparam+0x11b>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
10c88c: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp)
}
10c893: 8b 45 d4 mov -0x2c(%ebp),%eax
10c896: 8d 65 f4 lea -0xc(%ebp),%esp
10c899: 5b pop %ebx
10c89a: 5e pop %esi
10c89b: 5f pop %edi
10c89c: c9 leave
10c89d: c3 ret
0010a6a4 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
10a6a4: 55 push %ebp
10a6a5: 89 e5 mov %esp,%ebp
10a6a7: 53 push %ebx
10a6a8: 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() )
10a6ab: 83 3d 18 67 12 00 00 cmpl $0x0,0x126718
10a6b2: 75 48 jne 10a6fc <pthread_testcancel+0x58><== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a6b4: a1 1c 67 12 00 mov 0x12671c,%eax
10a6b9: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax
10a6bf: 8b 15 cc 61 12 00 mov 0x1261cc,%edx
10a6c5: 42 inc %edx
10a6c6: 89 15 cc 61 12 00 mov %edx,0x1261cc
*/
void pthread_testcancel( void )
{
POSIX_API_Control *thread_support;
bool cancel = false;
10a6cc: 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 &&
10a6ce: 83 b8 d4 00 00 00 00 cmpl $0x0,0xd4(%eax)
10a6d5: 75 0a jne 10a6e1 <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));
10a6d7: 83 b8 dc 00 00 00 00 cmpl $0x0,0xdc(%eax)
10a6de: 0f 95 c3 setne %bl
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
10a6e1: e8 14 23 00 00 call 10c9fa <_Thread_Enable_dispatch>
if ( cancel )
10a6e6: 84 db test %bl,%bl
10a6e8: 74 12 je 10a6fc <pthread_testcancel+0x58>
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
10a6ea: 50 push %eax
10a6eb: 50 push %eax
10a6ec: 6a ff push $0xffffffff
10a6ee: ff 35 1c 67 12 00 pushl 0x12671c
10a6f4: e8 5f 51 00 00 call 10f858 <_POSIX_Thread_Exit>
10a6f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
10a6fc: 8b 5d fc mov -0x4(%ebp),%ebx
10a6ff: c9 leave
10a700: c3 ret
0011ca8c <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
11ca8c: 55 push %ebp
11ca8d: 89 e5 mov %esp,%ebp
11ca8f: 56 push %esi
11ca90: 53 push %ebx
11ca91: 8b 5d 08 mov 0x8(%ebp),%ebx
11ca94: 8b 55 0c mov 0xc(%ebp),%edx
11ca97: 8b 4d 10 mov 0x10(%ebp),%ecx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11ca9a: 3b 1d 44 01 12 00 cmp 0x120144,%ebx
11caa0: 73 14 jae 11cab6 <read+0x2a> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
11caa2: 6b db 38 imul $0x38,%ebx,%ebx
11caa5: 03 1d 98 40 12 00 add 0x124098,%ebx
rtems_libio_check_is_open( iop );
11caab: 8b 73 14 mov 0x14(%ebx),%esi
11caae: f7 c6 00 01 00 00 test $0x100,%esi
11cab4: 75 0d jne 11cac3 <read+0x37>
11cab6: e8 99 46 ff ff call 111154 <__errno>
11cabb: c7 00 09 00 00 00 movl $0x9,(%eax)
11cac1: eb 1a jmp 11cadd <read+0x51>
rtems_libio_check_buffer( buffer );
11cac3: 85 d2 test %edx,%edx
11cac5: 74 0b je 11cad2 <read+0x46> <== NEVER TAKEN
rtems_libio_check_count( count );
11cac7: 31 c0 xor %eax,%eax
11cac9: 85 c9 test %ecx,%ecx
11cacb: 74 31 je 11cafe <read+0x72> <== NEVER TAKEN
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
11cacd: 83 e6 02 and $0x2,%esi
11cad0: 75 10 jne 11cae2 <read+0x56> <== ALWAYS TAKEN
11cad2: e8 7d 46 ff ff call 111154 <__errno> <== NOT EXECUTED
11cad7: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
11cadd: 83 c8 ff or $0xffffffff,%eax
11cae0: eb 1c jmp 11cafe <read+0x72>
return 0;
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
11cae2: 50 push %eax
11cae3: 8b 43 20 mov 0x20(%ebx),%eax
11cae6: 51 push %ecx
11cae7: 52 push %edx
11cae8: 53 push %ebx
11cae9: ff 50 08 call *0x8(%eax)
if ( rc > 0 )
11caec: 83 c4 10 add $0x10,%esp
11caef: 85 c0 test %eax,%eax
11caf1: 7e 0b jle 11cafe <read+0x72>
iop->offset += rc;
11caf3: 89 c1 mov %eax,%ecx
11caf5: c1 f9 1f sar $0x1f,%ecx
11caf8: 01 43 0c add %eax,0xc(%ebx)
11cafb: 11 4b 10 adc %ecx,0x10(%ebx)
return rc;
}
11cafe: 8d 65 f8 lea -0x8(%ebp),%esp
11cb01: 5b pop %ebx
11cb02: 5e pop %esi
11cb03: c9 leave
11cb04: c3 ret
00109df4 <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
109df4: 55 push %ebp
109df5: 89 e5 mov %esp,%ebp
109df7: 57 push %edi
109df8: 56 push %esi
109df9: 53 push %ebx
109dfa: 83 ec 2c sub $0x2c,%esp
109dfd: 8b 55 08 mov 0x8(%ebp),%edx
109e00: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
109e03: 85 db test %ebx,%ebx
109e05: 75 10 jne 109e17 <readlink+0x23> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EFAULT );
109e07: e8 f4 99 00 00 call 113800 <__errno> <== NOT EXECUTED
109e0c: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
109e12: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED
109e15: eb 69 jmp 109e80 <readlink+0x8c> <== NOT EXECUTED
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
109e17: 31 c0 xor %eax,%eax
109e19: 83 c9 ff or $0xffffffff,%ecx
109e1c: 89 d7 mov %edx,%edi
109e1e: f2 ae repnz scas %es:(%edi),%al
109e20: f7 d1 not %ecx
109e22: 49 dec %ecx
109e23: 83 ec 0c sub $0xc,%esp
109e26: 6a 00 push $0x0
109e28: 8d 75 d4 lea -0x2c(%ebp),%esi
109e2b: 56 push %esi
109e2c: 6a 00 push $0x0
109e2e: 51 push %ecx
109e2f: 52 push %edx
109e30: e8 30 f0 ff ff call 108e65 <rtems_filesystem_evaluate_path>
0, &loc, false );
if ( result != 0 )
109e35: 83 c4 20 add $0x20,%esp
return -1;
109e38: 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 )
109e3b: 85 c0 test %eax,%eax
109e3d: 75 41 jne 109e80 <readlink+0x8c> <== NEVER TAKEN
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
109e3f: 83 ec 0c sub $0xc,%esp
109e42: 56 push %esi
109e43: 8b 45 e0 mov -0x20(%ebp),%eax
109e46: ff 50 10 call *0x10(%eax)
109e49: 83 c4 10 add $0x10,%esp
109e4c: 83 f8 04 cmp $0x4,%eax
109e4f: 74 16 je 109e67 <readlink+0x73>
rtems_filesystem_freenode( &loc );
109e51: 83 ec 0c sub $0xc,%esp
109e54: 56 push %esi
109e55: e8 f2 f0 ff ff call 108f4c <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EINVAL );
109e5a: e8 a1 99 00 00 call 113800 <__errno>
109e5f: c7 00 16 00 00 00 movl $0x16,(%eax)
109e65: eb 16 jmp 109e7d <readlink+0x89>
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
109e67: 50 push %eax
109e68: ff 75 10 pushl 0x10(%ebp)
109e6b: 53 push %ebx
109e6c: 56 push %esi
109e6d: 8b 45 e0 mov -0x20(%ebp),%eax
109e70: ff 50 3c call *0x3c(%eax)
109e73: 89 c7 mov %eax,%edi
rtems_filesystem_freenode( &loc );
109e75: 89 34 24 mov %esi,(%esp)
109e78: e8 cf f0 ff ff call 108f4c <rtems_filesystem_freenode>
return result;
109e7d: 83 c4 10 add $0x10,%esp
}
109e80: 89 f8 mov %edi,%eax
109e82: 8d 65 f4 lea -0xc(%ebp),%esp
109e85: 5b pop %ebx
109e86: 5e pop %esi
109e87: 5f pop %edi
109e88: c9 leave
109e89: c3 ret
00108c04 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
108c04: 55 push %ebp
108c05: 89 e5 mov %esp,%ebp
108c07: 57 push %edi
108c08: 56 push %esi
108c09: 53 push %ebx
108c0a: 83 ec 2c sub $0x2c,%esp
108c0d: 8b 75 08 mov 0x8(%ebp),%esi
108c10: 8b 7d 0c mov 0xc(%ebp),%edi
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
108c13: 3b 35 c4 22 12 00 cmp 0x1222c4,%esi
108c19: 73 11 jae 108c2c <readv+0x28>
iop = rtems_libio_iop( fd );
108c1b: 6b f6 38 imul $0x38,%esi,%esi
108c1e: 03 35 18 62 12 00 add 0x126218,%esi
rtems_libio_check_is_open( iop );
108c24: 8b 46 14 mov 0x14(%esi),%eax
108c27: f6 c4 01 test $0x1,%ah
108c2a: 75 10 jne 108c3c <readv+0x38>
108c2c: e8 f3 90 00 00 call 111d24 <__errno>
108c31: c7 00 09 00 00 00 movl $0x9,(%eax)
108c37: e9 a4 00 00 00 jmp 108ce0 <readv+0xdc>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
108c3c: a8 02 test $0x2,%al
108c3e: 74 35 je 108c75 <readv+0x71> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
108c40: 85 ff test %edi,%edi
108c42: 74 31 je 108c75 <readv+0x71>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
108c44: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
108c48: 7e 2b jle 108c75 <readv+0x71>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
108c4a: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp)
108c51: 7f 22 jg 108c75 <readv+0x71> <== NEVER TAKEN
108c53: b2 01 mov $0x1,%dl
108c55: 31 c0 xor %eax,%eax
108c57: 31 c9 xor %ecx,%ecx
108c59: 89 75 d4 mov %esi,-0x2c(%ebp)
108c5c: eb 03 jmp 108c61 <readv+0x5d>
if ( iov[v].iov_len < 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
108c5e: 8b 4d e4 mov -0x1c(%ebp),%ecx
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
ssize_t old;
if ( !iov[v].iov_base )
108c61: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8)
108c65: 74 0e je 108c75 <readv+0x71>
if ( iov[v].iov_len < 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
108c67: 8b 5c c7 04 mov 0x4(%edi,%eax,8),%ebx
108c6b: 8d 34 19 lea (%ecx,%ebx,1),%esi
108c6e: 89 75 e4 mov %esi,-0x1c(%ebp)
if ( total < old )
108c71: 39 ce cmp %ecx,%esi
108c73: 7d 0d jge 108c82 <readv+0x7e>
rtems_set_errno_and_return_minus_one( EINVAL );
108c75: e8 aa 90 00 00 call 111d24 <__errno>
108c7a: c7 00 16 00 00 00 movl $0x16,(%eax)
108c80: eb 5e jmp 108ce0 <readv+0xdc>
if ( iov[v].iov_len )
all_zeros = false;
108c82: 85 db test %ebx,%ebx
108c84: 0f 94 c1 sete %cl
108c87: f7 d9 neg %ecx
108c89: 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++ ) {
108c8b: 40 inc %eax
108c8c: 3b 45 10 cmp 0x10(%ebp),%eax
108c8f: 7c cd jl 108c5e <readv+0x5a>
108c91: 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;
108c94: 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 ) {
108c96: 84 d2 test %dl,%dl
108c98: 75 49 jne 108ce3 <readv+0xdf>
108c9a: 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)(
108ca1: 50 push %eax
108ca2: 8b 46 20 mov 0x20(%esi),%eax
108ca5: 8b 55 e4 mov -0x1c(%ebp),%edx
108ca8: ff 74 d7 04 pushl 0x4(%edi,%edx,8)
108cac: ff 34 d7 pushl (%edi,%edx,8)
108caf: 56 push %esi
108cb0: ff 50 08 call *0x8(%eax)
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
108cb3: 83 c4 10 add $0x10,%esp
108cb6: 83 f8 00 cmp $0x0,%eax
108cb9: 7c 25 jl 108ce0 <readv+0xdc> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
108cbb: 74 0d je 108cca <readv+0xc6> <== NEVER TAKEN
iop->offset += bytes;
108cbd: 89 c1 mov %eax,%ecx
108cbf: c1 f9 1f sar $0x1f,%ecx
108cc2: 01 46 0c add %eax,0xc(%esi)
108cc5: 11 4e 10 adc %ecx,0x10(%esi)
total += bytes;
108cc8: 01 c3 add %eax,%ebx
}
if (bytes != iov[ v ].iov_len)
108cca: 8b 55 e4 mov -0x1c(%ebp),%edx
108ccd: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax
108cd1: 75 10 jne 108ce3 <readv+0xdf> <== NEVER TAKEN
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
108cd3: 42 inc %edx
108cd4: 89 55 e4 mov %edx,-0x1c(%ebp)
108cd7: 8b 45 10 mov 0x10(%ebp),%eax
108cda: 39 c2 cmp %eax,%edx
108cdc: 7c c3 jl 108ca1 <readv+0x9d>
108cde: eb 03 jmp 108ce3 <readv+0xdf>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
108ce0: 83 cb ff or $0xffffffff,%ebx
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
108ce3: 89 d8 mov %ebx,%eax
108ce5: 8d 65 f4 lea -0xc(%ebp),%esp
108ce8: 5b pop %ebx
108ce9: 5e pop %esi
108cea: 5f pop %edi
108ceb: c9 leave
108cec: c3 ret
0011cb84 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
11cb84: 55 push %ebp
11cb85: 89 e5 mov %esp,%ebp
11cb87: 57 push %edi
11cb88: 56 push %esi
11cb89: 53 push %ebx
11cb8a: 83 ec 2c sub $0x2c,%esp
11cb8d: 8b 5d 08 mov 0x8(%ebp),%ebx
11cb90: 8b 75 0c mov 0xc(%ebp),%esi
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
11cb93: ff 05 c0 40 12 00 incl 0x1240c0
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
11cb99: 83 3d 64 43 12 00 03 cmpl $0x3,0x124364
11cba0: 75 1a jne 11cbbc <realloc+0x38> <== NEVER TAKEN
if (_Thread_Dispatch_disable_level > 0)
11cba2: a1 e4 41 12 00 mov 0x1241e4,%eax
11cba7: 85 c0 test %eax,%eax
11cba9: 0f 85 ad 00 00 00 jne 11cc5c <realloc+0xd8> <== NEVER TAKEN
return (void *) 0;
if (_ISR_Nest_level > 0)
11cbaf: 83 3d 30 47 12 00 00 cmpl $0x0,0x124730
11cbb6: 0f 85 a0 00 00 00 jne 11cc5c <realloc+0xd8> <== NEVER TAKEN
}
/*
* Continue with realloc().
*/
if ( !ptr )
11cbbc: 85 db test %ebx,%ebx
11cbbe: 75 13 jne 11cbd3 <realloc+0x4f>
return malloc( size );
11cbc0: 83 ec 0c sub $0xc,%esp
11cbc3: 56 push %esi
11cbc4: e8 b7 a9 fe ff call 107580 <malloc>
11cbc9: 89 c3 mov %eax,%ebx
11cbcb: 83 c4 10 add $0x10,%esp
11cbce: e9 8b 00 00 00 jmp 11cc5e <realloc+0xda>
if ( !size ) {
11cbd3: 85 f6 test %esi,%esi
11cbd5: 75 0e jne 11cbe5 <realloc+0x61> <== ALWAYS TAKEN
free( ptr );
11cbd7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
11cbda: 53 push %ebx <== NOT EXECUTED
11cbdb: e8 04 a7 fe ff call 1072e4 <free> <== NOT EXECUTED
return (void *) 0;
11cbe0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
11cbe3: eb 77 jmp 11cc5c <realloc+0xd8> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
11cbe5: 52 push %edx
11cbe6: 8d 45 e4 lea -0x1c(%ebp),%eax
11cbe9: 50 push %eax
11cbea: 53 push %ebx
11cbeb: ff 35 50 01 12 00 pushl 0x120150
11cbf1: e8 ee 00 00 00 call 11cce4 <_Protected_heap_Get_block_size>
11cbf6: 83 c4 10 add $0x10,%esp
11cbf9: 84 c0 test %al,%al
11cbfb: 75 0d jne 11cc0a <realloc+0x86>
errno = EINVAL;
11cbfd: e8 52 45 ff ff call 111154 <__errno>
11cc02: c7 00 16 00 00 00 movl $0x16,(%eax)
11cc08: eb 52 jmp 11cc5c <realloc+0xd8>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
11cc0a: 50 push %eax
11cc0b: 56 push %esi
11cc0c: 53 push %ebx
11cc0d: ff 35 50 01 12 00 pushl 0x120150
11cc13: e8 04 01 00 00 call 11cd1c <_Protected_heap_Resize_block>
11cc18: 83 c4 10 add $0x10,%esp
11cc1b: 84 c0 test %al,%al
11cc1d: 75 3f jne 11cc5e <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 );
11cc1f: 83 ec 0c sub $0xc,%esp
11cc22: 56 push %esi
11cc23: e8 58 a9 fe ff call 107580 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
11cc28: ff 0d b4 40 12 00 decl 0x1240b4
if ( !new_area ) {
11cc2e: 83 c4 10 add $0x10,%esp
11cc31: 85 c0 test %eax,%eax
11cc33: 74 27 je 11cc5c <realloc+0xd8>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
11cc35: 8b 55 e4 mov -0x1c(%ebp),%edx
11cc38: 89 f1 mov %esi,%ecx
11cc3a: 39 d6 cmp %edx,%esi
11cc3c: 76 02 jbe 11cc40 <realloc+0xbc> <== NEVER TAKEN
11cc3e: 89 d1 mov %edx,%ecx
11cc40: 89 c7 mov %eax,%edi
11cc42: 89 de mov %ebx,%esi
11cc44: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
free( ptr );
11cc46: 83 ec 0c sub $0xc,%esp
11cc49: 53 push %ebx
11cc4a: 89 45 d4 mov %eax,-0x2c(%ebp)
11cc4d: e8 92 a6 fe ff call 1072e4 <free>
return new_area;
11cc52: 83 c4 10 add $0x10,%esp
11cc55: 8b 45 d4 mov -0x2c(%ebp),%eax
11cc58: 89 c3 mov %eax,%ebx
11cc5a: eb 02 jmp 11cc5e <realloc+0xda>
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
11cc5c: 31 db xor %ebx,%ebx
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
11cc5e: 89 d8 mov %ebx,%eax
11cc60: 8d 65 f4 lea -0xc(%ebp),%esp
11cc63: 5b pop %ebx
11cc64: 5e pop %esi
11cc65: 5f pop %edi
11cc66: c9 leave
11cc67: c3 ret
00108d84 <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
108d84: 55 push %ebp
108d85: 89 e5 mov %esp,%ebp
108d87: 57 push %edi
108d88: 56 push %esi
108d89: 53 push %ebx
108d8a: 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 );
108d8d: ff 75 08 pushl 0x8(%ebp)
108d90: e8 5d ef ff ff call 107cf2 <rtems_filesystem_dirname>
108d95: 89 45 b4 mov %eax,-0x4c(%ebp)
if ( parentpathlen == 0 )
108d98: 83 c4 10 add $0x10,%esp
108d9b: 85 c0 test %eax,%eax
108d9d: 8d 45 d0 lea -0x30(%ebp),%eax
108da0: 75 15 jne 108db7 <rmdir+0x33>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
108da2: 51 push %ecx
108da3: 50 push %eax
108da4: 8d 45 e4 lea -0x1c(%ebp),%eax
108da7: 50 push %eax
108da8: ff 75 08 pushl 0x8(%ebp)
108dab: e8 08 01 00 00 call 108eb8 <rtems_filesystem_get_start_loc>
108db0: 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;
108db3: 31 db xor %ebx,%ebx
108db5: eb 25 jmp 108ddc <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,
108db7: 83 ec 0c sub $0xc,%esp
108dba: 6a 00 push $0x0
108dbc: 50 push %eax
108dbd: 6a 02 push $0x2
108dbf: ff 75 b4 pushl -0x4c(%ebp)
108dc2: ff 75 08 pushl 0x8(%ebp)
108dc5: e8 bf ee ff ff call 107c89 <rtems_filesystem_evaluate_path>
108dca: 89 c2 mov %eax,%edx
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
108dcc: 83 c4 20 add $0x20,%esp
return -1;
108dcf: 83 c8 ff or $0xffffffff,%eax
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
108dd2: 85 d2 test %edx,%edx
108dd4: 0f 85 d6 00 00 00 jne 108eb0 <rmdir+0x12c> <== NEVER TAKEN
return -1;
free_parentloc = true;
108dda: b3 01 mov $0x1,%bl
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
108ddc: 8d 7d bc lea -0x44(%ebp),%edi
108ddf: 8d 75 d0 lea -0x30(%ebp),%esi
108de2: b9 05 00 00 00 mov $0x5,%ecx
108de7: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = pathname + parentpathlen;
108de9: 8b 75 08 mov 0x8(%ebp),%esi
108dec: 03 75 b4 add -0x4c(%ebp),%esi
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
108def: 83 c9 ff or $0xffffffff,%ecx
108df2: 89 f7 mov %esi,%edi
108df4: 31 c0 xor %eax,%eax
108df6: f2 ae repnz scas %es:(%edi),%al
108df8: f7 d1 not %ecx
108dfa: 49 dec %ecx
108dfb: 52 push %edx
108dfc: 52 push %edx
108dfd: 51 push %ecx
108dfe: 56 push %esi
108dff: e8 2d ef ff ff call 107d31 <rtems_filesystem_prefix_separators>
108e04: 01 c6 add %eax,%esi
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
108e06: 83 c9 ff or $0xffffffff,%ecx
108e09: 89 f7 mov %esi,%edi
108e0b: 31 c0 xor %eax,%eax
108e0d: f2 ae repnz scas %es:(%edi),%al
108e0f: f7 d1 not %ecx
108e11: 49 dec %ecx
108e12: c7 04 24 00 00 00 00 movl $0x0,(%esp)
108e19: 8d 7d bc lea -0x44(%ebp),%edi
108e1c: 57 push %edi
108e1d: 6a 00 push $0x0
108e1f: 51 push %ecx
108e20: 56 push %esi
108e21: e8 de ed ff ff call 107c04 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
108e26: 83 c4 20 add $0x20,%esp
108e29: 85 c0 test %eax,%eax
108e2b: 74 13 je 108e40 <rmdir+0xbc>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
108e2d: 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 )
108e30: 84 db test %bl,%bl
108e32: 74 7c je 108eb0 <rmdir+0x12c> <== ALWAYS TAKEN
rtems_filesystem_freenode( &parentloc );
108e34: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108e37: 8d 55 d0 lea -0x30(%ebp),%edx <== NOT EXECUTED
108e3a: 52 push %edx <== NOT EXECUTED
108e3b: 89 45 b0 mov %eax,-0x50(%ebp) <== NOT EXECUTED
108e3e: eb 65 jmp 108ea5 <rmdir+0x121> <== NOT EXECUTED
}
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ){
108e40: 83 ec 0c sub $0xc,%esp
108e43: 57 push %edi
108e44: 8b 45 c8 mov -0x38(%ebp),%eax
108e47: ff 50 10 call *0x10(%eax)
108e4a: 83 c4 10 add $0x10,%esp
108e4d: 48 dec %eax
108e4e: 74 2f je 108e7f <rmdir+0xfb>
rtems_filesystem_freenode( &loc );
108e50: 83 ec 0c sub $0xc,%esp
108e53: 57 push %edi
108e54: e8 bb f0 ff ff call 107f14 <rtems_filesystem_freenode>
if ( free_parentloc )
108e59: 83 c4 10 add $0x10,%esp
108e5c: 84 db test %bl,%bl
108e5e: 74 0f je 108e6f <rmdir+0xeb> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
108e60: 83 ec 0c sub $0xc,%esp
108e63: 8d 45 d0 lea -0x30(%ebp),%eax
108e66: 50 push %eax
108e67: e8 a8 f0 ff ff call 107f14 <rtems_filesystem_freenode>
108e6c: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( ENOTDIR );
108e6f: e8 e8 90 00 00 call 111f5c <__errno>
108e74: c7 00 14 00 00 00 movl $0x14,(%eax)
108e7a: 83 c8 ff or $0xffffffff,%eax
108e7d: eb 31 jmp 108eb0 <rmdir+0x12c>
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
108e7f: 50 push %eax
108e80: 50 push %eax
108e81: 57 push %edi
108e82: 8d 75 d0 lea -0x30(%ebp),%esi
108e85: 56 push %esi
108e86: 8b 45 c4 mov -0x3c(%ebp),%eax
108e89: ff 50 34 call *0x34(%eax)
rtems_filesystem_freenode( &loc );
108e8c: 89 3c 24 mov %edi,(%esp)
108e8f: 89 45 b0 mov %eax,-0x50(%ebp)
108e92: e8 7d f0 ff ff call 107f14 <rtems_filesystem_freenode>
if ( free_parentloc )
108e97: 83 c4 10 add $0x10,%esp
108e9a: 84 db test %bl,%bl
108e9c: 8b 45 b0 mov -0x50(%ebp),%eax
108e9f: 74 0f je 108eb0 <rmdir+0x12c>
rtems_filesystem_freenode( &parentloc );
108ea1: 83 ec 0c sub $0xc,%esp
108ea4: 56 push %esi
108ea5: e8 6a f0 ff ff call 107f14 <rtems_filesystem_freenode>
108eaa: 83 c4 10 add $0x10,%esp
108ead: 8b 45 b0 mov -0x50(%ebp),%eax
return result;
}
108eb0: 8d 65 f4 lea -0xc(%ebp),%esp
108eb3: 5b pop %ebx
108eb4: 5e pop %esi
108eb5: 5f pop %edi
108eb6: c9 leave
108eb7: c3 ret
00106e94 <rtems_bsp_cmdline_get_param>:
const char *rtems_bsp_cmdline_get_param(
const char *name,
char *value,
size_t length
)
{
106e94: 55 push %ebp
106e95: 89 e5 mov %esp,%ebp
106e97: 57 push %edi
106e98: 56 push %esi
106e99: 53 push %ebx
106e9a: 83 ec 0c sub $0xc,%esp
106e9d: 8b 45 08 mov 0x8(%ebp),%eax
106ea0: 8b 5d 0c mov 0xc(%ebp),%ebx
106ea3: 8b 75 10 mov 0x10(%ebp),%esi
const char *p;
if ( !name )
106ea6: 85 c0 test %eax,%eax
106ea8: 74 4c je 106ef6 <rtems_bsp_cmdline_get_param+0x62>
return NULL;
if ( !value )
106eaa: 85 db test %ebx,%ebx
106eac: 74 4a je 106ef8 <rtems_bsp_cmdline_get_param+0x64>
return NULL;
if ( !length )
106eae: 85 f6 test %esi,%esi
106eb0: 74 44 je 106ef6 <rtems_bsp_cmdline_get_param+0x62>
return NULL;
value[0] = '\0';
106eb2: c6 03 00 movb $0x0,(%ebx)
p = rtems_bsp_cmdline_get_param_raw( name );
106eb5: 83 ec 0c sub $0xc,%esp
106eb8: 50 push %eax
106eb9: e8 46 00 00 00 call 106f04 <rtems_bsp_cmdline_get_param_raw>
if ( !p )
106ebe: 83 c4 10 add $0x10,%esp
106ec1: 85 c0 test %eax,%eax
106ec3: 74 31 je 106ef6 <rtems_bsp_cmdline_get_param+0x62>
106ec5: 31 ff xor %edi,%edi
106ec7: 31 d2 xor %edx,%edx
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
106ec9: 4e dec %esi
106eca: eb 1d jmp 106ee9 <rtems_bsp_cmdline_get_param+0x55>
if ( *p == '\"' ) {
106ecc: 80 f9 22 cmp $0x22,%cl
106ecf: 75 03 jne 106ed4 <rtems_bsp_cmdline_get_param+0x40>
quotes++;
106ed1: 47 inc %edi
106ed2: eb 0d jmp 106ee1 <rtems_bsp_cmdline_get_param+0x4d>
} else if ( ((quotes % 2) == 0) && *p == ' ' )
106ed4: f7 c7 01 00 00 00 test $0x1,%edi
106eda: 75 05 jne 106ee1 <rtems_bsp_cmdline_get_param+0x4d>
106edc: 80 f9 20 cmp $0x20,%cl
106edf: 74 17 je 106ef8 <rtems_bsp_cmdline_get_param+0x64>
break;
value[i++] = *p++;
106ee1: 88 0c 13 mov %cl,(%ebx,%edx,1)
106ee4: 42 inc %edx
value[i] = '\0';
106ee5: c6 04 13 00 movb $0x0,(%ebx,%edx,1)
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
106ee9: 8a 0c 10 mov (%eax,%edx,1),%cl
106eec: 84 c9 test %cl,%cl
106eee: 74 08 je 106ef8 <rtems_bsp_cmdline_get_param+0x64>
106ef0: 39 f2 cmp %esi,%edx
106ef2: 72 d8 jb 106ecc <rtems_bsp_cmdline_get_param+0x38><== ALWAYS TAKEN
106ef4: eb 02 jmp 106ef8 <rtems_bsp_cmdline_get_param+0x64><== NOT EXECUTED
value[0] = '\0';
p = rtems_bsp_cmdline_get_param_raw( name );
if ( !p )
return NULL;
106ef6: 31 db xor %ebx,%ebx
copy_string( p, value, length );
return value;
}
106ef8: 89 d8 mov %ebx,%eax
106efa: 8d 65 f4 lea -0xc(%ebp),%esp
106efd: 5b pop %ebx
106efe: 5e pop %esi
106eff: 5f pop %edi
106f00: c9 leave
106f01: c3 ret
00106f2c <rtems_bsp_cmdline_get_param_rhs>:
const char *rtems_bsp_cmdline_get_param_rhs(
const char *name,
char *value,
size_t length
)
{
106f2c: 55 push %ebp
106f2d: 89 e5 mov %esp,%ebp
106f2f: 57 push %edi
106f30: 53 push %ebx
106f31: 8b 7d 08 mov 0x8(%ebp),%edi
106f34: 8b 5d 0c mov 0xc(%ebp),%ebx
const char *p;
const char *rhs;
char *d;
p = rtems_bsp_cmdline_get_param( name, value, length );
106f37: 50 push %eax
106f38: ff 75 10 pushl 0x10(%ebp)
106f3b: 53 push %ebx
106f3c: 57 push %edi
106f3d: e8 52 ff ff ff call 106e94 <rtems_bsp_cmdline_get_param>
106f42: 89 c2 mov %eax,%edx
if ( !p )
106f44: 83 c4 10 add $0x10,%esp
106f47: 85 c0 test %eax,%eax
106f49: 74 3c je 106f87 <rtems_bsp_cmdline_get_param_rhs+0x5b>
return NULL;
rhs = &p[strlen(name)];
106f4b: 31 c0 xor %eax,%eax
106f4d: 83 c9 ff or $0xffffffff,%ecx
106f50: f2 ae repnz scas %es:(%edi),%al
106f52: f7 d1 not %ecx
106f54: 8d 44 0a ff lea -0x1(%edx,%ecx,1),%eax
if ( *rhs != '=' )
106f58: 80 38 3d cmpb $0x3d,(%eax)
106f5b: 75 2a jne 106f87 <rtems_bsp_cmdline_get_param_rhs+0x5b><== NEVER TAKEN
return NULL;
rhs++;
106f5d: 8d 50 01 lea 0x1(%eax),%edx
if ( *rhs == '\"' )
106f60: 80 78 01 22 cmpb $0x22,0x1(%eax)
106f64: 75 03 jne 106f69 <rtems_bsp_cmdline_get_param_rhs+0x3d>
rhs++;
106f66: 8d 50 02 lea 0x2(%eax),%edx
const char *rtems_bsp_cmdline_get_param_rhs(
const char *name,
char *value,
size_t length
)
{
106f69: 89 d8 mov %ebx,%eax
106f6b: eb 04 jmp 106f71 <rtems_bsp_cmdline_get_param_rhs+0x45>
rhs++;
if ( *rhs == '\"' )
rhs++;
for ( d=value ; *rhs ; )
*d++ = *rhs++;
106f6d: 88 08 mov %cl,(%eax)
106f6f: 40 inc %eax
106f70: 42 inc %edx
return NULL;
rhs++;
if ( *rhs == '\"' )
rhs++;
for ( d=value ; *rhs ; )
106f71: 8a 0a mov (%edx),%cl
106f73: 84 c9 test %cl,%cl
106f75: 75 f6 jne 106f6d <rtems_bsp_cmdline_get_param_rhs+0x41>
*d++ = *rhs++;
if ( *(d-1) == '\"' )
106f77: 8d 50 ff lea -0x1(%eax),%edx
106f7a: 80 78 ff 22 cmpb $0x22,-0x1(%eax)
106f7e: 74 02 je 106f82 <rtems_bsp_cmdline_get_param_rhs+0x56>
106f80: 89 c2 mov %eax,%edx
d--;
*d = '\0';
106f82: c6 02 00 movb $0x0,(%edx)
return value;
106f85: eb 02 jmp 106f89 <rtems_bsp_cmdline_get_param_rhs+0x5d>
if ( !p )
return NULL;
rhs = &p[strlen(name)];
if ( *rhs != '=' )
return NULL;
106f87: 31 db xor %ebx,%ebx
if ( *(d-1) == '\"' )
d--;
*d = '\0';
return value;
}
106f89: 89 d8 mov %ebx,%eax
106f8b: 8d 65 f8 lea -0x8(%ebp),%esp
106f8e: 5b pop %ebx
106f8f: 5f pop %edi
106f90: c9 leave
106f91: c3 ret
001075c8 <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
1075c8: 55 push %ebp
1075c9: 89 e5 mov %esp,%ebp
1075cb: 57 push %edi
1075cc: 56 push %esi
1075cd: 53 push %ebx
1075ce: 83 ec 6c sub $0x6c,%esp
1075d1: 8b 5d 08 mov 0x8(%ebp),%ebx
Timestamp_Control uptime, total, ran;
#else
uint32_t total_units = 0;
#endif
if ( !print )
1075d4: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
1075d8: 0f 84 53 01 00 00 je 107731 <rtems_cpu_usage_report_with_plugin+0x169><== 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 );
1075de: 83 ec 0c sub $0xc,%esp
1075e1: 8d 7d d8 lea -0x28(%ebp),%edi
1075e4: 57 push %edi
1075e5: e8 b2 4c 00 00 call 10c29c <_TOD_Get_uptime>
_Timestamp_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total );
1075ea: 83 c4 0c add $0xc,%esp
1075ed: 8d 75 d0 lea -0x30(%ebp),%esi
1075f0: 56 push %esi
1075f1: 57 push %edi
1075f2: 68 e8 07 13 00 push $0x1307e8
1075f7: e8 7c 6c 00 00 call 10e278 <_Timespec_Subtract>
}
}
}
#endif
(*print)(
1075fc: 5e pop %esi
1075fd: 5f pop %edi
1075fe: 68 cc 0d 12 00 push $0x120dcc
107603: 53 push %ebx
107604: ff 55 0c call *0xc(%ebp)
107607: 83 c4 10 add $0x10,%esp
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ;
10760a: c7 45 a4 01 00 00 00 movl $0x1,-0x5c(%ebp)
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
107611: 8b 55 a4 mov -0x5c(%ebp),%edx
107614: 8b 04 95 20 02 13 00 mov 0x130220(,%edx,4),%eax
10761b: 85 c0 test %eax,%eax
10761d: 0f 84 e5 00 00 00 je 107708 <rtems_cpu_usage_report_with_plugin+0x140><== NEVER TAKEN
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
107623: 8b 70 04 mov 0x4(%eax),%esi
if ( information ) {
107626: 85 f6 test %esi,%esi
107628: 0f 84 da 00 00 00 je 107708 <rtems_cpu_usage_report_with_plugin+0x140><== NEVER TAKEN
10762e: bf 01 00 00 00 mov $0x1,%edi
107633: 89 5d 94 mov %ebx,-0x6c(%ebp)
107636: e9 be 00 00 00 jmp 1076f9 <rtems_cpu_usage_report_with_plugin+0x131>
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
10763b: 8b 46 1c mov 0x1c(%esi),%eax
10763e: 8b 14 b8 mov (%eax,%edi,4),%edx
if ( !the_thread )
107641: 85 d2 test %edx,%edx
107643: 0f 84 af 00 00 00 je 1076f8 <rtems_cpu_usage_report_with_plugin+0x130><== NEVER TAKEN
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
107649: 51 push %ecx
10764a: 8d 4d b3 lea -0x4d(%ebp),%ecx
10764d: 51 push %ecx
10764e: 6a 0d push $0xd
107650: ff 72 08 pushl 0x8(%edx)
107653: 89 55 a0 mov %edx,-0x60(%ebp)
107656: e8 d1 3a 00 00 call 10b12c <rtems_object_get_name>
(*print)(
10765b: 8d 5d b3 lea -0x4d(%ebp),%ebx
10765e: 53 push %ebx
10765f: 8b 55 a0 mov -0x60(%ebp),%edx
107662: ff 72 08 pushl 0x8(%edx)
107665: 68 3e 0f 12 00 push $0x120f3e
10766a: ff 75 94 pushl -0x6c(%ebp)
10766d: 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;
107670: 8b 55 a0 mov -0x60(%ebp),%edx
107673: 8b 8a 84 00 00 00 mov 0x84(%edx),%ecx
107679: 8b 9a 88 00 00 00 mov 0x88(%edx),%ebx
10767f: 89 4d c8 mov %ecx,-0x38(%ebp)
107682: 89 5d cc mov %ebx,-0x34(%ebp)
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
107685: 83 c4 20 add $0x20,%esp
107688: a1 d8 07 13 00 mov 0x1307d8,%eax
10768d: 8b 5a 08 mov 0x8(%edx),%ebx
107690: 39 58 08 cmp %ebx,0x8(%eax)
107693: 75 28 jne 1076bd <rtems_cpu_usage_report_with_plugin+0xf5>
Timestamp_Control used;
_Timestamp_Subtract(
107695: 50 push %eax
107696: 8d 45 c0 lea -0x40(%ebp),%eax
107699: 50 push %eax
10769a: 8d 55 d8 lea -0x28(%ebp),%edx
10769d: 52 push %edx
10769e: 68 fc 02 13 00 push $0x1302fc
1076a3: 89 45 a0 mov %eax,-0x60(%ebp)
1076a6: e8 cd 6b 00 00 call 10e278 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch, &uptime, &used
);
_Timestamp_Add_to( &ran, &used );
1076ab: 59 pop %ecx
1076ac: 5b pop %ebx
1076ad: 8b 45 a0 mov -0x60(%ebp),%eax
1076b0: 50 push %eax
1076b1: 8d 45 c8 lea -0x38(%ebp),%eax
1076b4: 50 push %eax
1076b5: e8 d2 6a 00 00 call 10e18c <_Timespec_Add_to>
1076ba: 83 c4 10 add $0x10,%esp
};
_Timestamp_Divide( &ran, &total, &ival, &fval );
1076bd: 8d 55 e0 lea -0x20(%ebp),%edx
1076c0: 52 push %edx
1076c1: 8d 4d e4 lea -0x1c(%ebp),%ecx
1076c4: 51 push %ecx
1076c5: 8d 5d d0 lea -0x30(%ebp),%ebx
1076c8: 53 push %ebx
1076c9: 8d 45 c8 lea -0x38(%ebp),%eax
1076cc: 50 push %eax
1076cd: e8 ea 6a 00 00 call 10e1bc <_Timespec_Divide>
/*
* Print the information
*/
(*print)( context,
1076d2: 58 pop %eax
1076d3: 5a pop %edx
1076d4: ff 75 e0 pushl -0x20(%ebp)
1076d7: ff 75 e4 pushl -0x1c(%ebp)
1076da: 8b 45 cc mov -0x34(%ebp),%eax
1076dd: b9 e8 03 00 00 mov $0x3e8,%ecx
1076e2: 31 d2 xor %edx,%edx
1076e4: f7 f1 div %ecx
1076e6: 50 push %eax
1076e7: ff 75 c8 pushl -0x38(%ebp)
1076ea: 68 51 0f 12 00 push $0x120f51
1076ef: ff 75 94 pushl -0x6c(%ebp)
1076f2: ff 55 0c call *0xc(%ebp)
1076f5: 83 c4 20 add $0x20,%esp
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
1076f8: 47 inc %edi
1076f9: 0f b7 46 10 movzwl 0x10(%esi),%eax
1076fd: 39 c7 cmp %eax,%edi
1076ff: 0f 86 36 ff ff ff jbe 10763b <rtems_cpu_usage_report_with_plugin+0x73>
107705: 8b 5d 94 mov -0x6c(%ebp),%ebx
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
107708: ff 45 a4 incl -0x5c(%ebp)
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ;
10770b: 83 7d a4 04 cmpl $0x4,-0x5c(%ebp)
10770f: 0f 85 fc fe ff ff jne 107611 <rtems_cpu_usage_report_with_plugin+0x49>
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
107715: 8b 45 d4 mov -0x2c(%ebp),%eax
107718: b9 e8 03 00 00 mov $0x3e8,%ecx
10771d: 31 d2 xor %edx,%edx
10771f: f7 f1 div %ecx
107721: 50 push %eax
107722: ff 75 d0 pushl -0x30(%ebp)
107725: 68 69 0f 12 00 push $0x120f69
10772a: 53 push %ebx
10772b: ff 55 0c call *0xc(%ebp)
10772e: 83 c4 10 add $0x10,%esp
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
107731: 8d 65 f4 lea -0xc(%ebp),%esp
107734: 5b pop %ebx
107735: 5e pop %esi
107736: 5f pop %edi
107737: c9 leave
107738: c3 ret
001110d4 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
1110d4: 55 push %ebp
1110d5: 89 e5 mov %esp,%ebp
1110d7: 53 push %ebx
1110d8: 83 ec 04 sub $0x4,%esp
1110db: 8b 55 08 mov 0x8(%ebp),%edx
if (sc == RTEMS_SUCCESSFUL) {
return 0;
1110de: 31 c0 xor %eax,%eax
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
1110e0: 85 d2 test %edx,%edx
1110e2: 74 1b je 1110ff <rtems_deviceio_errno+0x2b><== ALWAYS TAKEN
return 0;
} else {
int eno = EINVAL;
1110e4: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
1110e9: 83 fa 1c cmp $0x1c,%edx <== NOT EXECUTED
1110ec: 77 07 ja 1110f5 <rtems_deviceio_errno+0x21><== NOT EXECUTED
eno = status_code_to_errno [sc];
1110ee: 8b 1c 95 18 f0 11 00 mov 0x11f018(,%edx,4),%ebx <== NOT EXECUTED
}
errno = eno;
1110f5: e8 5a 00 00 00 call 111154 <__errno> <== NOT EXECUTED
1110fa: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
return -1;
1110fc: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
}
}
1110ff: 5a pop %edx
111100: 5b pop %ebx
111101: c9 leave
111102: c3 ret
001071e9 <rtems_filesystem_evaluate_path>:
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
1071e9: 55 push %ebp
1071ea: 89 e5 mov %esp,%ebp
1071ec: 56 push %esi
1071ed: 53 push %ebx
1071ee: 83 ec 10 sub $0x10,%esp
1071f1: 8b 5d 08 mov 0x8(%ebp),%ebx
1071f4: 8b 75 14 mov 0x14(%ebp),%esi
int i = 0;
1071f7: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
/*
* Verify Input parameters.
*/
if ( !pathname )
1071fe: 85 db test %ebx,%ebx
107200: 75 0d jne 10720f <rtems_filesystem_evaluate_path+0x26><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EFAULT );
107202: e8 4d 9f 00 00 call 111154 <__errno> <== NOT EXECUTED
107207: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
10720d: eb 0f jmp 10721e <rtems_filesystem_evaluate_path+0x35><== NOT EXECUTED
if ( !pathloc )
10720f: 85 f6 test %esi,%esi
107211: 75 10 jne 107223 <rtems_filesystem_evaluate_path+0x3a><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
107213: e8 3c 9f 00 00 call 111154 <__errno> <== NOT EXECUTED
107218: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
10721e: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
107221: eb 28 jmp 10724b <rtems_filesystem_evaluate_path+0x62><== NOT EXECUTED
/*
* Evaluate the path using the optable evalpath.
*/
rtems_filesystem_get_start_loc( pathname, &i, pathloc );
107223: 51 push %ecx
107224: 56 push %esi
107225: 8d 45 f4 lea -0xc(%ebp),%eax
107228: 50 push %eax
107229: 53 push %ebx
10722a: e8 29 0d 00 00 call 107f58 <rtems_filesystem_get_start_loc>
/*
* We evaluation the path relative to the start location we get got.
*/
return rtems_filesystem_evaluate_relative_path( &pathname[i],
10722f: 8b 45 f4 mov -0xc(%ebp),%eax
107232: 5a pop %edx
107233: ff 75 18 pushl 0x18(%ebp)
107236: 56 push %esi
107237: ff 75 10 pushl 0x10(%ebp)
10723a: 8b 55 0c mov 0xc(%ebp),%edx
10723d: 29 c2 sub %eax,%edx
10723f: 52 push %edx
107240: 01 c3 add %eax,%ebx
107242: 53 push %ebx
107243: e8 1c ff ff ff call 107164 <rtems_filesystem_evaluate_relative_path>
107248: 83 c4 20 add $0x20,%esp
pathnamelen - i,
flags,
pathloc,
follow_link );
}
10724b: 8d 65 f8 lea -0x8(%ebp),%esp
10724e: 5b pop %ebx
10724f: 5e pop %esi
107250: c9 leave
107251: c3 ret
00107164 <rtems_filesystem_evaluate_relative_path>:
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
107164: 55 push %ebp
107165: 89 e5 mov %esp,%ebp
107167: 57 push %edi
107168: 56 push %esi
107169: 53 push %ebx
10716a: 83 ec 0c sub $0xc,%esp
10716d: 8b 45 08 mov 0x8(%ebp),%eax
107170: 8b 4d 0c mov 0xc(%ebp),%ecx
107173: 8b 75 10 mov 0x10(%ebp),%esi
107176: 8b 5d 14 mov 0x14(%ebp),%ebx
107179: 8b 7d 18 mov 0x18(%ebp),%edi
/*
* Verify Input parameters.
*/
if ( !pathname )
10717c: 85 c0 test %eax,%eax
10717e: 75 0d jne 10718d <rtems_filesystem_evaluate_relative_path+0x29><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EFAULT );
107180: e8 cf 9f 00 00 call 111154 <__errno> <== NOT EXECUTED
107185: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
10718b: eb 0f jmp 10719c <rtems_filesystem_evaluate_relative_path+0x38><== NOT EXECUTED
if ( !pathloc )
10718d: 85 db test %ebx,%ebx
10718f: 75 10 jne 1071a1 <rtems_filesystem_evaluate_relative_path+0x3d><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
107191: e8 be 9f 00 00 call 111154 <__errno> <== NOT EXECUTED
107196: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
10719c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10719f: eb 40 jmp 1071e1 <rtems_filesystem_evaluate_relative_path+0x7d><== NOT EXECUTED
result = (*pathloc->ops->evalpath_h)( pathname, pathnamelen, flags, pathloc );
1071a1: 8b 53 0c mov 0xc(%ebx),%edx
1071a4: 53 push %ebx
1071a5: 56 push %esi
1071a6: 51 push %ecx
1071a7: 50 push %eax
1071a8: ff 12 call *(%edx)
/*
* Get the Node type and determine if you need to follow the link or
* not.
*/
if ( (result == 0) && follow_link ) {
1071aa: 83 c4 10 add $0x10,%esp
1071ad: 85 c0 test %eax,%eax
1071af: 75 30 jne 1071e1 <rtems_filesystem_evaluate_relative_path+0x7d>
1071b1: 85 ff test %edi,%edi
1071b3: 74 2c je 1071e1 <rtems_filesystem_evaluate_relative_path+0x7d>
type = (*pathloc->ops->node_type_h)( pathloc );
1071b5: 83 ec 0c sub $0xc,%esp
1071b8: 8b 43 0c mov 0xc(%ebx),%eax
1071bb: 53 push %ebx
1071bc: ff 50 10 call *0x10(%eax)
if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||
1071bf: 8d 50 fd lea -0x3(%eax),%edx
1071c2: 83 c4 10 add $0x10,%esp
1071c5: 31 c0 xor %eax,%eax
1071c7: 83 fa 01 cmp $0x1,%edx
1071ca: 77 15 ja 1071e1 <rtems_filesystem_evaluate_relative_path+0x7d>
* pathloc will be passed up (and eventually released).
* Hence, the (valid) originial node that we submit to
* eval_link_h() should be released by the handler.
*/
result = (*pathloc->ops->eval_link_h)( pathloc, flags );
1071cc: 8b 43 0c mov 0xc(%ebx),%eax
1071cf: 89 75 0c mov %esi,0xc(%ebp)
1071d2: 89 5d 08 mov %ebx,0x8(%ebp)
1071d5: 8b 40 34 mov 0x34(%eax),%eax
}
}
return result;
}
1071d8: 8d 65 f4 lea -0xc(%ebp),%esp
1071db: 5b pop %ebx
1071dc: 5e pop %esi
1071dd: 5f pop %edi
1071de: c9 leave
* pathloc will be passed up (and eventually released).
* Hence, the (valid) originial node that we submit to
* eval_link_h() should be released by the handler.
*/
result = (*pathloc->ops->eval_link_h)( pathloc, flags );
1071df: ff e0 jmp *%eax
}
}
return result;
}
1071e1: 8d 65 f4 lea -0xc(%ebp),%esp
1071e4: 5b pop %ebx
1071e5: 5e pop %esi
1071e6: 5f pop %edi
1071e7: c9 leave
1071e8: c3 ret
0010e32b <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
10e32b: 55 push %ebp
10e32c: 89 e5 mov %esp,%ebp
10e32e: 83 ec 18 sub $0x18,%esp
10e331: 8b 45 08 mov 0x8(%ebp),%eax
find_arg fa = {
10e334: 89 45 f0 mov %eax,-0x10(%ebp)
10e337: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
10e33e: 85 c0 test %eax,%eax
10e340: 74 13 je 10e355 <rtems_filesystem_get_mount_handler+0x2a><== NEVER TAKEN
rtems_filesystem_iterate( find_handler, &fa );
10e342: 50 push %eax
10e343: 50 push %eax
10e344: 8d 45 f0 lea -0x10(%ebp),%eax
10e347: 50 push %eax
10e348: 68 54 e2 10 00 push $0x10e254
10e34d: e8 62 ff ff ff call 10e2b4 <rtems_filesystem_iterate>
10e352: 83 c4 10 add $0x10,%esp
}
return fa.mount_h;
}
10e355: 8b 45 f4 mov -0xc(%ebp),%eax
10e358: c9 leave
10e359: c3 ret
00107048 <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 )
{
107048: 55 push %ebp
107049: 89 e5 mov %esp,%ebp
10704b: 57 push %edi
10704c: 56 push %esi
10704d: 53 push %ebx
10704e: 83 ec 2c sub $0x2c,%esp
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
107051: a1 54 1f 12 00 mov 0x121f54,%eax
107056: c7 40 2c 12 00 00 00 movl $0x12,0x2c(%eax)
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
10705d: 83 3d 60 d1 11 00 00 cmpl $0x0,0x11d160
107064: 75 0a jne 107070 <rtems_filesystem_initialize+0x28><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0001 );
107066: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107069: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED
10706e: eb 28 jmp 107098 <rtems_filesystem_initialize+0x50><== NOT EXECUTED
mt = &rtems_filesystem_mount_table[0];
107070: a1 4c 01 12 00 mov 0x12014c,%eax
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
107075: 83 ec 0c sub $0xc,%esp
107078: 6a 00 push $0x0
10707a: ff 70 04 pushl 0x4(%eax)
10707d: ff 30 pushl (%eax)
10707f: ff 70 0c pushl 0xc(%eax)
107082: ff 70 08 pushl 0x8(%eax)
107085: e8 c7 06 00 00 call 107751 <mount>
if ( status == -1 )
10708a: 83 c4 20 add $0x20,%esp
10708d: 40 inc %eax
10708e: 75 0d jne 10709d <rtems_filesystem_initialize+0x55><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0002 );
107090: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107093: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED
107098: e8 f3 36 00 00 call 10a790 <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_filesystem_link_counts = 0;
10709d: a1 54 1f 12 00 mov 0x121f54,%eax
1070a2: 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);
1070a8: 83 ec 0c sub $0xc,%esp
1070ab: 6a 00 push $0x0
1070ad: 8d 5d d4 lea -0x2c(%ebp),%ebx
1070b0: 53 push %ebx
1070b1: 6a 00 push $0x0
1070b3: 6a 01 push $0x1
1070b5: 68 90 e8 11 00 push $0x11e890
1070ba: e8 2a 01 00 00 call 1071e9 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
1070bf: 8b 3d 54 1f 12 00 mov 0x121f54,%edi
1070c5: 83 c7 18 add $0x18,%edi
1070c8: b9 05 00 00 00 mov $0x5,%ecx
1070cd: 89 de mov %ebx,%esi
1070cf: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
1070d1: 83 c4 14 add $0x14,%esp
1070d4: 6a 00 push $0x0
1070d6: 53 push %ebx
1070d7: 6a 00 push $0x0
1070d9: 6a 01 push $0x1
1070db: 68 90 e8 11 00 push $0x11e890
1070e0: e8 04 01 00 00 call 1071e9 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
1070e5: 8b 3d 54 1f 12 00 mov 0x121f54,%edi
1070eb: 83 c7 04 add $0x4,%edi
1070ee: b9 05 00 00 00 mov $0x5,%ecx
1070f3: 89 de mov %ebx,%esi
1070f5: 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);
1070f7: 83 c4 18 add $0x18,%esp
1070fa: 68 ff 01 00 00 push $0x1ff
1070ff: 68 92 e8 11 00 push $0x11e892
107104: e8 13 05 00 00 call 10761c <mkdir>
if ( status != 0 )
107109: 83 c4 10 add $0x10,%esp
10710c: 85 c0 test %eax,%eax
10710e: 74 0d je 10711d <rtems_filesystem_initialize+0xd5><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0003 );
107110: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107113: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED
107118: e9 7b ff ff ff jmp 107098 <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.
*/
}
10711d: 8d 65 f4 lea -0xc(%ebp),%esp
107120: 5b pop %ebx
107121: 5e pop %esi
107122: 5f pop %edi
107123: c9 leave
107124: c3 ret
0010e2b4 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
10e2b4: 55 push %ebp
10e2b5: 89 e5 mov %esp,%ebp
10e2b7: 57 push %edi
10e2b8: 56 push %esi
10e2b9: 53 push %ebx
10e2ba: 83 ec 1c sub $0x1c,%esp
10e2bd: 8b 75 08 mov 0x8(%ebp),%esi
10e2c0: 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;
10e2c3: 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];
10e2c5: bb 40 d1 11 00 mov $0x11d140,%ebx
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
10e2ca: eb 0c jmp 10e2d8 <rtems_filesystem_iterate+0x24>
stop = (*routine)( table_entry, routine_arg );
10e2cc: 51 push %ecx
10e2cd: 51 push %ecx
10e2ce: 57 push %edi
10e2cf: 53 push %ebx
10e2d0: ff d6 call *%esi
++table_entry;
10e2d2: 83 c3 08 add $0x8,%ebx
10e2d5: 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 ) {
10e2d8: 83 3b 00 cmpl $0x0,(%ebx)
10e2db: 74 06 je 10e2e3 <rtems_filesystem_iterate+0x2f>
10e2dd: 84 c0 test %al,%al
10e2df: 74 eb je 10e2cc <rtems_filesystem_iterate+0x18><== ALWAYS TAKEN
10e2e1: eb 40 jmp 10e323 <rtems_filesystem_iterate+0x6f><== NOT EXECUTED
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
10e2e3: 84 c0 test %al,%al
10e2e5: 75 3c jne 10e323 <rtems_filesystem_iterate+0x6f>
rtems_libio_lock();
10e2e7: 88 45 e4 mov %al,-0x1c(%ebp)
10e2ea: e8 95 ff ff ff call 10e284 <rtems_libio_lock>
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
10e2ef: 8b 1d 78 1f 12 00 mov 0x121f78,%ebx
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
10e2f5: 8a 55 e4 mov -0x1c(%ebp),%dl
10e2f8: eb 10 jmp 10e30a <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 );
10e2fa: 52 push %edx
10e2fb: 52 push %edx
10e2fc: 57 push %edi
10e2fd: 8d 43 08 lea 0x8(%ebx),%eax
10e300: 50 push %eax
10e301: ff d6 call *%esi
10e303: 88 c2 mov %al,%dl
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
10e305: 8b 1b mov (%ebx),%ebx
10e307: 83 c4 10 add $0x10,%esp
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
10e30a: 81 fb 7c 1f 12 00 cmp $0x121f7c,%ebx
10e310: 74 04 je 10e316 <rtems_filesystem_iterate+0x62>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
10e312: 84 d2 test %dl,%dl
10e314: 74 e4 je 10e2fa <rtems_filesystem_iterate+0x46><== ALWAYS TAKEN
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
10e316: 88 55 e4 mov %dl,-0x1c(%ebp)
10e319: e8 80 ff ff ff call 10e29e <rtems_libio_unlock>
10e31e: 8a 55 e4 mov -0x1c(%ebp),%dl
10e321: 88 d0 mov %dl,%al
}
return stop;
}
10e323: 8d 65 f4 lea -0xc(%ebp),%esp
10e326: 5b pop %ebx
10e327: 5e pop %esi
10e328: 5f pop %edi
10e329: c9 leave
10e32a: c3 ret
00107709 <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
107709: 55 push %ebp
10770a: 89 e5 mov %esp,%ebp
10770c: 57 push %edi
10770d: 56 push %esi
10770e: 53 push %ebx
10770f: 83 ec 1c sub $0x1c,%esp
107712: 8b 7d 08 mov 0x8(%ebp),%edi
107715: 8b 75 0c mov 0xc(%ebp),%esi
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
107718: e8 bc ff ff ff call 1076d9 <rtems_libio_lock>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
10771d: 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;
107723: 31 c0 xor %eax,%eax
rtems_libio_lock();
for (
107725: eb 0b jmp 107732 <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 );
107727: 50 push %eax
107728: 50 push %eax
107729: 56 push %esi
10772a: 53 push %ebx
10772b: ff d7 call *%edi
}
rtems_libio_unlock();
return stop;
}
10772d: 8b 1b mov (%ebx),%ebx
10772f: 83 c4 10 add $0x10,%esp
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
107732: 81 fb 38 1f 12 00 cmp $0x121f38,%ebx
107738: 74 04 je 10773e <rtems_filesystem_mount_iterate+0x35>
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
10773a: 84 c0 test %al,%al
10773c: 74 e9 je 107727 <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();
10773e: 88 45 e4 mov %al,-0x1c(%ebp)
107741: e8 ad ff ff ff call 1076f3 <rtems_libio_unlock>
return stop;
}
107746: 8a 45 e4 mov -0x1c(%ebp),%al
107749: 8d 65 f4 lea -0xc(%ebp),%esp
10774c: 5b pop %ebx
10774d: 5e pop %esi
10774e: 5f pop %edi
10774f: c9 leave
107750: c3 ret
00107291 <rtems_filesystem_prefix_separators>:
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
107291: 55 push %ebp
107292: 89 e5 mov %esp,%ebp
107294: 57 push %edi
107295: 56 push %esi
107296: 53 push %ebx
107297: 83 ec 0c sub $0xc,%esp
10729a: 8b 7d 08 mov 0x8(%ebp),%edi
10729d: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
1072a0: 31 db xor %ebx,%ebx
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
1072a2: eb 01 jmp 1072a5 <rtems_filesystem_prefix_separators+0x14>
{
pathname++;
pathnamelen--;
stripped++;
1072a4: 43 inc %ebx
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
1072a5: 8a 04 1f mov (%edi,%ebx,1),%al
1072a8: 39 de cmp %ebx,%esi
1072aa: 74 17 je 1072c3 <rtems_filesystem_prefix_separators+0x32><== NEVER TAKEN
1072ac: 84 c0 test %al,%al
1072ae: 74 13 je 1072c3 <rtems_filesystem_prefix_separators+0x32><== NEVER TAKEN
1072b0: 83 ec 0c sub $0xc,%esp
1072b3: 0f be c0 movsbl %al,%eax
1072b6: 50 push %eax
1072b7: e8 f4 0c 00 00 call 107fb0 <rtems_filesystem_is_separator>
1072bc: 83 c4 10 add $0x10,%esp
1072bf: 85 c0 test %eax,%eax
1072c1: 75 e1 jne 1072a4 <rtems_filesystem_prefix_separators+0x13>
pathname++;
pathnamelen--;
stripped++;
}
return stripped;
}
1072c3: 89 d8 mov %ebx,%eax
1072c5: 8d 65 f4 lea -0xc(%ebp),%esp
1072c8: 5b pop %ebx
1072c9: 5e pop %esi
1072ca: 5f pop %edi
1072cb: c9 leave
1072cc: c3 ret
00107a13 <rtems_gxx_getspecific>:
void *rtems_gxx_getspecific(__gthread_key_t key)
{
107a13: 55 push %ebp
107a14: 89 e5 mov %esp,%ebp
107a16: 53 push %ebx
107a17: 83 ec 18 sub $0x18,%esp
107a1a: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_status_code status;
void *p= 0;
107a1d: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_get( RTEMS_SELF, (void **)key, &p );
107a24: 8d 45 f4 lea -0xc(%ebp),%eax
107a27: 50 push %eax
107a28: 53 push %ebx
107a29: 6a 00 push $0x0
107a2b: e8 80 35 00 00 call 10afb0 <rtems_task_variable_get>
if ( status == RTEMS_SUCCESSFUL ) {
107a30: 83 c4 10 add $0x10,%esp
107a33: 85 c0 test %eax,%eax
107a35: 75 07 jne 107a3e <rtems_gxx_getspecific+0x2b><== NEVER TAKEN
/* We do not have to do this, but what the heck ! */
p= key->val;
107a37: 8b 03 mov (%ebx),%eax
107a39: 89 45 f4 mov %eax,-0xc(%ebp)
107a3c: eb 26 jmp 107a64 <rtems_gxx_getspecific+0x51>
} else {
/* fisrt time, always set to zero, it is unknown the value that the others
* threads are using at the moment of this call
*/
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
107a3e: 51 push %ecx <== NOT EXECUTED
107a3f: ff 73 04 pushl 0x4(%ebx) <== NOT EXECUTED
107a42: 53 push %ebx <== NOT EXECUTED
107a43: 6a 00 push $0x0 <== NOT EXECUTED
107a45: e8 56 34 00 00 call 10aea0 <rtems_task_variable_add><== NOT EXECUTED
if ( status != RTEMS_SUCCESSFUL ) {
107a4a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107a4d: 85 c0 test %eax,%eax <== NOT EXECUTED
107a4f: 74 0d je 107a5e <rtems_gxx_getspecific+0x4b><== NOT EXECUTED
rtems_panic ("rtems_gxx_getspecific");
107a51: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107a54: 68 7f fc 11 00 push $0x11fc7f <== NOT EXECUTED
107a59: e8 2d 71 00 00 call 10eb8b <rtems_panic> <== NOT EXECUTED
}
key->val = (void *)0;
107a5e: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED
p,
rtems_task_self()
);
#endif
return p;
}
107a64: 8b 45 f4 mov -0xc(%ebp),%eax
107a67: 8b 5d fc mov -0x4(%ebp),%ebx
107a6a: c9 leave
107a6b: c3 ret
001079e3 <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
1079e3: 55 push %ebp
1079e4: 89 e5 mov %esp,%ebp
1079e6: 53 push %ebx
1079e7: 83 ec 0c sub $0xc,%esp
1079ea: 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 );
1079ed: 53 push %ebx
1079ee: 6a 00 push $0x0
1079f0: e8 3f 35 00 00 call 10af34 <rtems_task_variable_delete>
if ( status == RTEMS_SUCCESSFUL ) {
1079f5: 83 c4 10 add $0x10,%esp
1079f8: 85 c0 test %eax,%eax
1079fa: 75 10 jne 107a0c <rtems_gxx_key_delete+0x29><== NEVER TAKEN
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( (void *)key );
1079fc: 85 db test %ebx,%ebx
1079fe: 74 0c je 107a0c <rtems_gxx_key_delete+0x29><== NEVER TAKEN
107a00: 83 ec 0c sub $0xc,%esp
107a03: 53 push %ebx
107a04: e8 4b fe ff ff call 107854 <free>
107a09: 83 c4 10 add $0x10,%esp
return 0;
}
return 0;
}
107a0c: 31 c0 xor %eax,%eax
107a0e: 8b 5d fc mov -0x4(%ebp),%ebx
107a11: c9 leave
107a12: c3 ret
001079d3 <rtems_gxx_key_dtor>:
int rtems_gxx_key_dtor (__gthread_key_t key, void *ptr)
{
1079d3: 55 push %ebp <== NOT EXECUTED
1079d4: 89 e5 mov %esp,%ebp <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: dtor key=%x, ptr=%x\n", key, ptr );
#endif
key->val = 0;
1079d6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1079d9: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
return 0;
}
1079df: 31 c0 xor %eax,%eax <== NOT EXECUTED
1079e1: c9 leave <== NOT EXECUTED
1079e2: c3 ret <== NOT EXECUTED
00107ae8 <rtems_gxx_mutex_destroy>:
int rtems_gxx_mutex_destroy (__gthread_mutex_t *mutex)
{
107ae8: 55 push %ebp <== NOT EXECUTED
107ae9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107aeb: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: destroy mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_delete(*(rtems_id *)mutex);
107aee: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
107af1: ff 30 pushl (%eax) <== NOT EXECUTED
107af3: e8 e0 2d 00 00 call 10a8d8 <rtems_semaphore_delete><== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL )
107af8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return 0;
107afb: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED
107afe: 19 c0 sbb %eax,%eax <== NOT EXECUTED
107b00: f7 d0 not %eax <== NOT EXECUTED
return -1;
}
107b02: c9 leave <== NOT EXECUTED
107b03: c3 ret <== NOT EXECUTED
00107a99 <rtems_gxx_mutex_init>:
/*
* MUTEX support
*/
void rtems_gxx_mutex_init (__gthread_mutex_t *mutex)
{
107a99: 55 push %ebp
107a9a: 89 e5 mov %esp,%ebp
107a9c: 83 ec 14 sub $0x14,%esp
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: mutex init =%X\n", *mutex );
#endif
status = rtems_semaphore_create(
107a9f: ff 75 08 pushl 0x8(%ebp)
107aa2: 6a 00 push $0x0
107aa4: 6a 54 push $0x54
107aa6: 6a 01 push $0x1
107aa8: 68 32 43 43 47 push $0x47434332
107aad: e8 8e 2c 00 00 call 10a740 <rtems_semaphore_create>
RTEMS_PRIORITY|RTEMS_BINARY_SEMAPHORE|
RTEMS_INHERIT_PRIORITY|RTEMS_NO_PRIORITY_CEILING|RTEMS_LOCAL,
0,
(rtems_id *)mutex
);
if ( status != RTEMS_SUCCESSFUL ) {
107ab2: 83 c4 20 add $0x20,%esp
107ab5: 85 c0 test %eax,%eax
107ab7: 74 0d je 107ac6 <rtems_gxx_mutex_init+0x2d><== ALWAYS TAKEN
"gxx_wrappers: mutex init failed %s (%d)\n",
rtems_status_text(status),
status
);
#endif
rtems_panic ("rtems_gxx_mutex_init");
107ab9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107abc: 68 95 fc 11 00 push $0x11fc95 <== NOT EXECUTED
107ac1: e8 c5 70 00 00 call 10eb8b <rtems_panic> <== NOT EXECUTED
}
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: mutex init complete =%X\n", *mutex );
#endif
}
107ac6: c9 leave
107ac7: c3 ret
00107940 <rtems_gxx_once>:
typedef int __gthread_once_t;
typedef void *__gthread_mutex_t;
typedef void *__gthread_recursive_mutex_t;
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))
{
107940: 55 push %ebp
107941: 89 e5 mov %esp,%ebp
107943: 56 push %esi
107944: 53 push %ebx
107945: 83 ec 10 sub $0x10,%esp
107948: 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 ) {
10794b: 8b 03 mov (%ebx),%eax
10794d: 85 c0 test %eax,%eax
10794f: 75 3f jne 107990 <rtems_gxx_once+0x50>
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
107951: 52 push %edx
107952: 8d 45 f4 lea -0xc(%ebp),%eax
107955: 50 push %eax
107956: 68 00 01 00 00 push $0x100
10795b: 68 00 01 00 00 push $0x100
107960: e8 af 33 00 00 call 10ad14 <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
107965: 8b 33 mov (%ebx),%esi
107967: 83 c4 10 add $0x10,%esp
10796a: 85 f6 test %esi,%esi
10796c: 75 06 jne 107974 <rtems_gxx_once+0x34> <== NEVER TAKEN
*(volatile __gthread_once_t *)once = 1;
10796e: c7 03 01 00 00 00 movl $0x1,(%ebx)
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
107974: 50 push %eax
107975: 8d 45 f4 lea -0xc(%ebp),%eax
107978: 50 push %eax
107979: 68 00 01 00 00 push $0x100
10797e: ff 75 f4 pushl -0xc(%ebp)
107981: e8 8e 33 00 00 call 10ad14 <rtems_task_mode>
if ( o == 0 )
107986: 83 c4 10 add $0x10,%esp
107989: 85 f6 test %esi,%esi
10798b: 75 03 jne 107990 <rtems_gxx_once+0x50> <== NEVER TAKEN
(*func)();
10798d: ff 55 0c call *0xc(%ebp)
}
return 0;
}
107990: 31 c0 xor %eax,%eax
107992: 8d 65 f8 lea -0x8(%ebp),%esp
107995: 5b pop %ebx
107996: 5e pop %esi
107997: c9 leave
107998: c3 ret
00107a6c <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
107a6c: 55 push %ebp
107a6d: 89 e5 mov %esp,%ebp
107a6f: 53 push %ebx
107a70: 83 ec 08 sub $0x8,%esp
107a73: 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 );
107a76: ff 73 04 pushl 0x4(%ebx)
107a79: 53 push %ebx
107a7a: 6a 00 push $0x0
107a7c: e8 1f 34 00 00 call 10aea0 <rtems_task_variable_add>
107a81: 89 c2 mov %eax,%edx
if ( status == RTEMS_SUCCESSFUL ) {
107a83: 83 c4 10 add $0x10,%esp
/* now let's set the proper value */
key->val = (void *)ptr;
return 0;
}
return -1;
107a86: 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 ) {
107a89: 85 d2 test %edx,%edx
107a8b: 75 07 jne 107a94 <rtems_gxx_setspecific+0x28><== NEVER TAKEN
/* now let's set the proper value */
key->val = (void *)ptr;
107a8d: 8b 45 0c mov 0xc(%ebp),%eax
107a90: 89 03 mov %eax,(%ebx)
return 0;
107a92: 31 c0 xor %eax,%eax
}
return -1;
}
107a94: 8b 5d fc mov -0x4(%ebp),%ebx
107a97: c9 leave
107a98: c3 ret
0010a8e4 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
10a8e4: 55 push %ebp
10a8e5: 89 e5 mov %esp,%ebp
10a8e7: 83 ec 08 sub $0x8,%esp
if (
10a8ea: 83 3d f0 bd 12 00 03 cmpl $0x3,0x12bdf0
10a8f1: 75 0d jne 10a900 <rtems_heap_allocate_aligned_with_boundary+0x1c><== NEVER TAKEN
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
10a8f3: e8 1c f1 ff ff call 109a14 <malloc_is_system_state_OK>
10a8f8: 88 c2 mov %al,%dl
) {
return NULL;
10a8fa: 31 c0 xor %eax,%eax
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
10a8fc: 84 d2 test %dl,%dl
10a8fe: 74 1c je 10a91c <rtems_heap_allocate_aligned_with_boundary+0x38>
) {
return NULL;
}
malloc_deferred_frees_process();
10a900: e8 4d f1 ff ff call 109a52 <malloc_deferred_frees_process>
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
10a905: ff 75 10 pushl 0x10(%ebp)
10a908: ff 75 0c pushl 0xc(%ebp)
10a90b: ff 75 08 pushl 0x8(%ebp)
10a90e: ff 35 d0 72 12 00 pushl 0x1272d0
10a914: e8 7f 44 00 00 call 10ed98 <_Protected_heap_Allocate_aligned_with_boundary>
10a919: 83 c4 10 add $0x10,%esp
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
10a91c: c9 leave
10a91d: c3 ret
00106f6e <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
106f6e: 55 push %ebp
106f6f: 89 e5 mov %esp,%ebp
106f71: 57 push %edi
106f72: 56 push %esi
106f73: 53 push %ebx
106f74: 83 ec 48 sub $0x48,%esp
106f77: 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(
106f7a: 31 c0 xor %eax,%eax
106f7c: 83 c9 ff or $0xffffffff,%ecx
106f7f: 89 f7 mov %esi,%edi
106f81: f2 ae repnz scas %es:(%edi),%al
106f83: f7 d1 not %ecx
106f85: 49 dec %ecx
106f86: 6a 01 push $0x1
106f88: 8d 55 d4 lea -0x2c(%ebp),%edx
106f8b: 52 push %edx
106f8c: 6a 00 push $0x0
106f8e: 51 push %ecx
106f8f: 56 push %esi
106f90: 89 55 c4 mov %edx,-0x3c(%ebp)
106f93: e8 51 02 00 00 call 1071e9 <rtems_filesystem_evaluate_path>
106f98: 89 c7 mov %eax,%edi
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
106f9a: 8b 5d d4 mov -0x2c(%ebp),%ebx
node_type = (*loc.ops->node_type_h)( &loc );
106f9d: 83 c4 14 add $0x14,%esp
106fa0: 8b 55 c4 mov -0x3c(%ebp),%edx
106fa3: 52 push %edx
106fa4: 8b 45 e0 mov -0x20(%ebp),%eax
106fa7: ff 50 10 call *0x10(%eax)
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
106faa: 83 c4 10 add $0x10,%esp
106fad: 83 f8 02 cmp $0x2,%eax
106fb0: 8b 55 c4 mov -0x3c(%ebp),%edx
106fb3: 75 07 jne 106fbc <rtems_io_lookup_name+0x4e>
106fb5: 85 ff test %edi,%edi
106fb7: 0f 95 c0 setne %al
106fba: 74 16 je 106fd2 <rtems_io_lookup_name+0x64><== ALWAYS TAKEN
rtems_filesystem_freenode( &loc );
106fbc: 83 ec 0c sub $0xc,%esp
106fbf: 8d 45 d4 lea -0x2c(%ebp),%eax
106fc2: 50 push %eax
106fc3: e8 08 03 00 00 call 1072d0 <rtems_filesystem_freenode>
return RTEMS_UNSATISFIED;
106fc8: 83 c4 10 add $0x10,%esp
106fcb: b8 0d 00 00 00 mov $0xd,%eax
106fd0: eb 32 jmp 107004 <rtems_io_lookup_name+0x96>
}
device_info->device_name = (char *) name;
106fd2: 8b 4d 0c mov 0xc(%ebp),%ecx
106fd5: 89 31 mov %esi,(%ecx)
device_info->device_name_length = strlen( name );
106fd7: 83 c9 ff or $0xffffffff,%ecx
106fda: 89 f7 mov %esi,%edi
106fdc: f2 ae repnz scas %es:(%edi),%al
106fde: f7 d1 not %ecx
106fe0: 49 dec %ecx
106fe1: 8b 45 0c mov 0xc(%ebp),%eax
106fe4: 89 48 04 mov %ecx,0x4(%eax)
device_info->major = the_jnode->info.device.major;
106fe7: 8b 43 50 mov 0x50(%ebx),%eax
106fea: 8b 4d 0c mov 0xc(%ebp),%ecx
106fed: 89 41 08 mov %eax,0x8(%ecx)
device_info->minor = the_jnode->info.device.minor;
106ff0: 8b 43 54 mov 0x54(%ebx),%eax
106ff3: 89 41 0c mov %eax,0xc(%ecx)
rtems_filesystem_freenode( &loc );
106ff6: 83 ec 0c sub $0xc,%esp
106ff9: 52 push %edx
106ffa: e8 d1 02 00 00 call 1072d0 <rtems_filesystem_freenode>
return RTEMS_SUCCESSFUL;
106fff: 83 c4 10 add $0x10,%esp
107002: 31 c0 xor %eax,%eax
}
107004: 8d 65 f4 lea -0xc(%ebp),%esp
107007: 5b pop %ebx
107008: 5e pop %esi
107009: 5f pop %edi
10700a: c9 leave
10700b: c3 ret
0010c7b4 <rtems_iterate_over_all_threads>:
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
{
10c7b4: 55 push %ebp
10c7b5: 89 e5 mov %esp,%ebp
10c7b7: 57 push %edi
10c7b8: 56 push %esi
10c7b9: 53 push %ebx
10c7ba: 83 ec 0c sub $0xc,%esp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10c7bd: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10c7c1: 74 41 je 10c804 <rtems_iterate_over_all_threads+0x50><== NEVER TAKEN
10c7c3: bb 01 00 00 00 mov $0x1,%ebx
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
10c7c8: 8b 04 9d 20 02 13 00 mov 0x130220(,%ebx,4),%eax
10c7cf: 85 c0 test %eax,%eax
10c7d1: 74 2b je 10c7fe <rtems_iterate_over_all_threads+0x4a><== NEVER TAKEN
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
10c7d3: 8b 78 04 mov 0x4(%eax),%edi
if ( !information )
10c7d6: be 01 00 00 00 mov $0x1,%esi
10c7db: 85 ff test %edi,%edi
10c7dd: 75 17 jne 10c7f6 <rtems_iterate_over_all_threads+0x42>
10c7df: eb 1d jmp 10c7fe <rtems_iterate_over_all_threads+0x4a>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
10c7e1: 8b 47 1c mov 0x1c(%edi),%eax
10c7e4: 8b 04 b0 mov (%eax,%esi,4),%eax
if ( !the_thread )
10c7e7: 85 c0 test %eax,%eax
10c7e9: 74 0a je 10c7f5 <rtems_iterate_over_all_threads+0x41><== NEVER TAKEN
continue;
(*routine)(the_thread);
10c7eb: 83 ec 0c sub $0xc,%esp
10c7ee: 50 push %eax
10c7ef: ff 55 08 call *0x8(%ebp)
10c7f2: 83 c4 10 add $0x10,%esp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10c7f5: 46 inc %esi
10c7f6: 0f b7 47 10 movzwl 0x10(%edi),%eax
10c7fa: 39 c6 cmp %eax,%esi
10c7fc: 76 e3 jbe 10c7e1 <rtems_iterate_over_all_threads+0x2d>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
10c7fe: 43 inc %ebx
10c7ff: 83 fb 04 cmp $0x4,%ebx
10c802: 75 c4 jne 10c7c8 <rtems_iterate_over_all_threads+0x14>
(*routine)(the_thread);
}
}
}
10c804: 8d 65 f4 lea -0xc(%ebp),%esp
10c807: 5b pop %ebx
10c808: 5e pop %esi
10c809: 5f pop %edi
10c80a: c9 leave
10c80b: c3 ret
0010e188 <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
10e188: 55 push %ebp
10e189: 89 e5 mov %esp,%ebp
10e18b: 53 push %ebx
10e18c: 83 ec 04 sub $0x4,%esp
10e18f: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_libio_lock();
10e192: e8 d5 fe ff ff call 10e06c <rtems_libio_lock>
if (iop->sem)
10e197: 8b 43 2c mov 0x2c(%ebx),%eax
10e19a: 85 c0 test %eax,%eax
10e19c: 74 0c je 10e1aa <rtems_libio_free+0x22> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
10e19e: 83 ec 0c sub $0xc,%esp
10e1a1: 50 push %eax
10e1a2: e8 91 bf ff ff call 10a138 <rtems_semaphore_delete>
10e1a7: 83 c4 10 add $0x10,%esp
iop->flags &= ~LIBIO_FLAGS_OPEN;
10e1aa: 81 63 14 ff fe ff ff andl $0xfffffeff,0x14(%ebx)
iop->data1 = rtems_libio_iop_freelist;
10e1b1: a1 9c 40 12 00 mov 0x12409c,%eax
10e1b6: 89 43 34 mov %eax,0x34(%ebx)
rtems_libio_iop_freelist = iop;
10e1b9: 89 1d 9c 40 12 00 mov %ebx,0x12409c
rtems_libio_unlock();
}
10e1bf: 8b 5d fc mov -0x4(%ebp),%ebx
10e1c2: c9 leave
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
rtems_libio_unlock();
10e1c3: e9 be fe ff ff jmp 10e086 <rtems_libio_unlock>
001073d0 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
1073d0: 55 push %ebp
1073d1: 89 e5 mov %esp,%ebp
1073d3: 53 push %ebx
1073d4: 83 ec 04 sub $0x4,%esp
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
1073d7: 8b 1d 44 01 12 00 mov 0x120144,%ebx
1073dd: 85 db test %ebx,%ebx
1073df: 74 3e je 10741f <rtems_libio_init+0x4f> <== NEVER TAKEN
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
1073e1: 50 push %eax
1073e2: 50 push %eax
1073e3: 6a 38 push $0x38
1073e5: 53 push %ebx
1073e6: e8 3d fd ff ff call 107128 <calloc>
1073eb: a3 98 40 12 00 mov %eax,0x124098
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
1073f0: 83 c4 10 add $0x10,%esp
1073f3: 85 c0 test %eax,%eax
1073f5: 75 07 jne 1073fe <rtems_libio_init+0x2e>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
1073f7: 83 ec 0c sub $0xc,%esp
1073fa: 6a 1a push $0x1a
1073fc: eb 44 jmp 107442 <rtems_libio_init+0x72>
iop = rtems_libio_iop_freelist = rtems_libio_iops;
1073fe: a3 9c 40 12 00 mov %eax,0x12409c
107403: 89 c2 mov %eax,%edx
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
107405: 31 c9 xor %ecx,%ecx
107407: eb 03 jmp 10740c <rtems_libio_init+0x3c>
iop->data1 = iop + 1;
107409: 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++)
10740c: 41 inc %ecx
10740d: 83 c2 38 add $0x38,%edx
107410: 39 d9 cmp %ebx,%ecx
107412: 72 f5 jb 107409 <rtems_libio_init+0x39>
iop->data1 = iop + 1;
iop->data1 = NULL;
107414: 6b db 38 imul $0x38,%ebx,%ebx
107417: c7 44 18 fc 00 00 00 movl $0x0,-0x4(%eax,%ebx,1)
10741e: 00
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
10741f: 83 ec 0c sub $0xc,%esp
107422: 68 a0 40 12 00 push $0x1240a0
107427: 6a 00 push $0x0
107429: 6a 54 push $0x54
10742b: 6a 01 push $0x1
10742d: 68 4f 49 42 4c push $0x4c42494f
107432: e8 69 2b 00 00 call 109fa0 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
107437: 83 c4 20 add $0x20,%esp
10743a: 85 c0 test %eax,%eax
10743c: 74 09 je 107447 <rtems_libio_init+0x77> <== ALWAYS TAKEN
rtems_fatal_error_occurred( rc );
10743e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107441: 50 push %eax <== NOT EXECUTED
107442: e8 49 33 00 00 call 10a790 <rtems_fatal_error_occurred>
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
107447: a1 40 01 12 00 mov 0x120140,%eax
10744c: 85 c0 test %eax,%eax
10744e: 74 06 je 107456 <rtems_libio_init+0x86> <== NEVER TAKEN
(* rtems_fs_init_helper)();
}
107450: 8b 5d fc mov -0x4(%ebp),%ebx
107453: c9 leave
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
(* rtems_fs_init_helper)();
107454: ff e0 jmp *%eax
}
107456: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
107459: c9 leave <== NOT EXECUTED
10745a: c3 ret <== NOT EXECUTED
00108491 <rtems_libio_set_private_env>:
rtems_status_code rtems_libio_set_private_env(void)
{
108491: 55 push %ebp
108492: 89 e5 mov %esp,%ebp
108494: 57 push %edi
108495: 56 push %esi
108496: 53 push %ebx
108497: 83 ec 40 sub $0x40,%esp
rtems_status_code sc;
rtems_id task_id;
rtems_filesystem_location_info_t loc;
sc=rtems_task_ident(RTEMS_SELF,0,&task_id);
10849a: 8d 45 e4 lea -0x1c(%ebp),%eax
10849d: 50 push %eax
10849e: 6a 00 push $0x0
1084a0: 6a 00 push $0x0
1084a2: e8 b1 27 00 00 call 10ac58 <rtems_task_ident>
1084a7: 89 45 c4 mov %eax,-0x3c(%ebp)
if (sc != RTEMS_SUCCESSFUL) return sc;
1084aa: 83 c4 10 add $0x10,%esp
1084ad: 85 c0 test %eax,%eax
1084af: 0f 85 c8 00 00 00 jne 10857d <rtems_libio_set_private_env+0xec><== NEVER TAKEN
/* Only for the first time a malloc is necesary */
if (rtems_current_user_env==&rtems_global_user_env) {
1084b5: 81 3d 40 2f 12 00 c8 cmpl $0x1250c8,0x122f40
1084bc: 50 12 00
1084bf: 75 49 jne 10850a <rtems_libio_set_private_env+0x79>
rtems_user_env_t *tmp = malloc(sizeof(rtems_user_env_t));
1084c1: 83 ec 0c sub $0xc,%esp
1084c4: 6a 48 push $0x48
1084c6: e8 b1 f5 ff ff call 107a7c <malloc>
1084cb: 89 c3 mov %eax,%ebx
if (!tmp)
1084cd: 83 c4 10 add $0x10,%esp
1084d0: 85 c0 test %eax,%eax
1084d2: 0f 84 9e 00 00 00 je 108576 <rtems_libio_set_private_env+0xe5><== NEVER TAKEN
#ifdef HAVE_USERENV_REFCNT
tmp->refcnt = 1;
#endif
sc = rtems_task_variable_add(
1084d8: 50 push %eax
1084d9: 68 54 84 10 00 push $0x108454
1084de: 68 40 2f 12 00 push $0x122f40
1084e3: 6a 00 push $0x0
1084e5: e8 8a 28 00 00 call 10ad74 <rtems_task_variable_add>
1084ea: 89 c6 mov %eax,%esi
RTEMS_SELF,
(void*)&rtems_current_user_env,
(void(*)(void *))free_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
1084ec: 83 c4 10 add $0x10,%esp
1084ef: 85 c0 test %eax,%eax
1084f1: 74 11 je 108504 <rtems_libio_set_private_env+0x73><== ALWAYS TAKEN
/* don't use free_user_env because the pathlocs are
* not initialized yet
*/
free(tmp);
1084f3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1084f6: 53 push %ebx <== NOT EXECUTED
1084f7: e8 fc f0 ff ff call 1075f8 <free> <== NOT EXECUTED
return sc;
1084fc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1084ff: 89 75 c4 mov %esi,-0x3c(%ebp) <== NOT EXECUTED
108502: eb 79 jmp 10857d <rtems_libio_set_private_env+0xec><== NOT EXECUTED
}
rtems_current_user_env = tmp;
108504: 89 1d 40 2f 12 00 mov %ebx,0x122f40
}
*rtems_current_user_env = rtems_global_user_env; /* get the global values*/
10850a: a1 40 2f 12 00 mov 0x122f40,%eax
10850f: be c8 50 12 00 mov $0x1250c8,%esi
108514: b9 12 00 00 00 mov $0x12,%ecx
108519: 89 c7 mov %eax,%edi
10851b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_current_user_env->task_id=task_id; /* mark the local values*/
10851d: 8b 55 e4 mov -0x1c(%ebp),%edx
108520: 89 10 mov %edx,(%eax)
* 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_evaluate_path("/", 1, 0, &loc, 0);
108522: 83 ec 0c sub $0xc,%esp
108525: 6a 00 push $0x0
108527: 8d 5d d0 lea -0x30(%ebp),%ebx
10852a: 53 push %ebx
10852b: 6a 00 push $0x0
10852d: 6a 01 push $0x1
10852f: 68 74 ef 11 00 push $0x11ef74
108534: e8 c4 ef ff ff call 1074fd <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
108539: 8b 3d 40 2f 12 00 mov 0x122f40,%edi
10853f: 83 c7 18 add $0x18,%edi
108542: b9 05 00 00 00 mov $0x5,%ecx
108547: 89 de mov %ebx,%esi
108549: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
10854b: 83 c4 14 add $0x14,%esp
10854e: 6a 00 push $0x0
108550: 53 push %ebx
108551: 6a 00 push $0x0
108553: 6a 01 push $0x1
108555: 68 74 ef 11 00 push $0x11ef74
10855a: e8 9e ef ff ff call 1074fd <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
10855f: 8b 3d 40 2f 12 00 mov 0x122f40,%edi
108565: 83 c7 04 add $0x4,%edi
108568: b9 05 00 00 00 mov $0x5,%ecx
10856d: 89 de mov %ebx,%esi
10856f: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return RTEMS_SUCCESSFUL;
108571: 83 c4 20 add $0x20,%esp
108574: eb 07 jmp 10857d <rtems_libio_set_private_env+0xec>
/* Only for the first time a malloc is necesary */
if (rtems_current_user_env==&rtems_global_user_env) {
rtems_user_env_t *tmp = malloc(sizeof(rtems_user_env_t));
if (!tmp)
return RTEMS_NO_MEMORY;
108576: c7 45 c4 1a 00 00 00 movl $0x1a,-0x3c(%ebp) <== NOT EXECUTED
rtems_filesystem_root = loc;
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_current = loc;
return RTEMS_SUCCESSFUL;
}
10857d: 8b 45 c4 mov -0x3c(%ebp),%eax
108580: 8d 65 f4 lea -0xc(%ebp),%esp
108583: 5b pop %ebx
108584: 5e pop %esi
108585: 5f pop %edi
108586: c9 leave
108587: c3 ret
00108588 <rtems_libio_share_private_env>:
* while changing any of those (chdir(), chroot()).
*/
#ifndef HAVE_USERENV_REFCNT
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
108588: 55 push %ebp <== NOT EXECUTED
108589: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10858b: 53 push %ebx <== NOT EXECUTED
10858c: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED
rtems_status_code sc;
rtems_user_env_t * shared_user_env;
rtems_id current_task_id;
sc=rtems_task_ident(RTEMS_SELF,0,¤t_task_id);
10858f: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED
108592: 50 push %eax <== NOT EXECUTED
108593: 6a 00 push $0x0 <== NOT EXECUTED
108595: 6a 00 push $0x0 <== NOT EXECUTED
108597: e8 bc 26 00 00 call 10ac58 <rtems_task_ident> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) return sc;
10859c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10859f: 85 c0 test %eax,%eax <== NOT EXECUTED
1085a1: 75 77 jne 10861a <rtems_libio_share_private_env+0x92><== NOT EXECUTED
if (rtems_current_user_env->task_id==current_task_id) {
1085a3: 8b 1d 40 2f 12 00 mov 0x122f40,%ebx <== NOT EXECUTED
1085a9: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
1085ac: 39 03 cmp %eax,(%ebx) <== NOT EXECUTED
1085ae: 75 23 jne 1085d3 <rtems_libio_share_private_env+0x4b><== NOT EXECUTED
/* kill the current user env & task_var*/
rtems_user_env_t *tmp = rtems_current_user_env;
sc = rtems_task_variable_delete(RTEMS_SELF,(void*)&rtems_current_user_env);
1085b0: 50 push %eax <== NOT EXECUTED
1085b1: 50 push %eax <== NOT EXECUTED
1085b2: 68 40 2f 12 00 push $0x122f40 <== NOT EXECUTED
1085b7: 6a 00 push $0x0 <== NOT EXECUTED
1085b9: e8 4a 28 00 00 call 10ae08 <rtems_task_variable_delete><== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) return sc;
1085be: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1085c1: 85 c0 test %eax,%eax <== NOT EXECUTED
1085c3: 75 55 jne 10861a <rtems_libio_share_private_env+0x92><== NOT EXECUTED
free_user_env(tmp);
1085c5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1085c8: 53 push %ebx <== NOT EXECUTED
1085c9: e8 86 fe ff ff call 108454 <free_user_env> <== NOT EXECUTED
1085ce: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1085d1: eb 19 jmp 1085ec <rtems_libio_share_private_env+0x64><== NOT EXECUTED
} else {
sc = rtems_task_variable_get(
1085d3: 51 push %ecx <== NOT EXECUTED
task_id,(void*)&rtems_current_user_env, (void*)&shared_user_env );
1085d4: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED
rtems_user_env_t *tmp = rtems_current_user_env;
sc = rtems_task_variable_delete(RTEMS_SELF,(void*)&rtems_current_user_env);
if (sc != RTEMS_SUCCESSFUL) return sc;
free_user_env(tmp);
} else {
sc = rtems_task_variable_get(
1085d7: 50 push %eax <== NOT EXECUTED
1085d8: 68 40 2f 12 00 push $0x122f40 <== NOT EXECUTED
1085dd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
1085e0: e8 9f 28 00 00 call 10ae84 <rtems_task_variable_get><== NOT EXECUTED
task_id,(void*)&rtems_current_user_env, (void*)&shared_user_env );
if (sc != RTEMS_SUCCESSFUL)
1085e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1085e8: 85 c0 test %eax,%eax <== NOT EXECUTED
1085ea: 75 24 jne 108610 <rtems_libio_share_private_env+0x88><== NOT EXECUTED
goto bailout;
}
/* AT THIS POINT, rtems_current_user_env is DANGLING */
sc = rtems_task_variable_add(
1085ec: 52 push %edx <== NOT EXECUTED
1085ed: 68 54 84 10 00 push $0x108454 <== NOT EXECUTED
1085f2: 68 40 2f 12 00 push $0x122f40 <== NOT EXECUTED
1085f7: 6a 00 push $0x0 <== NOT EXECUTED
1085f9: e8 76 27 00 00 call 10ad74 <rtems_task_variable_add><== NOT EXECUTED
RTEMS_SELF,(void*)&rtems_current_user_env,free_user_env);
if (sc != RTEMS_SUCCESSFUL)
1085fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108601: 85 c0 test %eax,%eax <== NOT EXECUTED
108603: 75 0b jne 108610 <rtems_libio_share_private_env+0x88><== NOT EXECUTED
goto bailout;
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
108605: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED
108608: 89 15 40 2f 12 00 mov %edx,0x122f40 <== NOT EXECUTED
/* increase the reference count */
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
10860e: eb 0a jmp 10861a <rtems_libio_share_private_env+0x92><== NOT EXECUTED
bailout:
/* fallback to the global env */
rtems_current_user_env = &rtems_global_user_env;
108610: c7 05 40 2f 12 00 c8 movl $0x1250c8,0x122f40 <== NOT EXECUTED
108617: 50 12 00
return sc;
}
10861a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10861d: c9 leave <== NOT EXECUTED
10861e: c3 ret <== NOT EXECUTED
0010e0d1 <rtems_libio_to_fcntl_flags>:
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
10e0d1: 55 push %ebp
10e0d2: 89 e5 mov %esp,%ebp
10e0d4: 8b 55 08 mov 0x8(%ebp),%edx
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
10e0d7: 89 d1 mov %edx,%ecx
10e0d9: 83 e1 06 and $0x6,%ecx
fcntl_flags |= O_RDWR;
10e0dc: 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 ) {
10e0e1: 83 f9 06 cmp $0x6,%ecx
10e0e4: 74 0f je 10e0f5 <rtems_libio_to_fcntl_flags+0x24><== NEVER TAKEN
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
fcntl_flags |= O_RDONLY;
10e0e6: 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) {
10e0e8: f6 c2 02 test $0x2,%dl
10e0eb: 75 08 jne 10e0f5 <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;
10e0ed: 31 c0 xor %eax,%eax <== NOT EXECUTED
10e0ef: f6 c2 04 test $0x4,%dl <== NOT EXECUTED
10e0f2: 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 ) {
10e0f5: f6 c2 01 test $0x1,%dl
10e0f8: 74 03 je 10e0fd <rtems_libio_to_fcntl_flags+0x2c>
fcntl_flags |= O_NONBLOCK;
10e0fa: 80 cc 40 or $0x40,%ah
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
10e0fd: f6 c6 02 test $0x2,%dh
10e100: 74 03 je 10e105 <rtems_libio_to_fcntl_flags+0x34>
fcntl_flags |= O_APPEND;
10e102: 83 c8 08 or $0x8,%eax
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
10e105: 80 e6 04 and $0x4,%dh
10e108: 74 03 je 10e10d <rtems_libio_to_fcntl_flags+0x3c>
fcntl_flags |= O_CREAT;
10e10a: 80 cc 02 or $0x2,%ah
}
return fcntl_flags;
}
10e10d: c9 leave
10e10e: c3 ret
00109d18 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
109d18: 55 push %ebp
109d19: 89 e5 mov %esp,%ebp
109d1b: 83 ec 1c sub $0x1c,%esp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
109d1e: 8d 45 f4 lea -0xc(%ebp),%eax
109d21: 50 push %eax
109d22: ff 75 08 pushl 0x8(%ebp)
109d25: ff 35 d0 72 12 00 pushl 0x1272d0
109d2b: e8 10 51 00 00 call 10ee40 <_Protected_heap_Get_block_size>
109d30: 83 c4 10 add $0x10,%esp
109d33: 84 c0 test %al,%al
109d35: 74 11 je 109d48 <rtems_malloc_statistics_at_free+0x30><== NEVER TAKEN
MSBUMP(lifetime_freed, size);
109d37: 8b 45 f4 mov -0xc(%ebp),%eax
109d3a: 31 d2 xor %edx,%edx
109d3c: 01 05 60 bb 12 00 add %eax,0x12bb60
109d42: 11 15 64 bb 12 00 adc %edx,0x12bb64
}
}
109d48: c9 leave
109d49: c3 ret
00109d4a <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
109d4a: 55 push %ebp
109d4b: 89 e5 mov %esp,%ebp
109d4d: 83 ec 18 sub $0x18,%esp
109d50: 8b 45 08 mov 0x8(%ebp),%eax
uintptr_t actual_size = 0;
109d53: 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 )
109d5a: 85 c0 test %eax,%eax
109d5c: 74 43 je 109da1 <rtems_malloc_statistics_at_malloc+0x57><== NEVER TAKEN
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
109d5e: 52 push %edx
109d5f: 8d 55 f4 lea -0xc(%ebp),%edx
109d62: 52 push %edx
109d63: 50 push %eax
109d64: ff 35 d0 72 12 00 pushl 0x1272d0
109d6a: e8 d1 50 00 00 call 10ee40 <_Protected_heap_Get_block_size>
MSBUMP(lifetime_allocated, actual_size);
109d6f: 8b 45 f4 mov -0xc(%ebp),%eax
109d72: 31 d2 xor %edx,%edx
109d74: 03 05 58 bb 12 00 add 0x12bb58,%eax
109d7a: 13 15 5c bb 12 00 adc 0x12bb5c,%edx
109d80: a3 58 bb 12 00 mov %eax,0x12bb58
109d85: 89 15 5c bb 12 00 mov %edx,0x12bb5c
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
109d8b: 2b 05 60 bb 12 00 sub 0x12bb60,%eax
if (current_depth > s->max_depth)
109d91: 83 c4 10 add $0x10,%esp
109d94: 3b 05 54 bb 12 00 cmp 0x12bb54,%eax
109d9a: 76 05 jbe 109da1 <rtems_malloc_statistics_at_malloc+0x57>
s->max_depth = current_depth;
109d9c: a3 54 bb 12 00 mov %eax,0x12bb54
}
109da1: c9 leave
109da2: c3 ret
00111928 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
111928: 55 push %ebp
111929: 89 e5 mov %esp,%ebp
11192b: 57 push %edi
11192c: 56 push %esi
11192d: 53 push %ebx
11192e: 83 ec 0c sub $0xc,%esp
111931: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
111934: be 16 00 00 00 mov $0x16,%esi
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
111939: 85 db test %ebx,%ebx
11193b: 74 55 je 111992 <rtems_memalign+0x6a>
return EINVAL;
*pointer = NULL;
11193d: 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()) &&
111943: 83 3d 1c 86 12 00 03 cmpl $0x3,0x12861c
11194a: 75 09 jne 111955 <rtems_memalign+0x2d> <== NEVER TAKEN
!malloc_is_system_state_OK() )
11194c: e8 43 68 ff ff call 108194 <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()) &&
111951: 84 c0 test %al,%al
111953: 74 3d je 111992 <rtems_memalign+0x6a> <== NEVER TAKEN
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
111955: e8 78 68 ff ff call 1081d2 <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
11195a: 6a 00 push $0x0
11195c: ff 75 0c pushl 0xc(%ebp)
11195f: ff 75 10 pushl 0x10(%ebp)
111962: ff 35 50 43 12 00 pushl 0x124350
111968: e8 0b b1 ff ff call 10ca78 <_Protected_heap_Allocate_aligned_with_boundary>
11196d: 89 c7 mov %eax,%edi
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
11196f: 83 c4 10 add $0x10,%esp
return ENOMEM;
111972: be 0c 00 00 00 mov $0xc,%esi
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
111977: 85 c0 test %eax,%eax
111979: 74 17 je 111992 <rtems_memalign+0x6a>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
11197b: a1 30 67 12 00 mov 0x126730,%eax
111980: 85 c0 test %eax,%eax
111982: 74 0a je 11198e <rtems_memalign+0x66>
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
111984: 83 ec 0c sub $0xc,%esp
111987: 53 push %ebx
111988: ff 50 04 call *0x4(%eax)
11198b: 83 c4 10 add $0x10,%esp
*pointer = return_this;
11198e: 89 3b mov %edi,(%ebx)
return 0;
111990: 31 f6 xor %esi,%esi
}
111992: 89 f0 mov %esi,%eax
111994: 8d 65 f4 lea -0xc(%ebp),%esp
111997: 5b pop %ebx
111998: 5e pop %esi
111999: 5f pop %edi
11199a: c9 leave
11199b: c3 ret
0011039c <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
11039c: 55 push %ebp
11039d: 89 e5 mov %esp,%ebp
11039f: 57 push %edi
1103a0: 56 push %esi
1103a1: 53 push %ebx
1103a2: 83 ec 78 sub $0x78,%esp
int success = 0;
char *dup_path = strdup(path);
1103a5: ff 75 08 pushl 0x8(%ebp)
1103a8: e8 0b 32 00 00 call 1135b8 <strdup>
1103ad: 89 c3 mov %eax,%ebx
if (dup_path != NULL) {
1103af: 83 c4 10 add $0x10,%esp
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
1103b2: 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) {
1103b5: 85 db test %ebx,%ebx
1103b7: 0f 84 1e 01 00 00 je 1104db <rtems_mkdir+0x13f> <== NEVER TAKEN
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
1103bd: 31 c0 xor %eax,%eax
1103bf: 80 3b 2f cmpb $0x2f,(%ebx)
1103c2: 0f 94 c0 sete %al
1103c5: 8d 3c 03 lea (%ebx,%eax,1),%edi
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
1103c8: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
1103cf: b8 01 00 00 00 mov $0x1,%eax
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
1103d4: 8a 0f mov (%edi),%cl
last = 1;
1103d6: 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')
1103db: 84 c9 test %cl,%cl
1103dd: 74 0b je 1103ea <rtems_mkdir+0x4e>
last = 1;
else if (p[0] != '/')
1103df: 80 f9 2f cmp $0x2f,%cl
1103e2: 0f 85 c8 00 00 00 jne 1104b0 <rtems_mkdir+0x114>
1103e8: 30 d2 xor %dl,%dl
continue;
*p = '\0';
1103ea: c6 07 00 movb $0x0,(%edi)
if (!last && p[1] == '\0')
1103ed: be 01 00 00 00 mov $0x1,%esi
1103f2: 85 d2 test %edx,%edx
1103f4: 75 0b jne 110401 <rtems_mkdir+0x65>
1103f6: 31 d2 xor %edx,%edx
1103f8: 80 7f 01 00 cmpb $0x0,0x1(%edi)
1103fc: 0f 94 c2 sete %dl
1103ff: 89 d6 mov %edx,%esi
last = 1;
if (first) {
110401: 85 c0 test %eax,%eax
110403: 74 1a je 11041f <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);
110405: 83 ec 0c sub $0xc,%esp
110408: 6a 00 push $0x0
11040a: e8 75 01 00 00 call 110584 <umask>
11040f: 89 45 94 mov %eax,-0x6c(%ebp)
numask = oumask & ~(S_IWUSR | S_IXUSR);
110412: 24 3f and $0x3f,%al
(void)umask(numask);
110414: 89 04 24 mov %eax,(%esp)
110417: e8 68 01 00 00 call 110584 <umask>
11041c: 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) {
11041f: b8 ff 01 00 00 mov $0x1ff,%eax
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
110424: 85 f6 test %esi,%esi
110426: 74 11 je 110439 <rtems_mkdir+0x9d>
(void)umask(oumask);
110428: 83 ec 0c sub $0xc,%esp
11042b: ff 75 94 pushl -0x6c(%ebp)
11042e: e8 51 01 00 00 call 110584 <umask>
110433: 83 c4 10 add $0x10,%esp
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
110436: 8b 45 0c mov 0xc(%ebp),%eax
110439: 52 push %edx
11043a: 52 push %edx
11043b: 50 push %eax
11043c: 53 push %ebx
11043d: e8 62 82 ff ff call 1086a4 <mkdir>
110442: 83 c4 10 add $0x10,%esp
110445: 85 c0 test %eax,%eax
110447: 79 5e jns 1104a7 <rtems_mkdir+0x10b>
if (errno == EEXIST || errno == EISDIR) {
110449: e8 92 25 00 00 call 1129e0 <__errno>
11044e: 83 38 11 cmpl $0x11,(%eax)
110451: 74 0a je 11045d <rtems_mkdir+0xc1> <== ALWAYS TAKEN
110453: e8 88 25 00 00 call 1129e0 <__errno> <== NOT EXECUTED
110458: 83 38 15 cmpl $0x15,(%eax) <== NOT EXECUTED
11045b: 75 59 jne 1104b6 <rtems_mkdir+0x11a> <== NOT EXECUTED
if (stat(path, &sb) < 0) {
11045d: 50 push %eax
11045e: 50 push %eax
11045f: 8d 45 a0 lea -0x60(%ebp),%eax
110462: 50 push %eax
110463: 53 push %ebx
110464: e8 8b 00 00 00 call 1104f4 <stat>
110469: 83 c4 10 add $0x10,%esp
11046c: 85 c0 test %eax,%eax
11046e: 78 46 js 1104b6 <rtems_mkdir+0x11a> <== NEVER TAKEN
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
110470: 8b 45 ac mov -0x54(%ebp),%eax
110473: 25 00 f0 00 00 and $0xf000,%eax
110478: 3d 00 40 00 00 cmp $0x4000,%eax
11047d: 74 22 je 1104a1 <rtems_mkdir+0x105>
if (last)
11047f: 85 f6 test %esi,%esi
110481: 74 0f je 110492 <rtems_mkdir+0xf6> <== NEVER TAKEN
errno = EEXIST;
110483: e8 58 25 00 00 call 1129e0 <__errno>
110488: c7 00 11 00 00 00 movl $0x11,(%eax)
else
errno = ENOTDIR;
retval = 0;
11048e: 31 ff xor %edi,%edi
110490: eb 38 jmp 1104ca <rtems_mkdir+0x12e>
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
errno = EEXIST;
else
errno = ENOTDIR;
110492: e8 49 25 00 00 call 1129e0 <__errno> <== NOT EXECUTED
110497: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
retval = 0;
11049d: 31 ff xor %edi,%edi <== NOT EXECUTED
11049f: eb 1b jmp 1104bc <rtems_mkdir+0x120> <== NOT EXECUTED
break;
}
if (last)
1104a1: 85 f6 test %esi,%esi
1104a3: 75 3e jne 1104e3 <rtems_mkdir+0x147>
1104a5: eb 04 jmp 1104ab <rtems_mkdir+0x10f>
} else {
retval = 0;
break;
}
}
if (!last)
1104a7: 85 f6 test %esi,%esi
1104a9: 75 3f jne 1104ea <rtems_mkdir+0x14e>
*p = '/';
1104ab: c6 07 2f movb $0x2f,(%edi)
1104ae: 31 c0 xor %eax,%eax
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
1104b0: 47 inc %edi
1104b1: e9 1e ff ff ff jmp 1103d4 <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;
1104b6: 31 ff xor %edi,%edi <== NOT EXECUTED
}
}
if (!last)
*p = '/';
}
if (!first && !last)
1104b8: 85 f6 test %esi,%esi <== NOT EXECUTED
1104ba: 75 0e jne 1104ca <rtems_mkdir+0x12e> <== NOT EXECUTED
(void)umask(oumask);
1104bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1104bf: ff 75 94 pushl -0x6c(%ebp) <== NOT EXECUTED
1104c2: e8 bd 00 00 00 call 110584 <umask> <== NOT EXECUTED
1104c7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
1104ca: 83 ec 0c sub $0xc,%esp
1104cd: 53 push %ebx
1104ce: e8 91 7c ff ff call 108164 <free>
}
return success != 0 ? 0 : -1;
1104d3: 83 c4 10 add $0x10,%esp
1104d6: 83 ff 01 cmp $0x1,%edi
1104d9: 19 c0 sbb %eax,%eax
}
1104db: 8d 65 f4 lea -0xc(%ebp),%esp
1104de: 5b pop %ebx
1104df: 5e pop %esi
1104e0: 5f pop %edi
1104e1: c9 leave
1104e2: c3 ret
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
retval = 2;
1104e3: bf 02 00 00 00 mov $0x2,%edi
1104e8: eb e0 jmp 1104ca <rtems_mkdir+0x12e>
} else {
retval = 0;
break;
}
}
if (!last)
1104ea: bf 01 00 00 00 mov $0x1,%edi
1104ef: eb d9 jmp 1104ca <rtems_mkdir+0x12e>
001148d0 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
1148d0: 55 push %ebp
1148d1: 89 e5 mov %esp,%ebp
1148d3: 57 push %edi
1148d4: 56 push %esi
1148d5: 53 push %ebx
1148d6: 83 ec 1c sub $0x1c,%esp
1148d9: 8b 75 0c mov 0xc(%ebp),%esi
1148dc: 8b 55 10 mov 0x10(%ebp),%edx
1148df: 8b 7d 14 mov 0x14(%ebp),%edi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
1148e2: b8 03 00 00 00 mov $0x3,%eax
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
1148e7: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
1148eb: 0f 84 ce 00 00 00 je 1149bf <rtems_partition_create+0xef>
return RTEMS_INVALID_NAME;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
1148f1: b0 09 mov $0x9,%al
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
1148f3: 85 f6 test %esi,%esi
1148f5: 0f 84 c4 00 00 00 je 1149bf <rtems_partition_create+0xef>
return RTEMS_INVALID_ADDRESS;
if ( !id )
1148fb: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp)
1148ff: 0f 84 ba 00 00 00 je 1149bf <rtems_partition_create+0xef><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
114905: 85 ff test %edi,%edi
114907: 0f 84 ad 00 00 00 je 1149ba <rtems_partition_create+0xea>
11490d: 85 d2 test %edx,%edx
11490f: 0f 84 a5 00 00 00 je 1149ba <rtems_partition_create+0xea>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
114915: b0 08 mov $0x8,%al
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
114917: 39 fa cmp %edi,%edx
114919: 0f 82 a0 00 00 00 jb 1149bf <rtems_partition_create+0xef>
11491f: f7 c7 03 00 00 00 test $0x3,%edi
114925: 0f 85 94 00 00 00 jne 1149bf <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;
11492b: 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 ) )
11492d: f7 c6 03 00 00 00 test $0x3,%esi
114933: 0f 85 86 00 00 00 jne 1149bf <rtems_partition_create+0xef>
114939: a1 b8 e5 13 00 mov 0x13e5b8,%eax
11493e: 40 inc %eax
11493f: a3 b8 e5 13 00 mov %eax,0x13e5b8
* 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 );
114944: 83 ec 0c sub $0xc,%esp
114947: 68 44 e4 13 00 push $0x13e444
11494c: 89 55 e4 mov %edx,-0x1c(%ebp)
11494f: e8 28 3e 00 00 call 11877c <_Objects_Allocate>
114954: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
114956: 83 c4 10 add $0x10,%esp
114959: 85 c0 test %eax,%eax
11495b: 8b 55 e4 mov -0x1c(%ebp),%edx
11495e: 75 0c jne 11496c <rtems_partition_create+0x9c>
_Thread_Enable_dispatch();
114960: e8 59 4a 00 00 call 1193be <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
114965: b8 05 00 00 00 mov $0x5,%eax
11496a: eb 53 jmp 1149bf <rtems_partition_create+0xef>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
11496c: 89 70 10 mov %esi,0x10(%eax)
the_partition->length = length;
11496f: 89 50 14 mov %edx,0x14(%eax)
the_partition->buffer_size = buffer_size;
114972: 89 78 18 mov %edi,0x18(%eax)
the_partition->attribute_set = attribute_set;
114975: 8b 45 18 mov 0x18(%ebp),%eax
114978: 89 43 1c mov %eax,0x1c(%ebx)
the_partition->number_of_used_blocks = 0;
11497b: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
_Chain_Initialize( &the_partition->Memory, starting_address,
114982: 57 push %edi
114983: 89 d0 mov %edx,%eax
114985: 31 d2 xor %edx,%edx
114987: f7 f7 div %edi
114989: 50 push %eax
11498a: 56 push %esi
11498b: 8d 43 24 lea 0x24(%ebx),%eax
11498e: 50 push %eax
11498f: e8 8c 2a 00 00 call 117420 <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
114994: 8b 43 08 mov 0x8(%ebx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
114997: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
11499a: 8b 15 60 e4 13 00 mov 0x13e460,%edx
1149a0: 89 1c 8a mov %ebx,(%edx,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1149a3: 8b 55 08 mov 0x8(%ebp),%edx
1149a6: 89 53 0c mov %edx,0xc(%ebx)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
1149a9: 8b 55 1c mov 0x1c(%ebp),%edx
1149ac: 89 02 mov %eax,(%edx)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
1149ae: e8 0b 4a 00 00 call 1193be <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1149b3: 83 c4 10 add $0x10,%esp
1149b6: 31 c0 xor %eax,%eax
1149b8: eb 05 jmp 1149bf <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;
1149ba: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1149bf: 8d 65 f4 lea -0xc(%ebp),%esp
1149c2: 5b pop %ebx
1149c3: 5e pop %esi
1149c4: 5f pop %edi
1149c5: c9 leave
1149c6: c3 ret
0010b095 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
10b095: 55 push %ebp
10b096: 89 e5 mov %esp,%ebp
10b098: 57 push %edi
10b099: 56 push %esi
10b09a: 53 push %ebx
10b09b: 83 ec 30 sub $0x30,%esp
10b09e: 8b 75 08 mov 0x8(%ebp),%esi
10b0a1: 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 );
10b0a4: 8d 45 e4 lea -0x1c(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
10b0a7: 50 push %eax
10b0a8: 56 push %esi
10b0a9: 68 14 72 12 00 push $0x127214
10b0ae: e8 49 1e 00 00 call 10cefc <_Objects_Get>
10b0b3: 89 c7 mov %eax,%edi
switch ( location ) {
10b0b5: 83 c4 10 add $0x10,%esp
10b0b8: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b0bc: 0f 85 3d 01 00 00 jne 10b1ff <rtems_rate_monotonic_period+0x16a>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
10b0c2: a1 58 78 12 00 mov 0x127858,%eax
10b0c7: 39 47 40 cmp %eax,0x40(%edi)
10b0ca: 74 0f je 10b0db <rtems_rate_monotonic_period+0x46>
_Thread_Enable_dispatch();
10b0cc: e8 05 26 00 00 call 10d6d6 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
10b0d1: bb 17 00 00 00 mov $0x17,%ebx
10b0d6: e9 29 01 00 00 jmp 10b204 <rtems_rate_monotonic_period+0x16f>
}
if ( length == RTEMS_PERIOD_STATUS ) {
10b0db: 85 db test %ebx,%ebx
10b0dd: 75 19 jne 10b0f8 <rtems_rate_monotonic_period+0x63>
switch ( the_period->state ) {
10b0df: 8b 47 38 mov 0x38(%edi),%eax
10b0e2: 83 f8 04 cmp $0x4,%eax
10b0e5: 77 07 ja 10b0ee <rtems_rate_monotonic_period+0x59><== NEVER TAKEN
10b0e7: 8b 1c 85 04 0f 12 00 mov 0x120f04(,%eax,4),%ebx
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
10b0ee: e8 e3 25 00 00 call 10d6d6 <_Thread_Enable_dispatch>
return( return_value );
10b0f3: e9 0c 01 00 00 jmp 10b204 <rtems_rate_monotonic_period+0x16f>
}
_ISR_Disable( level );
10b0f8: 9c pushf
10b0f9: fa cli
10b0fa: 8f 45 d4 popl -0x2c(%ebp)
switch ( the_period->state ) {
10b0fd: 8b 47 38 mov 0x38(%edi),%eax
10b100: 83 f8 02 cmp $0x2,%eax
10b103: 74 5d je 10b162 <rtems_rate_monotonic_period+0xcd>
10b105: 83 f8 04 cmp $0x4,%eax
10b108: 0f 84 b8 00 00 00 je 10b1c6 <rtems_rate_monotonic_period+0x131>
10b10e: 85 c0 test %eax,%eax
10b110: 0f 85 e9 00 00 00 jne 10b1ff <rtems_rate_monotonic_period+0x16a><== NEVER TAKEN
case RATE_MONOTONIC_INACTIVE: {
_ISR_Enable( level );
10b116: ff 75 d4 pushl -0x2c(%ebp)
10b119: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10b11a: 83 ec 0c sub $0xc,%esp
10b11d: 57 push %edi
10b11e: e8 2f fe ff ff call 10af52 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10b123: 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;
10b12a: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
the_watchdog->routine = routine;
10b131: c7 47 2c 10 b4 10 00 movl $0x10b410,0x2c(%edi)
the_watchdog->id = id;
10b138: 89 77 30 mov %esi,0x30(%edi)
the_watchdog->user_data = user_data;
10b13b: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10b142: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b145: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b148: 58 pop %eax
10b149: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b14a: 83 c7 10 add $0x10,%edi
10b14d: 57 push %edi
10b14e: 68 d0 73 12 00 push $0x1273d0
10b153: e8 e8 34 00 00 call 10e640 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b158: e8 79 25 00 00 call 10d6d6 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b15d: 83 c4 10 add $0x10,%esp
10b160: eb 60 jmp 10b1c2 <rtems_rate_monotonic_period+0x12d>
case RATE_MONOTONIC_ACTIVE:
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10b162: 83 ec 0c sub $0xc,%esp
10b165: 57 push %edi
10b166: e8 4f fe ff ff call 10afba <_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;
10b16b: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi)
the_period->next_length = length;
10b172: 89 5f 3c mov %ebx,0x3c(%edi)
_ISR_Enable( level );
10b175: ff 75 d4 pushl -0x2c(%ebp)
10b178: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10b179: a1 58 78 12 00 mov 0x127858,%eax
10b17e: 8b 57 08 mov 0x8(%edi),%edx
10b181: 89 50 20 mov %edx,0x20(%eax)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b184: 5b pop %ebx
10b185: 5e pop %esi
10b186: 68 00 40 00 00 push $0x4000
10b18b: 50 push %eax
10b18c: e8 43 2d 00 00 call 10ded4 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10b191: 9c pushf
10b192: fa cli
10b193: 5a pop %edx
local_state = the_period->state;
10b194: 8b 47 38 mov 0x38(%edi),%eax
the_period->state = RATE_MONOTONIC_ACTIVE;
10b197: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
_ISR_Enable( level );
10b19e: 52 push %edx
10b19f: 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 )
10b1a0: 83 c4 10 add $0x10,%esp
10b1a3: 83 f8 03 cmp $0x3,%eax
10b1a6: 75 15 jne 10b1bd <rtems_rate_monotonic_period+0x128>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b1a8: 51 push %ecx
10b1a9: 51 push %ecx
10b1aa: 68 00 40 00 00 push $0x4000
10b1af: ff 35 58 78 12 00 pushl 0x127858
10b1b5: e8 aa 21 00 00 call 10d364 <_Thread_Clear_state>
10b1ba: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
10b1bd: e8 14 25 00 00 call 10d6d6 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b1c2: 31 db xor %ebx,%ebx
10b1c4: eb 3e jmp 10b204 <rtems_rate_monotonic_period+0x16f>
case RATE_MONOTONIC_EXPIRED:
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10b1c6: 83 ec 0c sub $0xc,%esp
10b1c9: 57 push %edi
10b1ca: e8 eb fd ff ff call 10afba <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10b1cf: ff 75 d4 pushl -0x2c(%ebp)
10b1d2: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10b1d3: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
the_period->next_length = length;
10b1da: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b1dd: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b1e0: 58 pop %eax
10b1e1: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b1e2: 83 c7 10 add $0x10,%edi
10b1e5: 57 push %edi
10b1e6: 68 d0 73 12 00 push $0x1273d0
10b1eb: e8 50 34 00 00 call 10e640 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b1f0: e8 e1 24 00 00 call 10d6d6 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
10b1f5: 83 c4 10 add $0x10,%esp
10b1f8: bb 06 00 00 00 mov $0x6,%ebx
10b1fd: eb 05 jmp 10b204 <rtems_rate_monotonic_period+0x16f>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b1ff: bb 04 00 00 00 mov $0x4,%ebx
}
10b204: 89 d8 mov %ebx,%eax
10b206: 8d 65 f4 lea -0xc(%ebp),%esp
10b209: 5b pop %ebx
10b20a: 5e pop %esi
10b20b: 5f pop %edi
10b20c: c9 leave
10b20d: c3 ret
0010b210 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10b210: 55 push %ebp
10b211: 89 e5 mov %esp,%ebp
10b213: 57 push %edi
10b214: 56 push %esi
10b215: 53 push %ebx
10b216: 83 ec 7c sub $0x7c,%esp
10b219: 8b 5d 08 mov 0x8(%ebp),%ebx
10b21c: 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 )
10b21f: 85 ff test %edi,%edi
10b221: 0f 84 2b 01 00 00 je 10b352 <rtems_rate_monotonic_report_statistics_with_plugin+0x142><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10b227: 52 push %edx
10b228: 52 push %edx
10b229: 68 18 0f 12 00 push $0x120f18
10b22e: 53 push %ebx
10b22f: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
10b231: 5e pop %esi
10b232: 58 pop %eax
10b233: 68 36 0f 12 00 push $0x120f36
10b238: 53 push %ebx
10b239: ff d7 call *%edi
(*print)( context, "--- Wall times are in seconds ---\n" );
10b23b: 5a pop %edx
10b23c: 59 pop %ecx
10b23d: 68 58 0f 12 00 push $0x120f58
10b242: 53 push %ebx
10b243: ff d7 call *%edi
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
10b245: 5e pop %esi
10b246: 58 pop %eax
10b247: 68 7b 0f 12 00 push $0x120f7b
10b24c: 53 push %ebx
10b24d: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10b24f: 5a pop %edx
10b250: 59 pop %ecx
10b251: 68 c6 0f 12 00 push $0x120fc6
10b256: 53 push %ebx
10b257: 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 ;
10b259: 8b 35 1c 72 12 00 mov 0x12721c,%esi
10b25f: 83 c4 10 add $0x10,%esp
10b262: e9 df 00 00 00 jmp 10b346 <rtems_rate_monotonic_report_statistics_with_plugin+0x136>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10b267: 50 push %eax
10b268: 50 push %eax
10b269: 8d 45 88 lea -0x78(%ebp),%eax
10b26c: 50 push %eax
10b26d: 56 push %esi
10b26e: e8 c9 55 00 00 call 11083c <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10b273: 83 c4 10 add $0x10,%esp
10b276: 85 c0 test %eax,%eax
10b278: 0f 85 c7 00 00 00 jne 10b345 <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 );
10b27e: 51 push %ecx
10b27f: 51 push %ecx
10b280: 8d 55 c0 lea -0x40(%ebp),%edx
10b283: 52 push %edx
10b284: 56 push %esi
10b285: e8 56 56 00 00 call 1108e0 <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 );
10b28a: 83 c4 0c add $0xc,%esp
10b28d: 8d 45 e3 lea -0x1d(%ebp),%eax
10b290: 50 push %eax
10b291: 6a 05 push $0x5
10b293: ff 75 c0 pushl -0x40(%ebp)
10b296: e8 01 02 00 00 call 10b49c <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10b29b: 58 pop %eax
10b29c: 5a pop %edx
10b29d: ff 75 8c pushl -0x74(%ebp)
10b2a0: ff 75 88 pushl -0x78(%ebp)
10b2a3: 8d 55 e3 lea -0x1d(%ebp),%edx
10b2a6: 52 push %edx
10b2a7: 56 push %esi
10b2a8: 68 12 10 12 00 push $0x121012
10b2ad: 53 push %ebx
10b2ae: ff d7 call *%edi
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10b2b0: 8b 45 88 mov -0x78(%ebp),%eax
10b2b3: 83 c4 20 add $0x20,%esp
10b2b6: 85 c0 test %eax,%eax
10b2b8: 75 0f jne 10b2c9 <rtems_rate_monotonic_report_statistics_with_plugin+0xb9>
(*print)( context, "\n" );
10b2ba: 51 push %ecx
10b2bb: 51 push %ecx
10b2bc: 68 8c 12 12 00 push $0x12128c
10b2c1: 53 push %ebx
10b2c2: ff d7 call *%edi
continue;
10b2c4: 83 c4 10 add $0x10,%esp
10b2c7: eb 7c jmp 10b345 <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 );
10b2c9: 52 push %edx
10b2ca: 8d 55 d8 lea -0x28(%ebp),%edx
10b2cd: 52 push %edx
10b2ce: 50 push %eax
10b2cf: 8d 45 a0 lea -0x60(%ebp),%eax
10b2d2: 50 push %eax
10b2d3: e8 3c 30 00 00 call 10e314 <_Timespec_Divide_by_integer>
(*print)( context,
10b2d8: 8b 45 dc mov -0x24(%ebp),%eax
10b2db: b9 e8 03 00 00 mov $0x3e8,%ecx
10b2e0: 99 cltd
10b2e1: f7 f9 idiv %ecx
10b2e3: 50 push %eax
10b2e4: ff 75 d8 pushl -0x28(%ebp)
10b2e7: 8b 45 9c mov -0x64(%ebp),%eax
10b2ea: 99 cltd
10b2eb: f7 f9 idiv %ecx
10b2ed: 50 push %eax
10b2ee: ff 75 98 pushl -0x68(%ebp)
10b2f1: 8b 45 94 mov -0x6c(%ebp),%eax
10b2f4: 99 cltd
10b2f5: f7 f9 idiv %ecx
10b2f7: 50 push %eax
10b2f8: ff 75 90 pushl -0x70(%ebp)
10b2fb: 68 29 10 12 00 push $0x121029
10b300: 53 push %ebx
10b301: 89 4d 84 mov %ecx,-0x7c(%ebp)
10b304: 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);
10b306: 83 c4 2c add $0x2c,%esp
10b309: 8d 55 d8 lea -0x28(%ebp),%edx
10b30c: 52 push %edx
10b30d: 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;
10b310: 8d 45 b8 lea -0x48(%ebp),%eax
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
10b313: 50 push %eax
10b314: e8 fb 2f 00 00 call 10e314 <_Timespec_Divide_by_integer>
(*print)( context,
10b319: 8b 45 dc mov -0x24(%ebp),%eax
10b31c: 8b 4d 84 mov -0x7c(%ebp),%ecx
10b31f: 99 cltd
10b320: f7 f9 idiv %ecx
10b322: 50 push %eax
10b323: ff 75 d8 pushl -0x28(%ebp)
10b326: 8b 45 b4 mov -0x4c(%ebp),%eax
10b329: 99 cltd
10b32a: f7 f9 idiv %ecx
10b32c: 50 push %eax
10b32d: ff 75 b0 pushl -0x50(%ebp)
10b330: 8b 45 ac mov -0x54(%ebp),%eax
10b333: 99 cltd
10b334: f7 f9 idiv %ecx
10b336: 50 push %eax
10b337: ff 75 a8 pushl -0x58(%ebp)
10b33a: 68 48 10 12 00 push $0x121048
10b33f: 53 push %ebx
10b340: ff d7 call *%edi
10b342: 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++ ) {
10b345: 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 ;
10b346: 3b 35 20 72 12 00 cmp 0x127220,%esi
10b34c: 0f 86 15 ff ff ff jbe 10b267 <rtems_rate_monotonic_report_statistics_with_plugin+0x57>
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
10b352: 8d 65 f4 lea -0xc(%ebp),%esp
10b355: 5b pop %ebx
10b356: 5e pop %esi
10b357: 5f pop %edi
10b358: c9 leave
10b359: c3 ret
00115c40 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
115c40: 55 push %ebp
115c41: 89 e5 mov %esp,%ebp
115c43: 53 push %ebx
115c44: 83 ec 14 sub $0x14,%esp
115c47: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
115c4a: 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 )
115c4f: 85 db test %ebx,%ebx
115c51: 74 6d je 115cc0 <rtems_signal_send+0x80>
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
115c53: 50 push %eax
115c54: 50 push %eax
115c55: 8d 45 f4 lea -0xc(%ebp),%eax
115c58: 50 push %eax
115c59: ff 75 08 pushl 0x8(%ebp)
115c5c: e8 7f 37 00 00 call 1193e0 <_Thread_Get>
switch ( location ) {
115c61: 83 c4 10 add $0x10,%esp
115c64: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
115c68: 75 51 jne 115cbb <rtems_signal_send+0x7b>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
115c6a: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
115c70: 83 7a 0c 00 cmpl $0x0,0xc(%edx)
115c74: 74 39 je 115caf <rtems_signal_send+0x6f>
if ( asr->is_enabled ) {
115c76: 80 7a 08 00 cmpb $0x0,0x8(%edx)
115c7a: 74 22 je 115c9e <rtems_signal_send+0x5e>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115c7c: 9c pushf
115c7d: fa cli
115c7e: 59 pop %ecx
*signal_set |= signals;
115c7f: 09 5a 14 or %ebx,0x14(%edx)
_ISR_Enable( _level );
115c82: 51 push %ecx
115c83: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
115c84: 83 3d 0c eb 13 00 00 cmpl $0x0,0x13eb0c
115c8b: 74 19 je 115ca6 <rtems_signal_send+0x66>
115c8d: 3b 05 10 eb 13 00 cmp 0x13eb10,%eax
115c93: 75 11 jne 115ca6 <rtems_signal_send+0x66><== NEVER TAKEN
_Context_Switch_necessary = true;
115c95: c6 05 1c eb 13 00 01 movb $0x1,0x13eb1c
115c9c: eb 08 jmp 115ca6 <rtems_signal_send+0x66>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115c9e: 9c pushf
115c9f: fa cli
115ca0: 58 pop %eax
*signal_set |= signals;
115ca1: 09 5a 18 or %ebx,0x18(%edx)
_ISR_Enable( _level );
115ca4: 50 push %eax
115ca5: 9d popf
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
115ca6: e8 13 37 00 00 call 1193be <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115cab: 31 c0 xor %eax,%eax
115cad: eb 11 jmp 115cc0 <rtems_signal_send+0x80>
}
_Thread_Enable_dispatch();
115caf: e8 0a 37 00 00 call 1193be <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
115cb4: b8 0b 00 00 00 mov $0xb,%eax
115cb9: eb 05 jmp 115cc0 <rtems_signal_send+0x80>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115cbb: b8 04 00 00 00 mov $0x4,%eax
}
115cc0: 8b 5d fc mov -0x4(%ebp),%ebx
115cc3: c9 leave
115cc4: c3 ret
00106b40 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
106b40: 55 push %ebp
106b41: 89 e5 mov %esp,%ebp
106b43: 57 push %edi
106b44: 56 push %esi
106b45: 8b 45 08 mov 0x8(%ebp),%eax
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
106b48: 83 78 08 00 cmpl $0x0,0x8(%eax)
106b4c: 74 15 je 106b63 <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;
106b4e: 8b b8 c8 00 00 00 mov 0xc8(%eax),%edi
106b54: 83 c7 08 add $0x8,%edi
106b57: be e0 51 12 00 mov $0x1251e0,%esi
106b5c: b9 04 00 00 00 mov $0x4,%ecx
106b61: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
106b63: 5e pop %esi
106b64: 5f pop %edi
106b65: c9 leave
106b66: c3 ret
00106b1e <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
106b1e: 55 push %ebp
106b1f: 89 e5 mov %esp,%ebp
106b21: 57 push %edi
106b22: 8b 45 0c mov 0xc(%ebp),%eax
Stack_check_Initialize();
if (the_thread)
106b25: 85 c0 test %eax,%eax
106b27: 74 12 je 106b3b <rtems_stack_checker_create_extension+0x1d><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
106b29: 8b 88 c4 00 00 00 mov 0xc4(%eax),%ecx
106b2f: 8b 90 c8 00 00 00 mov 0xc8(%eax),%edx
106b35: b0 a5 mov $0xa5,%al
106b37: 89 d7 mov %edx,%edi
106b39: f3 aa rep stos %al,%es:(%edi)
return true;
}
106b3b: b0 01 mov $0x1,%al
106b3d: 5f pop %edi
106b3e: c9 leave
106b3f: c3 ret
00106c74 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
106c74: 55 push %ebp
106c75: 89 e5 mov %esp,%ebp
106c77: 83 ec 08 sub $0x8,%esp
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
106c7a: a1 94 58 12 00 mov 0x125894,%eax
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
106c7f: 8b 90 c8 00 00 00 mov 0xc8(%eax),%edx
106c85: 39 d5 cmp %edx,%ebp
106c87: 72 0a jb 106c93 <rtems_stack_checker_is_blown+0x1f><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
106c89: 03 90 c4 00 00 00 add 0xc4(%eax),%edx
106c8f: 39 d5 cmp %edx,%ebp
106c91: 76 0f jbe 106ca2 <rtems_stack_checker_is_blown+0x2e><== ALWAYS TAKEN
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
106c93: 52 push %edx <== NOT EXECUTED
106c94: 52 push %edx <== NOT EXECUTED
106c95: 6a 01 push $0x1 <== NOT EXECUTED
106c97: ff 35 94 58 12 00 pushl 0x125894 <== NOT EXECUTED
106c9d: e8 c5 fe ff ff call 106b67 <Stack_check_report_blown_task><== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
106ca2: 31 c0 xor %eax,%eax
106ca4: c9 leave
106ca5: c3 ret
00106d0b <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
106d0b: 55 push %ebp <== NOT EXECUTED
106d0c: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106d0e: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
106d11: 68 f4 81 10 00 push $0x1081f4 <== NOT EXECUTED
106d16: 6a 00 push $0x0 <== NOT EXECUTED
106d18: e8 89 ff ff ff call 106ca6 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
106d1d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
106d20: c9 leave <== NOT EXECUTED
106d21: c3 ret <== NOT EXECUTED
00106ca6 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
106ca6: 55 push %ebp <== NOT EXECUTED
106ca7: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106ca9: 56 push %esi <== NOT EXECUTED
106caa: 53 push %ebx <== NOT EXECUTED
106cab: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
106cae: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
if ( !print )
106cb1: 85 db test %ebx,%ebx <== NOT EXECUTED
106cb3: 74 4f je 106d04 <rtems_stack_checker_report_usage_with_plugin+0x5e><== NOT EXECUTED
return;
print_context = context;
106cb5: 89 35 cc 4e 12 00 mov %esi,0x124ecc <== NOT EXECUTED
print_handler = print;
106cbb: 89 1d d0 4e 12 00 mov %ebx,0x124ed0 <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
106cc1: 52 push %edx <== NOT EXECUTED
106cc2: 52 push %edx <== NOT EXECUTED
106cc3: 68 33 ec 11 00 push $0x11ec33 <== NOT EXECUTED
106cc8: 56 push %esi <== NOT EXECUTED
106cc9: ff d3 call *%ebx <== NOT EXECUTED
(*print)( context,
106ccb: 59 pop %ecx <== NOT EXECUTED
106ccc: 58 pop %eax <== NOT EXECUTED
106ccd: 68 4a ec 11 00 push $0x11ec4a <== NOT EXECUTED
106cd2: 56 push %esi <== NOT EXECUTED
106cd3: 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 );
106cd5: c7 04 24 68 6a 10 00 movl $0x106a68,(%esp) <== NOT EXECUTED
106cdc: e8 cb 48 00 00 call 10b5ac <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);
106ce1: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED
106ce8: e8 7b fd ff ff call 106a68 <Stack_check_Dump_threads_usage><== NOT EXECUTED
#endif
print_context = NULL;
106ced: c7 05 cc 4e 12 00 00 movl $0x0,0x124ecc <== NOT EXECUTED
106cf4: 00 00 00
print_handler = NULL;
106cf7: c7 05 d0 4e 12 00 00 movl $0x0,0x124ed0 <== NOT EXECUTED
106cfe: 00 00 00
106d01: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
106d04: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
106d07: 5b pop %ebx <== NOT EXECUTED
106d08: 5e pop %esi <== NOT EXECUTED
106d09: c9 leave <== NOT EXECUTED
106d0a: c3 ret <== NOT EXECUTED
00106c1b <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
106c1b: 55 push %ebp
106c1c: 89 e5 mov %esp,%ebp
106c1e: 53 push %ebx
106c1f: 83 ec 14 sub $0x14,%esp
106c22: 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;
106c25: 8b 83 c8 00 00 00 mov 0xc8(%ebx),%eax
106c2b: 8d 48 08 lea 0x8(%eax),%ecx
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
106c2e: 31 d2 xor %edx,%edx
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
106c30: 39 c5 cmp %eax,%ebp
106c32: 72 0b jb 106c3f <rtems_stack_checker_switch_extension+0x24><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
106c34: 03 83 c4 00 00 00 add 0xc4(%ebx),%eax
}
/*
* rtems_stack_checker_switch_extension
*/
void rtems_stack_checker_switch_extension(
106c3a: 39 c5 cmp %eax,%ebp
106c3c: 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,
106c3f: 50 push %eax
106c40: 6a 10 push $0x10
106c42: 68 e0 51 12 00 push $0x1251e0
106c47: 51 push %ecx
106c48: 88 55 f4 mov %dl,-0xc(%ebp)
106c4b: e8 80 b1 00 00 call 111dd0 <memcmp>
106c50: 83 c4 10 add $0x10,%esp
106c53: 85 c0 test %eax,%eax
106c55: 0f 94 c0 sete %al
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
106c58: 8a 55 f4 mov -0xc(%ebp),%dl
106c5b: 84 d2 test %dl,%dl
106c5d: 74 04 je 106c63 <rtems_stack_checker_switch_extension+0x48><== NEVER TAKEN
106c5f: 84 c0 test %al,%al
106c61: 75 0c jne 106c6f <rtems_stack_checker_switch_extension+0x54><== ALWAYS TAKEN
Stack_check_report_blown_task( running, pattern_ok );
106c63: 52 push %edx <== NOT EXECUTED
106c64: 52 push %edx <== NOT EXECUTED
106c65: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
106c68: 50 push %eax <== NOT EXECUTED
106c69: 53 push %ebx <== NOT EXECUTED
106c6a: e8 f8 fe ff ff call 106b67 <Stack_check_report_blown_task><== NOT EXECUTED
}
}
106c6f: 8b 5d fc mov -0x4(%ebp),%ebx
106c72: c9 leave
106c73: c3 ret
0010edd0 <rtems_string_to_double>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10edd0: 55 push %ebp
10edd1: 89 e5 mov %esp,%ebp
10edd3: 57 push %edi
10edd4: 56 push %esi
10edd5: 53 push %ebx
10edd6: 83 ec 2c sub $0x2c,%esp
10edd9: 8b 75 08 mov 0x8(%ebp),%esi
10eddc: 8b 5d 0c mov 0xc(%ebp),%ebx
10eddf: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10ede2: b8 09 00 00 00 mov $0x9,%eax
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10ede7: 85 db test %ebx,%ebx
10ede9: 74 6e je 10ee59 <rtems_string_to_double+0x89>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10edeb: e8 b4 2a 00 00 call 1118a4 <__errno>
10edf0: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10edf6: c7 03 00 00 00 00 movl $0x0,(%ebx)
10edfc: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
10ee03: 50 push %eax
10ee04: 50 push %eax
10ee05: 8d 45 e4 lea -0x1c(%ebp),%eax
10ee08: 50 push %eax
10ee09: 56 push %esi
10ee0a: e8 11 56 00 00 call 114420 <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 )
10ee0f: 83 c4 10 add $0x10,%esp
10ee12: 85 ff test %edi,%edi
10ee14: 74 05 je 10ee1b <rtems_string_to_double+0x4b>
*endptr = end;
10ee16: 8b 45 e4 mov -0x1c(%ebp),%eax
10ee19: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10ee1b: 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 )
10ee20: 39 75 e4 cmp %esi,-0x1c(%ebp)
10ee23: 74 2e je 10ee53 <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))
10ee25: dd 05 60 34 12 00 fldl 0x123460
10ee2b: d9 c9 fxch %st(1)
10ee2d: dd e1 fucom %st(1)
10ee2f: df e0 fnstsw %ax
10ee31: dd d9 fstp %st(1)
10ee33: 9e sahf
10ee34: 76 17 jbe 10ee4d <rtems_string_to_double+0x7d>
10ee36: dd 5d c8 fstpl -0x38(%ebp)
10ee39: e8 66 2a 00 00 call 1118a4 <__errno>
10ee3e: 89 c2 mov %eax,%edx
return RTEMS_INVALID_NUMBER;
10ee40: 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))
10ee45: 83 3a 22 cmpl $0x22,(%edx)
10ee48: dd 45 c8 fldl -0x38(%ebp)
10ee4b: 74 0a je 10ee57 <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;
10ee4d: dd 1b fstpl (%ebx)
#endif
return RTEMS_SUCCESSFUL;
10ee4f: 31 c0 xor %eax,%eax
10ee51: eb 06 jmp 10ee59 <rtems_string_to_double+0x89>
10ee53: dd d8 fstp %st(0)
10ee55: eb 02 jmp 10ee59 <rtems_string_to_double+0x89>
10ee57: dd d8 fstp %st(0)
}
10ee59: 8d 65 f4 lea -0xc(%ebp),%esp
10ee5c: 5b pop %ebx
10ee5d: 5e pop %esi
10ee5e: 5f pop %edi
10ee5f: c9 leave
10ee60: c3 ret
0010ee64 <rtems_string_to_float>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10ee64: 55 push %ebp
10ee65: 89 e5 mov %esp,%ebp
10ee67: 57 push %edi
10ee68: 56 push %esi
10ee69: 53 push %ebx
10ee6a: 83 ec 2c sub $0x2c,%esp
10ee6d: 8b 75 08 mov 0x8(%ebp),%esi
10ee70: 8b 5d 0c mov 0xc(%ebp),%ebx
10ee73: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10ee76: b8 09 00 00 00 mov $0x9,%eax
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10ee7b: 85 db test %ebx,%ebx
10ee7d: 74 67 je 10eee6 <rtems_string_to_float+0x82>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10ee7f: e8 20 2a 00 00 call 1118a4 <__errno>
10ee84: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10ee8a: c7 03 00 00 00 00 movl $0x0,(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
10ee90: 50 push %eax
10ee91: 50 push %eax
10ee92: 8d 45 e4 lea -0x1c(%ebp),%eax
10ee95: 50 push %eax
10ee96: 56 push %esi
10ee97: e8 a0 55 00 00 call 11443c <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 )
10ee9c: 83 c4 10 add $0x10,%esp
10ee9f: 85 ff test %edi,%edi
10eea1: 74 05 je 10eea8 <rtems_string_to_float+0x44>
*endptr = end;
10eea3: 8b 45 e4 mov -0x1c(%ebp),%eax
10eea6: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10eea8: 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 )
10eead: 39 75 e4 cmp %esi,-0x1c(%ebp)
10eeb0: 74 2e je 10eee0 <rtems_string_to_float+0x7c>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10eeb2: d9 05 68 34 12 00 flds 0x123468
10eeb8: d9 c9 fxch %st(1)
10eeba: dd e1 fucom %st(1)
10eebc: df e0 fnstsw %ax
10eebe: dd d9 fstp %st(1)
10eec0: 9e sahf
10eec1: 76 17 jbe 10eeda <rtems_string_to_float+0x76>
10eec3: d9 5d c8 fstps -0x38(%ebp)
10eec6: e8 d9 29 00 00 call 1118a4 <__errno>
10eecb: 89 c2 mov %eax,%edx
return RTEMS_INVALID_NUMBER;
10eecd: 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))
10eed2: 83 3a 22 cmpl $0x22,(%edx)
10eed5: d9 45 c8 flds -0x38(%ebp)
10eed8: 74 0a je 10eee4 <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;
10eeda: d9 1b fstps (%ebx)
#endif
return RTEMS_SUCCESSFUL;
10eedc: 31 c0 xor %eax,%eax
10eede: eb 06 jmp 10eee6 <rtems_string_to_float+0x82>
10eee0: dd d8 fstp %st(0)
10eee2: eb 02 jmp 10eee6 <rtems_string_to_float+0x82>
10eee4: dd d8 fstp %st(0)
}
10eee6: 8d 65 f4 lea -0xc(%ebp),%esp
10eee9: 5b pop %ebx
10eeea: 5e pop %esi
10eeeb: 5f pop %edi
10eeec: c9 leave
10eeed: c3 ret
0010eef0 <rtems_string_to_int>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10eef0: 55 push %ebp
10eef1: 89 e5 mov %esp,%ebp
10eef3: 57 push %edi
10eef4: 56 push %esi
10eef5: 53 push %ebx
10eef6: 83 ec 2c sub $0x2c,%esp
10eef9: 8b 7d 08 mov 0x8(%ebp),%edi
10eefc: 8b 5d 0c mov 0xc(%ebp),%ebx
10eeff: 8b 55 10 mov 0x10(%ebp),%edx
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10ef02: b8 09 00 00 00 mov $0x9,%eax
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10ef07: 85 db test %ebx,%ebx
10ef09: 74 5a je 10ef65 <rtems_string_to_int+0x75>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10ef0b: 89 55 d4 mov %edx,-0x2c(%ebp)
10ef0e: e8 91 29 00 00 call 1118a4 <__errno>
10ef13: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10ef19: 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 );
10ef1f: 50 push %eax
10ef20: ff 75 14 pushl 0x14(%ebp)
10ef23: 8d 45 e4 lea -0x1c(%ebp),%eax
10ef26: 50 push %eax
10ef27: 57 push %edi
10ef28: e8 d3 56 00 00 call 114600 <strtol>
10ef2d: 89 c6 mov %eax,%esi
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
10ef2f: 83 c4 10 add $0x10,%esp
10ef32: 8b 55 d4 mov -0x2c(%ebp),%edx
10ef35: 85 d2 test %edx,%edx
10ef37: 74 05 je 10ef3e <rtems_string_to_int+0x4e>
*endptr = end;
10ef39: 8b 45 e4 mov -0x1c(%ebp),%eax
10ef3c: 89 02 mov %eax,(%edx)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10ef3e: 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 )
10ef43: 39 7d e4 cmp %edi,-0x1c(%ebp)
10ef46: 74 1d je 10ef65 <rtems_string_to_int+0x75>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10ef48: 81 fe ff ff ff 7f cmp $0x7fffffff,%esi
10ef4e: 75 11 jne 10ef61 <rtems_string_to_int+0x71>
10ef50: e8 4f 29 00 00 call 1118a4 <__errno>
10ef55: 89 c2 mov %eax,%edx
return RTEMS_INVALID_NUMBER;
10ef57: 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))
10ef5c: 83 3a 22 cmpl $0x22,(%edx)
10ef5f: 74 04 je 10ef65 <rtems_string_to_int+0x75><== ALWAYS TAKEN
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
10ef61: 89 33 mov %esi,(%ebx)
#endif
return RTEMS_SUCCESSFUL;
10ef63: 31 c0 xor %eax,%eax
}
10ef65: 8d 65 f4 lea -0xc(%ebp),%esp
10ef68: 5b pop %ebx
10ef69: 5e pop %esi
10ef6a: 5f pop %edi
10ef6b: c9 leave
10ef6c: c3 ret
0010f008 <rtems_string_to_long>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10f008: 55 push %ebp
10f009: 89 e5 mov %esp,%ebp
10f00b: 57 push %edi
10f00c: 56 push %esi
10f00d: 53 push %ebx
10f00e: 83 ec 2c sub $0x2c,%esp
10f011: 8b 7d 08 mov 0x8(%ebp),%edi
10f014: 8b 5d 0c mov 0xc(%ebp),%ebx
10f017: 8b 55 10 mov 0x10(%ebp),%edx
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f01a: b9 09 00 00 00 mov $0x9,%ecx
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10f01f: 85 db test %ebx,%ebx
10f021: 74 60 je 10f083 <rtems_string_to_long+0x7b>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f023: 89 55 d4 mov %edx,-0x2c(%ebp)
10f026: e8 79 28 00 00 call 1118a4 <__errno>
10f02b: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f031: 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 );
10f037: 50 push %eax
10f038: ff 75 14 pushl 0x14(%ebp)
10f03b: 8d 45 e4 lea -0x1c(%ebp),%eax
10f03e: 50 push %eax
10f03f: 57 push %edi
10f040: e8 bb 55 00 00 call 114600 <strtol>
10f045: 89 c6 mov %eax,%esi
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
10f047: 83 c4 10 add $0x10,%esp
10f04a: 8b 55 d4 mov -0x2c(%ebp),%edx
10f04d: 85 d2 test %edx,%edx
10f04f: 74 05 je 10f056 <rtems_string_to_long+0x4e>
*endptr = end;
10f051: 8b 45 e4 mov -0x1c(%ebp),%eax
10f054: 89 02 mov %eax,(%edx)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10f056: 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 )
10f05b: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f05e: 74 23 je 10f083 <rtems_string_to_long+0x7b>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
10f060: 81 fe ff ff ff 7f cmp $0x7fffffff,%esi
10f066: 74 08 je 10f070 <rtems_string_to_long+0x68>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MIN
/* there was an underflow */
if ( (result == STRING_TO_MIN) && (errno == ERANGE))
10f068: 81 fe 00 00 00 80 cmp $0x80000000,%esi
10f06e: 75 0f jne 10f07f <rtems_string_to_long+0x77>
10f070: e8 2f 28 00 00 call 1118a4 <__errno>
return RTEMS_INVALID_NUMBER;
10f075: 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))
10f07a: 83 38 22 cmpl $0x22,(%eax)
10f07d: 74 04 je 10f083 <rtems_string_to_long+0x7b><== ALWAYS TAKEN
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
10f07f: 89 33 mov %esi,(%ebx)
#endif
return RTEMS_SUCCESSFUL;
10f081: 31 c9 xor %ecx,%ecx
}
10f083: 89 c8 mov %ecx,%eax
10f085: 8d 65 f4 lea -0xc(%ebp),%esp
10f088: 5b pop %ebx
10f089: 5e pop %esi
10f08a: 5f pop %edi
10f08b: c9 leave
10f08c: c3 ret
0010ef70 <rtems_string_to_long_long>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10ef70: 55 push %ebp
10ef71: 89 e5 mov %esp,%ebp
10ef73: 57 push %edi
10ef74: 56 push %esi
10ef75: 53 push %ebx
10ef76: 83 ec 2c sub $0x2c,%esp
10ef79: 8b 5d 0c mov 0xc(%ebp),%ebx
10ef7c: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10ef7f: b9 09 00 00 00 mov $0x9,%ecx
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10ef84: 85 db test %ebx,%ebx
10ef86: 74 76 je 10effe <rtems_string_to_long_long+0x8e>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10ef88: e8 17 29 00 00 call 1118a4 <__errno>
10ef8d: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10ef93: c7 03 00 00 00 00 movl $0x0,(%ebx)
10ef99: 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 );
10efa0: 50 push %eax
10efa1: ff 75 14 pushl 0x14(%ebp)
10efa4: 8d 45 e4 lea -0x1c(%ebp),%eax
10efa7: 50 push %eax
10efa8: ff 75 08 pushl 0x8(%ebp)
10efab: e8 6c 56 00 00 call 11461c <strtoll>
10efb0: 89 c6 mov %eax,%esi
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
10efb2: 83 c4 10 add $0x10,%esp
10efb5: 85 ff test %edi,%edi
10efb7: 74 05 je 10efbe <rtems_string_to_long_long+0x4e>
*endptr = end;
10efb9: 8b 45 e4 mov -0x1c(%ebp),%eax
10efbc: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10efbe: 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 )
10efc3: 8b 45 08 mov 0x8(%ebp),%eax
10efc6: 39 45 e4 cmp %eax,-0x1c(%ebp)
10efc9: 74 33 je 10effe <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))
10efcb: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
10efd1: 75 05 jne 10efd8 <rtems_string_to_long_long+0x68>
10efd3: 83 fe ff cmp $0xffffffff,%esi
10efd6: 74 0a je 10efe2 <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))
10efd8: 8d 82 00 00 00 80 lea -0x80000000(%edx),%eax
10efde: 09 f0 or %esi,%eax
10efe0: 75 15 jne 10eff7 <rtems_string_to_long_long+0x87>
10efe2: 89 55 d4 mov %edx,-0x2c(%ebp)
10efe5: e8 ba 28 00 00 call 1118a4 <__errno>
return RTEMS_INVALID_NUMBER;
10efea: 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))
10efef: 83 38 22 cmpl $0x22,(%eax)
10eff2: 8b 55 d4 mov -0x2c(%ebp),%edx
10eff5: 74 07 je 10effe <rtems_string_to_long_long+0x8e><== ALWAYS TAKEN
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
10eff7: 89 33 mov %esi,(%ebx)
10eff9: 89 53 04 mov %edx,0x4(%ebx)
#endif
return RTEMS_SUCCESSFUL;
10effc: 31 c9 xor %ecx,%ecx
}
10effe: 89 c8 mov %ecx,%eax
10f000: 8d 65 f4 lea -0xc(%ebp),%esp
10f003: 5b pop %ebx
10f004: 5e pop %esi
10f005: 5f pop %edi
10f006: c9 leave
10f007: c3 ret
0010f090 <rtems_string_to_pointer>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10f090: 55 push %ebp
10f091: 89 e5 mov %esp,%ebp
10f093: 57 push %edi
10f094: 56 push %esi
10f095: 53 push %ebx
10f096: 83 ec 2c sub $0x2c,%esp
10f099: 8b 7d 08 mov 0x8(%ebp),%edi
10f09c: 8b 5d 0c mov 0xc(%ebp),%ebx
10f09f: 8b 55 10 mov 0x10(%ebp),%edx
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f0a2: b8 09 00 00 00 mov $0x9,%eax
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10f0a7: 85 db test %ebx,%ebx
10f0a9: 74 56 je 10f101 <rtems_string_to_pointer+0x71>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f0ab: 89 55 d4 mov %edx,-0x2c(%ebp)
10f0ae: e8 f1 27 00 00 call 1118a4 <__errno>
10f0b3: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f0b9: 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 );
10f0bf: 50 push %eax
10f0c0: 6a 10 push $0x10
10f0c2: 8d 45 e4 lea -0x1c(%ebp),%eax
10f0c5: 50 push %eax
10f0c6: 57 push %edi
10f0c7: e8 fc 59 00 00 call 114ac8 <strtoul>
10f0cc: 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 )
10f0ce: 83 c4 10 add $0x10,%esp
10f0d1: 8b 55 d4 mov -0x2c(%ebp),%edx
10f0d4: 85 d2 test %edx,%edx
10f0d6: 74 05 je 10f0dd <rtems_string_to_pointer+0x4d>
*endptr = end;
10f0d8: 8b 45 e4 mov -0x1c(%ebp),%eax
10f0db: 89 02 mov %eax,(%edx)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10f0dd: 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 )
10f0e2: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f0e5: 74 1a je 10f101 <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))
10f0e7: 83 fe ff cmp $0xffffffff,%esi
10f0ea: 75 11 jne 10f0fd <rtems_string_to_pointer+0x6d><== ALWAYS TAKEN
10f0ec: e8 b3 27 00 00 call 1118a4 <__errno> <== NOT EXECUTED
10f0f1: 89 c2 mov %eax,%edx <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
10f0f3: 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))
10f0f8: 83 3a 22 cmpl $0x22,(%edx) <== NOT EXECUTED
10f0fb: 74 04 je 10f101 <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;
10f0fd: 89 33 mov %esi,(%ebx)
#else
*n = (STRING_TO_TYPE) result;
#endif
return RTEMS_SUCCESSFUL;
10f0ff: 31 c0 xor %eax,%eax
}
10f101: 8d 65 f4 lea -0xc(%ebp),%esp
10f104: 5b pop %ebx
10f105: 5e pop %esi
10f106: 5f pop %edi
10f107: c9 leave
10f108: c3 ret
0010f168 <rtems_string_to_unsigned_int>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10f168: 55 push %ebp
10f169: 89 e5 mov %esp,%ebp
10f16b: 57 push %edi
10f16c: 56 push %esi
10f16d: 53 push %ebx
10f16e: 83 ec 2c sub $0x2c,%esp
10f171: 8b 7d 08 mov 0x8(%ebp),%edi
10f174: 8b 5d 0c mov 0xc(%ebp),%ebx
10f177: 8b 55 10 mov 0x10(%ebp),%edx
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f17a: b8 09 00 00 00 mov $0x9,%eax
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10f17f: 85 db test %ebx,%ebx
10f181: 74 57 je 10f1da <rtems_string_to_unsigned_int+0x72>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f183: 89 55 d4 mov %edx,-0x2c(%ebp)
10f186: e8 19 27 00 00 call 1118a4 <__errno>
10f18b: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f191: 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 );
10f197: 50 push %eax
10f198: ff 75 14 pushl 0x14(%ebp)
10f19b: 8d 45 e4 lea -0x1c(%ebp),%eax
10f19e: 50 push %eax
10f19f: 57 push %edi
10f1a0: e8 23 59 00 00 call 114ac8 <strtoul>
10f1a5: 89 c6 mov %eax,%esi
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
10f1a7: 83 c4 10 add $0x10,%esp
10f1aa: 8b 55 d4 mov -0x2c(%ebp),%edx
10f1ad: 85 d2 test %edx,%edx
10f1af: 74 05 je 10f1b6 <rtems_string_to_unsigned_int+0x4e>
*endptr = end;
10f1b1: 8b 45 e4 mov -0x1c(%ebp),%eax
10f1b4: 89 02 mov %eax,(%edx)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10f1b6: 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 )
10f1bb: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f1be: 74 1a je 10f1da <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))
10f1c0: 83 fe ff cmp $0xffffffff,%esi
10f1c3: 75 11 jne 10f1d6 <rtems_string_to_unsigned_int+0x6e>
10f1c5: e8 da 26 00 00 call 1118a4 <__errno>
10f1ca: 89 c2 mov %eax,%edx
return RTEMS_INVALID_NUMBER;
10f1cc: 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))
10f1d1: 83 3a 22 cmpl $0x22,(%edx)
10f1d4: 74 04 je 10f1da <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;
10f1d6: 89 33 mov %esi,(%ebx)
#endif
return RTEMS_SUCCESSFUL;
10f1d8: 31 c0 xor %eax,%eax
}
10f1da: 8d 65 f4 lea -0xc(%ebp),%esp
10f1dd: 5b pop %ebx
10f1de: 5e pop %esi
10f1df: 5f pop %edi
10f1e0: c9 leave
10f1e1: c3 ret
0010f270 <rtems_string_to_unsigned_long>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10f270: 55 push %ebp
10f271: 89 e5 mov %esp,%ebp
10f273: 57 push %edi
10f274: 56 push %esi
10f275: 53 push %ebx
10f276: 83 ec 2c sub $0x2c,%esp
10f279: 8b 7d 08 mov 0x8(%ebp),%edi
10f27c: 8b 5d 0c mov 0xc(%ebp),%ebx
10f27f: 8b 55 10 mov 0x10(%ebp),%edx
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f282: b8 09 00 00 00 mov $0x9,%eax
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10f287: 85 db test %ebx,%ebx
10f289: 74 57 je 10f2e2 <rtems_string_to_unsigned_long+0x72>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f28b: 89 55 d4 mov %edx,-0x2c(%ebp)
10f28e: e8 11 26 00 00 call 1118a4 <__errno>
10f293: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f299: 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 );
10f29f: 50 push %eax
10f2a0: ff 75 14 pushl 0x14(%ebp)
10f2a3: 8d 45 e4 lea -0x1c(%ebp),%eax
10f2a6: 50 push %eax
10f2a7: 57 push %edi
10f2a8: e8 1b 58 00 00 call 114ac8 <strtoul>
10f2ad: 89 c6 mov %eax,%esi
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
10f2af: 83 c4 10 add $0x10,%esp
10f2b2: 8b 55 d4 mov -0x2c(%ebp),%edx
10f2b5: 85 d2 test %edx,%edx
10f2b7: 74 05 je 10f2be <rtems_string_to_unsigned_long+0x4e>
*endptr = end;
10f2b9: 8b 45 e4 mov -0x1c(%ebp),%eax
10f2bc: 89 02 mov %eax,(%edx)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10f2be: 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 )
10f2c3: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f2c6: 74 1a je 10f2e2 <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))
10f2c8: 83 fe ff cmp $0xffffffff,%esi
10f2cb: 75 11 jne 10f2de <rtems_string_to_unsigned_long+0x6e>
10f2cd: e8 d2 25 00 00 call 1118a4 <__errno>
10f2d2: 89 c2 mov %eax,%edx
return RTEMS_INVALID_NUMBER;
10f2d4: 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))
10f2d9: 83 3a 22 cmpl $0x22,(%edx)
10f2dc: 74 04 je 10f2e2 <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;
10f2de: 89 33 mov %esi,(%ebx)
#endif
return RTEMS_SUCCESSFUL;
10f2e0: 31 c0 xor %eax,%eax
}
10f2e2: 8d 65 f4 lea -0xc(%ebp),%esp
10f2e5: 5b pop %ebx
10f2e6: 5e pop %esi
10f2e7: 5f pop %edi
10f2e8: c9 leave
10f2e9: c3 ret
0010f1e4 <rtems_string_to_unsigned_long_long>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
10f1e4: 55 push %ebp
10f1e5: 89 e5 mov %esp,%ebp
10f1e7: 57 push %edi
10f1e8: 56 push %esi
10f1e9: 53 push %ebx
10f1ea: 83 ec 2c sub $0x2c,%esp
10f1ed: 8b 5d 0c mov 0xc(%ebp),%ebx
10f1f0: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f1f3: b8 09 00 00 00 mov $0x9,%eax
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
10f1f8: 85 db test %ebx,%ebx
10f1fa: 74 6b je 10f267 <rtems_string_to_unsigned_long_long+0x83>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f1fc: e8 a3 26 00 00 call 1118a4 <__errno>
10f201: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f207: c7 03 00 00 00 00 movl $0x0,(%ebx)
10f20d: 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 );
10f214: 50 push %eax
10f215: ff 75 14 pushl 0x14(%ebp)
10f218: 8d 45 e4 lea -0x1c(%ebp),%eax
10f21b: 50 push %eax
10f21c: ff 75 08 pushl 0x8(%ebp)
10f21f: e8 c0 58 00 00 call 114ae4 <strtoull>
10f224: 89 c6 mov %eax,%esi
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
10f226: 83 c4 10 add $0x10,%esp
10f229: 85 ff test %edi,%edi
10f22b: 74 05 je 10f232 <rtems_string_to_unsigned_long_long+0x4e>
*endptr = end;
10f22d: 8b 45 e4 mov -0x1c(%ebp),%eax
10f230: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
10f232: 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 )
10f237: 8b 4d 08 mov 0x8(%ebp),%ecx
10f23a: 39 4d e4 cmp %ecx,-0x1c(%ebp)
10f23d: 74 28 je 10f267 <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))
10f23f: 83 fa ff cmp $0xffffffff,%edx
10f242: 75 1c jne 10f260 <rtems_string_to_unsigned_long_long+0x7c>
10f244: 83 fe ff cmp $0xffffffff,%esi
10f247: 75 17 jne 10f260 <rtems_string_to_unsigned_long_long+0x7c><== NEVER TAKEN
10f249: 89 55 d4 mov %edx,-0x2c(%ebp)
10f24c: e8 53 26 00 00 call 1118a4 <__errno>
10f251: 89 c1 mov %eax,%ecx
return RTEMS_INVALID_NUMBER;
10f253: 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))
10f258: 83 39 22 cmpl $0x22,(%ecx)
10f25b: 8b 55 d4 mov -0x2c(%ebp),%edx
10f25e: 74 07 je 10f267 <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;
10f260: 89 33 mov %esi,(%ebx)
10f262: 89 53 04 mov %edx,0x4(%ebx)
#endif
return RTEMS_SUCCESSFUL;
10f265: 31 c0 xor %eax,%eax
}
10f267: 8d 65 f4 lea -0xc(%ebp),%esp
10f26a: 5b pop %ebx
10f26b: 5e pop %esi
10f26c: 5f pop %edi
10f26d: c9 leave
10f26e: c3 ret
00106e08 <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
106e08: 55 push %ebp
106e09: 89 e5 mov %esp,%ebp
106e0b: 57 push %edi
106e0c: 56 push %esi
106e0d: 53 push %ebx
106e0e: 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(
106e14: 31 c0 xor %eax,%eax
106e16: 83 c9 ff or $0xffffffff,%ecx
106e19: 8b 7d 08 mov 0x8(%ebp),%edi
106e1c: f2 ae repnz scas %es:(%edi),%al
106e1e: f7 d1 not %ecx
106e20: 49 dec %ecx
106e21: 6a 00 push $0x0
106e23: 8d 45 d0 lea -0x30(%ebp),%eax
106e26: 50 push %eax
106e27: 6a 00 push $0x0
106e29: 51 push %ecx
106e2a: ff 75 08 pushl 0x8(%ebp)
106e2d: e8 1b 0a 00 00 call 10784d <rtems_filesystem_evaluate_path>
106e32: 89 85 54 fe ff ff mov %eax,-0x1ac(%ebp)
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
106e38: 83 c4 20 add $0x20,%esp
106e3b: 85 c0 test %eax,%eax
106e3d: 0f 85 d9 01 00 00 jne 10701c <rtems_tarfs_load+0x214><== NEVER TAKEN
return -1;
if (root_loc.ops != &IMFS_ops
106e43: 8b 45 dc mov -0x24(%ebp),%eax
106e46: 31 f6 xor %esi,%esi
106e48: 3d ac 39 12 00 cmp $0x1239ac,%eax
106e4d: 74 1b je 106e6a <rtems_tarfs_load+0x62> <== ALWAYS TAKEN
&& root_loc.ops != &fifoIMFS_ops)
106e4f: 3d 34 43 12 00 cmp $0x124334,%eax <== NOT EXECUTED
106e54: 0f 85 c2 01 00 00 jne 10701c <rtems_tarfs_load+0x214><== NOT EXECUTED
106e5a: 8b b5 54 fe ff ff mov -0x1ac(%ebp),%esi <== NOT EXECUTED
106e60: eb 08 jmp 106e6a <rtems_tarfs_load+0x62> <== NOT EXECUTED
106e62: 8b b5 50 fe ff ff mov -0x1b0(%ebp),%esi
106e68: eb 18 jmp 106e82 <rtems_tarfs_load+0x7a>
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
106e6a: 8d 45 bc lea -0x44(%ebp),%eax
106e6d: 89 85 34 fe ff ff mov %eax,-0x1cc(%ebp)
106e73: 8d 55 d0 lea -0x30(%ebp),%edx
106e76: 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);
106e7c: 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)
106e82: 8d 86 00 02 00 00 lea 0x200(%esi),%eax
106e88: 89 85 50 fe ff ff mov %eax,-0x1b0(%ebp)
106e8e: 8b 55 10 mov 0x10(%ebp),%edx
106e91: 39 d0 cmp %edx,%eax
106e93: 0f 87 8d 01 00 00 ja 107026 <rtems_tarfs_load+0x21e><== NEVER TAKEN
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
106e99: 03 75 0c add 0xc(%ebp),%esi
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar ", 7))
106e9c: 8d 86 01 01 00 00 lea 0x101(%esi),%eax
106ea2: 52 push %edx
106ea3: 6a 07 push $0x7
106ea5: 68 f4 39 12 00 push $0x1239f4
106eaa: 50 push %eax
106eab: e8 4c dd 00 00 call 114bfc <strncmp>
106eb0: 83 c4 10 add $0x10,%esp
106eb3: 85 c0 test %eax,%eax
106eb5: 0f 85 6b 01 00 00 jne 107026 <rtems_tarfs_load+0x21e><== NEVER TAKEN
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
106ebb: 50 push %eax
106ebc: 6a 63 push $0x63
106ebe: 56 push %esi
106ebf: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax
106ec5: 50 push %eax
106ec6: e8 c1 dd 00 00 call 114c8c <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
106ecb: c6 45 bb 00 movb $0x0,-0x45(%ebp)
linkflag = hdr_ptr[156];
106ecf: 8a 96 9c 00 00 00 mov 0x9c(%esi),%dl
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
106ed5: 59 pop %ecx
106ed6: 5f pop %edi
106ed7: 6a 08 push $0x8
106ed9: 8d 46 64 lea 0x64(%esi),%eax
106edc: 50 push %eax
106edd: 88 95 44 fe ff ff mov %dl,-0x1bc(%ebp)
106ee3: e8 a8 6e 00 00 call 10dd90 <_rtems_octal2ulong>
106ee8: 89 85 48 fe ff ff mov %eax,-0x1b8(%ebp)
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
106eee: 5f pop %edi
106eef: 58 pop %eax
106ef0: 6a 0c push $0xc
106ef2: 8d 46 7c lea 0x7c(%esi),%eax
106ef5: 50 push %eax
106ef6: e8 95 6e 00 00 call 10dd90 <_rtems_octal2ulong>
106efb: 89 85 4c fe ff ff mov %eax,-0x1b4(%ebp)
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
106f01: 5a pop %edx
106f02: 59 pop %ecx
106f03: 6a 08 push $0x8
106f05: 8d 86 94 00 00 00 lea 0x94(%esi),%eax
106f0b: 50 push %eax
106f0c: e8 7f 6e 00 00 call 10dd90 <_rtems_octal2ulong>
106f11: 89 c7 mov %eax,%edi
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
106f13: 89 34 24 mov %esi,(%esp)
106f16: e8 a3 6e 00 00 call 10ddbe <_rtems_tar_header_checksum>
106f1b: 83 c4 10 add $0x10,%esp
106f1e: 39 f8 cmp %edi,%eax
106f20: 8a 95 44 fe ff ff mov -0x1bc(%ebp),%dl
106f26: 0f 85 fa 00 00 00 jne 107026 <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) {
106f2c: 80 fa 35 cmp $0x35,%dl
106f2f: 75 57 jne 106f88 <rtems_tarfs_load+0x180>
strcpy(full_filename, mountpoint);
106f31: 50 push %eax
106f32: 50 push %eax
106f33: ff 75 08 pushl 0x8(%ebp)
106f36: 53 push %ebx
106f37: e8 64 d9 00 00 call 1148a0 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
106f3c: 31 c0 xor %eax,%eax
106f3e: 83 c9 ff or $0xffffffff,%ecx
106f41: 89 df mov %ebx,%edi
106f43: f2 ae repnz scas %es:(%edi),%al
106f45: f7 d1 not %ecx
106f47: 83 c4 10 add $0x10,%esp
106f4a: 80 bc 0d 56 fe ff ff cmpb $0x2f,-0x1aa(%ebp,%ecx,1)
106f51: 2f
106f52: 74 10 je 106f64 <rtems_tarfs_load+0x15c><== ALWAYS TAKEN
strcat(full_filename, "/");
106f54: 57 push %edi <== NOT EXECUTED
106f55: 57 push %edi <== NOT EXECUTED
106f56: 68 b9 f9 11 00 push $0x11f9b9 <== NOT EXECUTED
106f5b: 53 push %ebx <== NOT EXECUTED
106f5c: e8 93 d8 00 00 call 1147f4 <strcat> <== NOT EXECUTED
106f61: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
strcat(full_filename, filename);
106f64: 56 push %esi
106f65: 56 push %esi
106f66: 8d 95 58 ff ff ff lea -0xa8(%ebp),%edx
106f6c: 52 push %edx
106f6d: 53 push %ebx
106f6e: e8 81 d8 00 00 call 1147f4 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
106f73: 5a pop %edx
106f74: 59 pop %ecx
106f75: 68 ff 01 00 00 push $0x1ff
106f7a: 53 push %ebx
106f7b: e8 c8 0f 00 00 call 107f48 <mkdir>
106f80: 83 c4 10 add $0x10,%esp
106f83: e9 da fe ff ff jmp 106e62 <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) {
106f88: 80 fa 30 cmp $0x30,%dl
106f8b: 0f 85 d1 fe ff ff jne 106e62 <rtems_tarfs_load+0x5a>
const char *name;
loc = root_loc;
106f91: b9 05 00 00 00 mov $0x5,%ecx
106f96: 8b bd 34 fe ff ff mov -0x1cc(%ebp),%edi
106f9c: 8b b5 30 fe ff ff mov -0x1d0(%ebp),%esi
106fa2: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
106fa4: 50 push %eax
106fa5: 8d 45 e4 lea -0x1c(%ebp),%eax
106fa8: 50 push %eax
106fa9: 8d 55 bc lea -0x44(%ebp),%edx
106fac: 52 push %edx
106fad: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax
106fb3: 50 push %eax
106fb4: e8 ef 78 00 00 call 10e8a8 <IMFS_evaluate_for_make>
106fb9: 83 c4 10 add $0x10,%esp
106fbc: 85 c0 test %eax,%eax
106fbe: 75 41 jne 107001 <rtems_tarfs_load+0x1f9><== NEVER TAKEN
node = IMFS_create_node(
106fc0: 83 ec 0c sub $0xc,%esp
106fc3: 6a 00 push $0x0
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
106fc5: 8b 85 48 fe ff ff mov -0x1b8(%ebp),%eax
106fcb: 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(
106fd0: 80 cc 80 or $0x80,%ah
106fd3: 50 push %eax
106fd4: ff 75 e4 pushl -0x1c(%ebp)
106fd7: 6a 06 push $0x6
106fd9: 8d 55 bc lea -0x44(%ebp),%edx
106fdc: 52 push %edx
106fdd: e8 c1 73 00 00 call 10e3a3 <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;
106fe2: 8b 95 4c fe ff ff mov -0x1b4(%ebp),%edx
106fe8: 89 50 50 mov %edx,0x50(%eax)
106feb: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.linearfile.direct = &tar_image[offset];
106ff2: 8b 55 0c mov 0xc(%ebp),%edx
106ff5: 03 95 50 fe ff ff add -0x1b0(%ebp),%edx
106ffb: 89 50 58 mov %edx,0x58(%eax)
106ffe: 83 c4 20 add $0x20,%esp
}
nblocks = (((file_size) + 511) & ~511) / 512;
107001: 8b 85 4c fe ff ff mov -0x1b4(%ebp),%eax
107007: 05 ff 01 00 00 add $0x1ff,%eax
offset += 512 * nblocks;
10700c: 25 00 fe ff ff and $0xfffffe00,%eax
107011: 01 85 50 fe ff ff add %eax,-0x1b0(%ebp)
107017: e9 46 fe ff ff jmp 106e62 <rtems_tarfs_load+0x5a>
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops
&& root_loc.ops != &fifoIMFS_ops)
return -1;
10701c: c7 85 54 fe ff ff ff movl $0xffffffff,-0x1ac(%ebp) <== NOT EXECUTED
107023: ff ff ff
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
107026: 8b 85 54 fe ff ff mov -0x1ac(%ebp),%eax
10702c: 8d 65 f4 lea -0xc(%ebp),%esp
10702f: 5b pop %ebx
107030: 5e pop %esi
107031: 5f pop %edi
107032: c9 leave
107033: c3 ret
00110d78 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
110d78: 55 push %ebp
110d79: 89 e5 mov %esp,%ebp
110d7b: 57 push %edi
110d7c: 56 push %esi
110d7d: 53 push %ebx
110d7e: 83 ec 1c sub $0x1c,%esp
110d81: 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;
110d84: 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 )
110d89: 85 c9 test %ecx,%ecx
110d8b: 0f 84 04 01 00 00 je 110e95 <rtems_task_mode+0x11d>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
110d91: 8b 35 34 47 12 00 mov 0x124734,%esi
api = executing->API_Extensions[ THREAD_API_RTEMS ];
110d97: 8b 9e f4 00 00 00 mov 0xf4(%esi),%ebx
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
110d9d: 80 7e 74 01 cmpb $0x1,0x74(%esi)
110da1: 19 ff sbb %edi,%edi
110da3: 81 e7 00 01 00 00 and $0x100,%edi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
110da9: 83 7e 7c 00 cmpl $0x0,0x7c(%esi)
110dad: 74 06 je 110db5 <rtems_task_mode+0x3d>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
110daf: 81 cf 00 02 00 00 or $0x200,%edi
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
110db5: 80 7b 08 01 cmpb $0x1,0x8(%ebx)
110db9: 19 d2 sbb %edx,%edx
110dbb: 81 e2 00 04 00 00 and $0x400,%edx
old_mode |= _ISR_Get_level();
110dc1: 89 55 e4 mov %edx,-0x1c(%ebp)
110dc4: 89 4d e0 mov %ecx,-0x20(%ebp)
110dc7: e8 39 c5 ff ff call 10d305 <_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;
110dcc: 8b 55 e4 mov -0x1c(%ebp),%edx
110dcf: 09 d0 or %edx,%eax
old_mode |= _ISR_Get_level();
110dd1: 09 f8 or %edi,%eax
110dd3: 8b 4d e0 mov -0x20(%ebp),%ecx
110dd6: 89 01 mov %eax,(%ecx)
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
110dd8: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
110ddf: 74 0b je 110dec <rtems_task_mode+0x74>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
110de1: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp)
110de8: 0f 94 46 74 sete 0x74(%esi)
if ( mask & RTEMS_TIMESLICE_MASK ) {
110dec: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
110df3: 74 21 je 110e16 <rtems_task_mode+0x9e>
if ( _Modes_Is_timeslice(mode_set) ) {
110df5: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
110dfc: 74 11 je 110e0f <rtems_task_mode+0x97>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
110dfe: c7 46 7c 01 00 00 00 movl $0x1,0x7c(%esi)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
110e05: a1 b4 41 12 00 mov 0x1241b4,%eax
110e0a: 89 46 78 mov %eax,0x78(%esi)
110e0d: eb 07 jmp 110e16 <rtems_task_mode+0x9e>
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
110e0f: c7 46 7c 00 00 00 00 movl $0x0,0x7c(%esi)
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
110e16: f6 45 0c 01 testb $0x1,0xc(%ebp)
110e1a: 74 0a je 110e26 <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 ) );
110e1c: f6 45 08 01 testb $0x1,0x8(%ebp)
110e20: 74 03 je 110e25 <rtems_task_mode+0xad>
110e22: fa cli
110e23: eb 01 jmp 110e26 <rtems_task_mode+0xae>
110e25: fb sti
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110e26: 31 d2 xor %edx,%edx
if ( mask & RTEMS_ASR_MASK ) {
110e28: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
110e2f: 74 2a je 110e5b <rtems_task_mode+0xe3>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
110e31: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp)
110e38: 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 ) {
110e3b: 3a 43 08 cmp 0x8(%ebx),%al
110e3e: 74 1b je 110e5b <rtems_task_mode+0xe3>
asr->is_enabled = is_asr_enabled;
110e40: 88 43 08 mov %al,0x8(%ebx)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
110e43: 9c pushf
110e44: fa cli
110e45: 58 pop %eax
_signals = information->signals_pending;
110e46: 8b 53 18 mov 0x18(%ebx),%edx
information->signals_pending = information->signals_posted;
110e49: 8b 4b 14 mov 0x14(%ebx),%ecx
110e4c: 89 4b 18 mov %ecx,0x18(%ebx)
information->signals_posted = _signals;
110e4f: 89 53 14 mov %edx,0x14(%ebx)
_ISR_Enable( _level );
110e52: 50 push %eax
110e53: 9d popf
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110e54: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
110e58: 0f 95 c2 setne %dl
if ( _System_state_Is_up( _System_state_Get() ) )
if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
_Thread_Dispatch();
return RTEMS_SUCCESSFUL;
110e5b: 31 c0 xor %eax,%eax
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) )
110e5d: 83 3d 64 43 12 00 03 cmpl $0x3,0x124364
110e64: 75 2f jne 110e95 <rtems_task_mode+0x11d> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE bool _Thread_Evaluate_mode( void )
{
Thread_Control *executing;
executing = _Thread_Executing;
110e66: a1 34 47 12 00 mov 0x124734,%eax
if ( !_States_Is_ready( executing->current_state ) ||
110e6b: 83 78 10 00 cmpl $0x0,0x10(%eax)
110e6f: 75 0e jne 110e7f <rtems_task_mode+0x107> <== NEVER TAKEN
110e71: 3b 05 38 47 12 00 cmp 0x124738,%eax
110e77: 74 0f je 110e88 <rtems_task_mode+0x110>
( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
110e79: 80 78 74 00 cmpb $0x0,0x74(%eax)
110e7d: 74 09 je 110e88 <rtems_task_mode+0x110> <== NEVER TAKEN
_Context_Switch_necessary = true;
110e7f: c6 05 40 47 12 00 01 movb $0x1,0x124740
110e86: eb 06 jmp 110e8e <rtems_task_mode+0x116>
if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
_Thread_Dispatch();
return RTEMS_SUCCESSFUL;
110e88: 31 c0 xor %eax,%eax
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) )
if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
110e8a: 84 d2 test %dl,%dl
110e8c: 74 07 je 110e95 <rtems_task_mode+0x11d>
_Thread_Dispatch();
110e8e: e8 69 af ff ff call 10bdfc <_Thread_Dispatch>
return RTEMS_SUCCESSFUL;
110e93: 31 c0 xor %eax,%eax
}
110e95: 83 c4 1c add $0x1c,%esp
110e98: 5b pop %ebx
110e99: 5e pop %esi
110e9a: 5f pop %edi
110e9b: c9 leave
110e9c: c3 ret
0010dda4 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10dda4: 55 push %ebp
10dda5: 89 e5 mov %esp,%ebp
10dda7: 56 push %esi
10dda8: 53 push %ebx
10dda9: 83 ec 10 sub $0x10,%esp
10ddac: 8b 5d 0c mov 0xc(%ebp),%ebx
10ddaf: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10ddb2: 85 db test %ebx,%ebx
10ddb4: 74 10 je 10ddc6 <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 ) );
10ddb6: 0f b6 15 f4 41 12 00 movzbl 0x1241f4,%edx
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
10ddbd: b8 13 00 00 00 mov $0x13,%eax
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10ddc2: 39 d3 cmp %edx,%ebx
10ddc4: 77 52 ja 10de18 <rtems_task_set_priority+0x74>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
10ddc6: 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 )
10ddcb: 85 f6 test %esi,%esi
10ddcd: 74 49 je 10de18 <rtems_task_set_priority+0x74>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10ddcf: 51 push %ecx
10ddd0: 51 push %ecx
10ddd1: 8d 45 f4 lea -0xc(%ebp),%eax
10ddd4: 50 push %eax
10ddd5: ff 75 08 pushl 0x8(%ebp)
10ddd8: e8 fb 1b 00 00 call 10f9d8 <_Thread_Get>
switch ( location ) {
10dddd: 83 c4 10 add $0x10,%esp
10dde0: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10dde4: 75 2d jne 10de13 <rtems_task_set_priority+0x6f>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10dde6: 8b 50 14 mov 0x14(%eax),%edx
10dde9: 89 16 mov %edx,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10ddeb: 85 db test %ebx,%ebx
10dded: 74 1b je 10de0a <rtems_task_set_priority+0x66>
the_thread->real_priority = new_priority;
10ddef: 89 58 18 mov %ebx,0x18(%eax)
if ( the_thread->resource_count == 0 ||
10ddf2: 83 78 1c 00 cmpl $0x0,0x1c(%eax)
10ddf6: 74 05 je 10ddfd <rtems_task_set_priority+0x59>
10ddf8: 39 58 14 cmp %ebx,0x14(%eax)
10ddfb: 76 0d jbe 10de0a <rtems_task_set_priority+0x66><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
10ddfd: 52 push %edx
10ddfe: 6a 00 push $0x0
10de00: 53 push %ebx
10de01: 50 push %eax
10de02: e8 1d 17 00 00 call 10f524 <_Thread_Change_priority>
10de07: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10de0a: e8 a7 1b 00 00 call 10f9b6 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10de0f: 31 c0 xor %eax,%eax
10de11: eb 05 jmp 10de18 <rtems_task_set_priority+0x74>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10de13: b8 04 00 00 00 mov $0x4,%eax
}
10de18: 8d 65 f8 lea -0x8(%ebp),%esp
10de1b: 5b pop %ebx
10de1c: 5e pop %esi
10de1d: c9 leave
10de1e: c3 ret
001086f8 <rtems_termios_bufsize>:
rtems_status_code rtems_termios_bufsize (
int cbufsize,
int raw_input,
int raw_output
)
{
1086f8: 55 push %ebp <== NOT EXECUTED
1086f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
rtems_termios_cbufsize = cbufsize;
1086fb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1086fe: a3 44 1f 12 00 mov %eax,0x121f44 <== NOT EXECUTED
rtems_termios_raw_input_size = raw_input;
108703: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
108706: a3 48 1f 12 00 mov %eax,0x121f48 <== NOT EXECUTED
rtems_termios_raw_output_size = raw_output;
10870b: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10870e: a3 4c 1f 12 00 mov %eax,0x121f4c <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
108713: 31 c0 xor %eax,%eax <== NOT EXECUTED
108715: c9 leave <== NOT EXECUTED
108716: c3 ret <== NOT EXECUTED
0010857b <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
10857b: 55 push %ebp
10857c: 89 e5 mov %esp,%ebp
10857e: 56 push %esi
10857f: 53 push %ebx
108580: 8b 75 08 mov 0x8(%ebp),%esi
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
108583: 8b 06 mov (%esi),%eax
108585: 8b 58 34 mov 0x34(%eax),%ebx
rtems_status_code sc;
sc = rtems_semaphore_obtain(
108588: 51 push %ecx
108589: 6a 00 push $0x0
10858b: 6a 00 push $0x0
10858d: ff 35 dc 40 12 00 pushl 0x1240dc
108593: e8 30 1c 00 00 call 10a1c8 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
108598: 83 c4 10 add $0x10,%esp
10859b: 85 c0 test %eax,%eax
10859d: 75 7d jne 10861c <rtems_termios_close+0xa1><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
10859f: 8b 43 08 mov 0x8(%ebx),%eax
1085a2: 48 dec %eax
1085a3: 89 43 08 mov %eax,0x8(%ebx)
1085a6: 85 c0 test %eax,%eax
1085a8: 0f 85 33 01 00 00 jne 1086e1 <rtems_termios_close+0x166>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
1085ae: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
1085b4: c1 e0 05 shl $0x5,%eax
1085b7: 8b 80 98 3d 12 00 mov 0x123d98(%eax),%eax
1085bd: 85 c0 test %eax,%eax
1085bf: 74 0b je 1085cc <rtems_termios_close+0x51>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
1085c1: 83 ec 0c sub $0xc,%esp
1085c4: 53 push %ebx
1085c5: ff d0 call *%eax
1085c7: 83 c4 10 add $0x10,%esp
1085ca: eb 1b jmp 1085e7 <rtems_termios_close+0x6c>
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
1085cc: 52 push %edx
1085cd: 6a 00 push $0x0
1085cf: 6a 00 push $0x0
1085d1: ff 73 18 pushl 0x18(%ebx)
1085d4: e8 ef 1b 00 00 call 10a1c8 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
1085d9: 83 c4 10 add $0x10,%esp
1085dc: 85 c0 test %eax,%eax
1085de: 75 3c jne 10861c <rtems_termios_close+0xa1><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
1085e0: 89 d8 mov %ebx,%eax
1085e2: e8 11 fb ff ff call 1080f8 <drainOutput>
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
1085e7: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
1085ee: 75 35 jne 108625 <rtems_termios_close+0xaa>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
1085f0: 50 push %eax
1085f1: 50 push %eax
1085f2: 6a 01 push $0x1
1085f4: ff b3 c4 00 00 00 pushl 0xc4(%ebx)
1085fa: e8 61 17 00 00 call 109d60 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
1085ff: 83 c4 10 add $0x10,%esp
108602: 85 c0 test %eax,%eax
108604: 75 16 jne 10861c <rtems_termios_close+0xa1><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
108606: 51 push %ecx
108607: 51 push %ecx
108608: 6a 01 push $0x1
10860a: ff b3 c8 00 00 00 pushl 0xc8(%ebx)
108610: e8 4b 17 00 00 call 109d60 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
108615: 83 c4 10 add $0x10,%esp
108618: 85 c0 test %eax,%eax
10861a: 74 09 je 108625 <rtems_termios_close+0xaa><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
10861c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10861f: 50 push %eax <== NOT EXECUTED
108620: e8 6b 21 00 00 call 10a790 <rtems_fatal_error_occurred><== NOT EXECUTED
}
if (tty->device.lastClose)
108625: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax
10862b: 85 c0 test %eax,%eax
10862d: 74 0d je 10863c <rtems_termios_close+0xc1>
(*tty->device.lastClose)(tty->major, tty->minor, arg);
10862f: 52 push %edx
108630: 56 push %esi
108631: ff 73 10 pushl 0x10(%ebx)
108634: ff 73 0c pushl 0xc(%ebx)
108637: ff d0 call *%eax
108639: 83 c4 10 add $0x10,%esp
if (tty->forw == NULL) {
10863c: 8b 13 mov (%ebx),%edx
10863e: 85 d2 test %edx,%edx
108640: 8b 43 04 mov 0x4(%ebx),%eax
108643: 75 11 jne 108656 <rtems_termios_close+0xdb>
rtems_termios_ttyTail = tty->back;
108645: a3 e0 40 12 00 mov %eax,0x1240e0
if ( rtems_termios_ttyTail != NULL ) {
10864a: 85 c0 test %eax,%eax
10864c: 74 0b je 108659 <rtems_termios_close+0xde><== ALWAYS TAKEN
rtems_termios_ttyTail->forw = NULL;
10864e: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
108654: eb 03 jmp 108659 <rtems_termios_close+0xde><== NOT EXECUTED
}
} else {
tty->forw->back = tty->back;
108656: 89 42 04 mov %eax,0x4(%edx)
}
if (tty->back == NULL) {
108659: 8b 53 04 mov 0x4(%ebx),%edx
10865c: 85 d2 test %edx,%edx
10865e: 8b 03 mov (%ebx),%eax
108660: 75 12 jne 108674 <rtems_termios_close+0xf9><== NEVER TAKEN
rtems_termios_ttyHead = tty->forw;
108662: a3 e4 40 12 00 mov %eax,0x1240e4
if ( rtems_termios_ttyHead != NULL ) {
108667: 85 c0 test %eax,%eax
108669: 74 0b je 108676 <rtems_termios_close+0xfb>
rtems_termios_ttyHead->back = NULL;
10866b: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
108672: eb 02 jmp 108676 <rtems_termios_close+0xfb>
}
} else {
tty->back->forw = tty->forw;
108674: 89 02 mov %eax,(%edx) <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
108676: 83 ec 0c sub $0xc,%esp
108679: ff 73 14 pushl 0x14(%ebx)
10867c: e8 b7 1a 00 00 call 10a138 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
108681: 59 pop %ecx
108682: ff 73 18 pushl 0x18(%ebx)
108685: e8 ae 1a 00 00 call 10a138 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
10868a: 5a pop %edx
10868b: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
108691: e8 a2 1a 00 00 call 10a138 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
108696: 83 c4 10 add $0x10,%esp
108699: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
1086a0: 74 09 je 1086ab <rtems_termios_close+0x130>
1086a2: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
1086a9: 75 0e jne 1086b9 <rtems_termios_close+0x13e>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
1086ab: 83 ec 0c sub $0xc,%esp
1086ae: ff 73 68 pushl 0x68(%ebx)
1086b1: e8 82 1a 00 00 call 10a138 <rtems_semaphore_delete>
1086b6: 83 c4 10 add $0x10,%esp
free (tty->rawInBuf.theBuf);
1086b9: 83 ec 0c sub $0xc,%esp
1086bc: ff 73 58 pushl 0x58(%ebx)
1086bf: e8 20 ec ff ff call 1072e4 <free>
free (tty->rawOutBuf.theBuf);
1086c4: 58 pop %eax
1086c5: ff 73 7c pushl 0x7c(%ebx)
1086c8: e8 17 ec ff ff call 1072e4 <free>
free (tty->cbuf);
1086cd: 5e pop %esi
1086ce: ff 73 1c pushl 0x1c(%ebx)
1086d1: e8 0e ec ff ff call 1072e4 <free>
free (tty);
1086d6: 89 1c 24 mov %ebx,(%esp)
1086d9: e8 06 ec ff ff call 1072e4 <free>
1086de: 83 c4 10 add $0x10,%esp
}
rtems_semaphore_release (rtems_termios_ttyMutex);
1086e1: 83 ec 0c sub $0xc,%esp
1086e4: ff 35 dc 40 12 00 pushl 0x1240dc
1086ea: e8 c5 1b 00 00 call 10a2b4 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
1086ef: 31 c0 xor %eax,%eax
1086f1: 8d 65 f8 lea -0x8(%ebp),%esp
1086f4: 5b pop %ebx
1086f5: 5e pop %esi
1086f6: c9 leave
1086f7: c3 ret
001098a5 <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)
{
1098a5: 55 push %ebp
1098a6: 89 e5 mov %esp,%ebp
1098a8: 83 ec 08 sub $0x8,%esp
1098ab: 8b 45 08 mov 0x8(%ebp),%eax
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
1098ae: 8b 55 0c mov 0xc(%ebp),%edx
1098b1: 01 90 90 00 00 00 add %edx,0x90(%eax)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
1098b7: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax)
1098be: 75 1f jne 1098df <rtems_termios_dequeue_characters+0x3a>
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
1098c0: 52 push %edx
1098c1: 52 push %edx
1098c2: 6a 02 push $0x2
1098c4: ff b0 c8 00 00 00 pushl 0xc8(%eax)
1098ca: e8 91 04 00 00 call 109d60 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
1098cf: 83 c4 10 add $0x10,%esp
1098d2: 85 c0 test %eax,%eax
1098d4: 74 30 je 109906 <rtems_termios_dequeue_characters+0x61><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
1098d6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1098d9: 50 push %eax <== NOT EXECUTED
1098da: e8 b1 0e 00 00 call 10a790 <rtems_fatal_error_occurred><== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
1098df: 83 b8 cc 00 00 00 05 cmpl $0x5,0xcc(%eax)
1098e6: 75 15 jne 1098fd <rtems_termios_dequeue_characters+0x58>
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
1098e8: 8b 15 48 3e 12 00 mov 0x123e48,%edx
1098ee: 85 d2 test %edx,%edx
1098f0: 74 14 je 109906 <rtems_termios_dequeue_characters+0x61><== NEVER TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
1098f2: 83 ec 0c sub $0xc,%esp
1098f5: 50 push %eax
1098f6: ff d2 call *%edx
1098f8: 83 c4 10 add $0x10,%esp
1098fb: eb 09 jmp 109906 <rtems_termios_dequeue_characters+0x61>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
1098fd: 89 45 08 mov %eax,0x8(%ebp)
}
109900: c9 leave
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
109901: e9 6d fd ff ff jmp 109673 <rtems_termios_refill_transmitter>
}
109906: 31 c0 xor %eax,%eax
109908: c9 leave
109909: c3 ret
00109384 <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)
{
109384: 55 push %ebp
109385: 89 e5 mov %esp,%ebp
109387: 57 push %edi
109388: 56 push %esi
109389: 53 push %ebx
10938a: 83 ec 2c sub $0x2c,%esp
10938d: 8b 5d 08 mov 0x8(%ebp),%ebx
109390: 8b 7d 0c mov 0xc(%ebp),%edi
109393: 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) {
109396: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
10939c: c1 e0 05 shl $0x5,%eax
10939f: 89 ca mov %ecx,%edx
1093a1: 83 b8 a4 3d 12 00 00 cmpl $0x0,0x123da4(%eax)
1093a8: 75 3b jne 1093e5 <rtems_termios_enqueue_raw_characters+0x61>
1093aa: 89 4d e0 mov %ecx,-0x20(%ebp)
1093ad: c6 45 df 00 movb $0x0,-0x21(%ebp)
1093b1: 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);
1093b3: 8d 43 30 lea 0x30(%ebx),%eax
1093b6: 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,
1093b9: 8d 53 4a lea 0x4a(%ebx),%edx
1093bc: 89 55 d0 mov %edx,-0x30(%ebp)
1093bf: e9 26 02 00 00 jmp 1095ea <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++;
1093c4: 0f be 0f movsbl (%edi),%ecx
1093c7: 47 inc %edi
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
1093c8: 56 push %esi
1093c9: 56 push %esi
1093ca: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
1093d0: c1 e0 05 shl $0x5,%eax
1093d3: 53 push %ebx
1093d4: 51 push %ecx
1093d5: 89 55 cc mov %edx,-0x34(%ebp)
1093d8: ff 90 a4 3d 12 00 call *0x123da4(%eax)
1093de: 8b 55 cc mov -0x34(%ebp),%edx
1093e1: 4a dec %edx
1093e2: 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--) {
1093e5: 85 d2 test %edx,%edx
1093e7: 75 db jne 1093c4 <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;
1093e9: 31 f6 xor %esi,%esi
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
1093eb: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx)
1093f2: 0f 85 0d 02 00 00 jne 109605 <rtems_termios_enqueue_raw_characters+0x281><== NEVER TAKEN
1093f8: 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;
1093fe: 89 d6 mov %edx,%esi
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
109400: 85 c0 test %eax,%eax
109402: 0f 84 fd 01 00 00 je 109605 <rtems_termios_enqueue_raw_characters+0x281>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
109408: 51 push %ecx <== NOT EXECUTED
109409: 51 push %ecx <== NOT EXECUTED
10940a: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED
109410: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED
109413: 52 push %edx <== NOT EXECUTED
109414: ff d0 call *%eax <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
109416: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED
10941d: 00 00 00
109420: e9 dd 01 00 00 jmp 109602 <rtems_termios_enqueue_raw_characters+0x27e><== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
109425: 8a 0f mov (%edi),%cl
109427: 88 4d de mov %cl,-0x22(%ebp)
10942a: 47 inc %edi
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
10942b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109431: f6 c4 02 test $0x2,%ah
109434: 74 46 je 10947c <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]) {
109436: 0f be c1 movsbl %cl,%eax
109439: 0f b6 53 4a movzbl 0x4a(%ebx),%edx
10943d: 39 d0 cmp %edx,%eax
10943f: 75 28 jne 109469 <rtems_termios_enqueue_raw_characters+0xe5><== ALWAYS TAKEN
if (c == tty->termios.c_cc[VSTART]) {
109441: 0f b6 53 49 movzbl 0x49(%ebx),%edx <== NOT EXECUTED
109445: 39 d0 cmp %edx,%eax <== NOT EXECUTED
109447: 75 0b jne 109454 <rtems_termios_enqueue_raw_characters+0xd0><== NOT EXECUTED
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
109449: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10944f: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED
109452: eb 09 jmp 10945d <rtems_termios_enqueue_raw_characters+0xd9><== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
109454: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10945a: 83 c8 10 or $0x10,%eax <== NOT EXECUTED
10945d: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
* 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)
{
109463: c6 45 df 01 movb $0x1,-0x21(%ebp) <== NOT EXECUTED
109467: eb 19 jmp 109482 <rtems_termios_enqueue_raw_characters+0xfe><== NOT EXECUTED
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
109469: 0f b6 53 49 movzbl 0x49(%ebx),%edx
10946d: 39 d0 cmp %edx,%eax
10946f: 75 0b jne 10947c <rtems_termios_enqueue_raw_characters+0xf8><== ALWAYS TAKEN
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
109471: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109477: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED
10947a: eb e1 jmp 10945d <rtems_termios_enqueue_raw_characters+0xd9><== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
10947c: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
109480: 74 51 je 1094d3 <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) {
109482: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109488: 83 e0 30 and $0x30,%eax <== NOT EXECUTED
10948b: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED
10948e: 0f 85 53 01 00 00 jne 1095e7 <rtems_termios_enqueue_raw_characters+0x263><== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
109494: 9c pushf <== NOT EXECUTED
109495: fa cli <== NOT EXECUTED
109496: 8f 45 e4 popl -0x1c(%ebp) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
109499: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10949f: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
1094a2: 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) {
1094a8: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
1094af: 74 19 je 1094ca <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);
1094b1: 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)(
1094b7: 52 push %edx <== NOT EXECUTED
1094b8: 6a 01 push $0x1 <== NOT EXECUTED
1094ba: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
1094bd: 50 push %eax <== NOT EXECUTED
1094be: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1094c1: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
1094c7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
1094ca: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED
1094cd: 9d popf <== NOT EXECUTED
1094ce: e9 14 01 00 00 jmp 1095e7 <rtems_termios_enqueue_raw_characters+0x263><== NOT EXECUTED
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
1094d3: 8b 43 60 mov 0x60(%ebx),%eax
1094d6: 8b 4b 64 mov 0x64(%ebx),%ecx
1094d9: 40 inc %eax
1094da: 31 d2 xor %edx,%edx
1094dc: f7 f1 div %ecx
1094de: 89 55 e4 mov %edx,-0x1c(%ebp)
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
1094e1: 9c pushf
1094e2: fa cli
1094e3: 8f 45 d8 popl -0x28(%ebp)
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
1094e6: 8b 53 5c mov 0x5c(%ebx),%edx
1094e9: 8b 43 64 mov 0x64(%ebx),%eax
% tty->rawInBuf.Size) > tty->highwater) &&
1094ec: 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)
1094ef: 29 d0 sub %edx,%eax
1094f1: 03 45 e4 add -0x1c(%ebp),%eax
% tty->rawInBuf.Size) > tty->highwater) &&
1094f4: 31 d2 xor %edx,%edx
1094f6: 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)
1094f8: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx
1094fe: 0f 86 98 00 00 00 jbe 10959c <rtems_termios_enqueue_raw_characters+0x218><== ALWAYS TAKEN
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
109504: 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) &&
10950a: a8 01 test $0x1,%al <== NOT EXECUTED
10950c: 0f 85 8a 00 00 00 jne 10959c <rtems_termios_enqueue_raw_characters+0x218><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
109512: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109518: 83 c8 01 or $0x1,%eax <== NOT EXECUTED
10951b: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
109521: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109527: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED
10952c: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED
109531: 75 33 jne 109566 <rtems_termios_enqueue_raw_characters+0x1e2><== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
109533: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109539: a8 20 test $0x20,%al <== NOT EXECUTED
10953b: 75 09 jne 109546 <rtems_termios_enqueue_raw_characters+0x1c2><== NOT EXECUTED
10953d: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
109544: 75 56 jne 10959c <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;
109546: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10954c: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
10954f: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
109555: 51 push %ecx <== NOT EXECUTED
109556: 6a 01 push $0x1 <== NOT EXECUTED
109558: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED
10955b: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10955e: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
109564: eb 33 jmp 109599 <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) ) {
109566: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10956c: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED
109571: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED
109576: 75 24 jne 10959c <rtems_termios_enqueue_raw_characters+0x218><== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
109578: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10957e: 83 c8 04 or $0x4,%eax <== NOT EXECUTED
109581: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
109587: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED
10958d: 85 c0 test %eax,%eax <== NOT EXECUTED
10958f: 74 0b je 10959c <rtems_termios_enqueue_raw_characters+0x218><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
109591: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109594: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109597: ff d0 call *%eax <== NOT EXECUTED
109599: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
10959c: ff 75 d8 pushl -0x28(%ebp)
10959f: 9d popf
if (newTail == tty->rawInBuf.Head) {
1095a0: 8b 43 5c mov 0x5c(%ebx),%eax
1095a3: 39 45 e4 cmp %eax,-0x1c(%ebp)
1095a6: 75 03 jne 1095ab <rtems_termios_enqueue_raw_characters+0x227><== ALWAYS TAKEN
dropped++;
1095a8: 46 inc %esi <== NOT EXECUTED
1095a9: eb 3c jmp 1095e7 <rtems_termios_enqueue_raw_characters+0x263><== NOT EXECUTED
} else {
tty->rawInBuf.theBuf[newTail] = c;
1095ab: 8b 43 58 mov 0x58(%ebx),%eax
1095ae: 8a 4d de mov -0x22(%ebp),%cl
1095b1: 8b 55 e4 mov -0x1c(%ebp),%edx
1095b4: 88 0c 10 mov %cl,(%eax,%edx,1)
tty->rawInBuf.Tail = newTail;
1095b7: 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 )) {
1095ba: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx)
1095c1: 75 24 jne 1095e7 <rtems_termios_enqueue_raw_characters+0x263><== NEVER TAKEN
1095c3: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax
1095c9: 85 c0 test %eax,%eax
1095cb: 74 1a je 1095e7 <rtems_termios_enqueue_raw_characters+0x263><== ALWAYS TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
1095cd: 52 push %edx <== NOT EXECUTED
1095ce: 52 push %edx <== NOT EXECUTED
1095cf: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED
1095d5: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED
1095d8: ff d0 call *%eax <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
1095da: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED
1095e1: 00 00 00
1095e4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1095e7: ff 4d e0 decl -0x20(%ebp)
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
1095ea: 83 7d e0 00 cmpl $0x0,-0x20(%ebp)
1095ee: 0f 85 31 fe ff ff jne 109425 <rtems_termios_enqueue_raw_characters+0xa1>
}
}
}
}
tty->rawInBufDropped += dropped;
1095f4: 01 73 78 add %esi,0x78(%ebx)
rtems_semaphore_release (tty->rawInBuf.Semaphore);
1095f7: 83 ec 0c sub $0xc,%esp
1095fa: ff 73 68 pushl 0x68(%ebx)
1095fd: e8 b2 0c 00 00 call 10a2b4 <rtems_semaphore_release>
return dropped;
109602: 83 c4 10 add $0x10,%esp
}
109605: 89 f0 mov %esi,%eax
109607: 8d 65 f4 lea -0xc(%ebp),%esp
10960a: 5b pop %ebx
10960b: 5e pop %esi
10960c: 5f pop %edi
10960d: c9 leave
10960e: c3 ret
00108717 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
108717: 55 push %ebp
108718: 89 e5 mov %esp,%ebp
10871a: 57 push %edi
10871b: 56 push %esi
10871c: 53 push %ebx
10871d: 83 ec 20 sub $0x20,%esp
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
108720: 8b 55 08 mov 0x8(%ebp),%edx
108723: 8b 02 mov (%edx),%eax
108725: 8b 58 34 mov 0x34(%eax),%ebx
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
108728: 8b 72 08 mov 0x8(%edx),%esi
rtems_status_code sc;
args->ioctl_return = 0;
10872b: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108732: 6a 00 push $0x0
108734: 6a 00 push $0x0
108736: ff 73 18 pushl 0x18(%ebx)
108739: e8 8a 1a 00 00 call 10a1c8 <rtems_semaphore_obtain>
10873e: 89 45 e4 mov %eax,-0x1c(%ebp)
if (sc != RTEMS_SUCCESSFUL) {
108741: 83 c4 10 add $0x10,%esp
108744: 85 c0 test %eax,%eax
108746: 74 0b je 108753 <rtems_termios_ioctl+0x3c><== ALWAYS TAKEN
args->ioctl_return = sc;
108748: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
10874b: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED
return sc;
10874e: e9 05 03 00 00 jmp 108a58 <rtems_termios_ioctl+0x341><== NOT EXECUTED
}
switch (args->command) {
108753: 8b 55 08 mov 0x8(%ebp),%edx
108756: 8b 42 04 mov 0x4(%edx),%eax
108759: 83 f8 04 cmp $0x4,%eax
10875c: 0f 84 4d 02 00 00 je 1089af <rtems_termios_ioctl+0x298><== NEVER TAKEN
108762: 77 10 ja 108774 <rtems_termios_ioctl+0x5d>
108764: 83 f8 02 cmp $0x2,%eax
108767: 74 77 je 1087e0 <rtems_termios_ioctl+0xc9>
108769: 0f 87 1e 02 00 00 ja 10898d <rtems_termios_ioctl+0x276>
10876f: 48 dec %eax
108770: 75 2f jne 1087a1 <rtems_termios_ioctl+0x8a><== NEVER TAKEN
108772: eb 55 jmp 1087c9 <rtems_termios_ioctl+0xb2>
108774: 3d 7f 66 04 40 cmp $0x4004667f,%eax
108779: 0f 84 a5 02 00 00 je 108a24 <rtems_termios_ioctl+0x30d><== NEVER TAKEN
10877f: 77 0a ja 10878b <rtems_termios_ioctl+0x74>
108781: 83 f8 05 cmp $0x5,%eax
108784: 75 1b jne 1087a1 <rtems_termios_ioctl+0x8a><== ALWAYS TAKEN
108786: e9 0e 02 00 00 jmp 108999 <rtems_termios_ioctl+0x282><== NOT EXECUTED
10878b: 3d 1a 74 04 40 cmp $0x4004741a,%eax
108790: 0f 84 7e 02 00 00 je 108a14 <rtems_termios_ioctl+0x2fd>
108796: 3d 1b 74 04 80 cmp $0x8004741b,%eax
10879b: 0f 84 21 02 00 00 je 1089c2 <rtems_termios_ioctl+0x2ab><== ALWAYS TAKEN
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
1087a1: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
1087a7: c1 e0 05 shl $0x5,%eax
1087aa: 8b 80 ac 3d 12 00 mov 0x123dac(%eax),%eax
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
1087b0: 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) {
1087b7: 85 c0 test %eax,%eax
1087b9: 0f 84 82 02 00 00 je 108a41 <rtems_termios_ioctl+0x32a><== NEVER TAKEN
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
1087bf: 52 push %edx
1087c0: 52 push %edx
1087c1: ff 75 08 pushl 0x8(%ebp)
1087c4: e9 40 02 00 00 jmp 108a09 <rtems_termios_ioctl+0x2f2>
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
1087c9: 8b 4d 08 mov 0x8(%ebp),%ecx
1087cc: 8b 41 08 mov 0x8(%ecx),%eax
1087cf: 8d 73 30 lea 0x30(%ebx),%esi
1087d2: b9 09 00 00 00 mov $0x9,%ecx
1087d7: 89 c7 mov %eax,%edi
1087d9: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
break;
1087db: e9 61 02 00 00 jmp 108a41 <rtems_termios_ioctl+0x32a>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
1087e0: 8b 45 08 mov 0x8(%ebp),%eax
1087e3: 8b 70 08 mov 0x8(%eax),%esi
1087e6: 8d 7b 30 lea 0x30(%ebx),%edi
1087e9: b9 09 00 00 00 mov $0x9,%ecx
1087ee: 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) &&
1087f0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1087f6: f6 c4 02 test $0x2,%ah
1087f9: 74 57 je 108852 <rtems_termios_ioctl+0x13b>
1087fb: f6 43 31 04 testb $0x4,0x31(%ebx)
1087ff: 75 51 jne 108852 <rtems_termios_ioctl+0x13b><== ALWAYS TAKEN
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
108801: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108807: 25 ef fd ff ff and $0xfffffdef,%eax <== NOT EXECUTED
10880c: 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) {
108812: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108818: a8 20 test $0x20,%al <== NOT EXECUTED
10881a: 74 36 je 108852 <rtems_termios_ioctl+0x13b><== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
10881c: 9c pushf <== NOT EXECUTED
10881d: fa cli <== NOT EXECUTED
10881e: 5e pop %esi <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
10881f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108825: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
108828: 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) {
10882e: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
108835: 74 19 je 108850 <rtems_termios_ioctl+0x139><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
108837: 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)(
10883d: 57 push %edi <== NOT EXECUTED
10883e: 6a 01 push $0x1 <== NOT EXECUTED
108840: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
108843: 50 push %eax <== NOT EXECUTED
108844: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
108847: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
10884d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
108850: 56 push %esi <== NOT EXECUTED
108851: 9d popf <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
108852: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108858: f6 c4 04 test $0x4,%ah
10885b: 74 24 je 108881 <rtems_termios_ioctl+0x16a><== ALWAYS TAKEN
10885d: f6 43 31 10 testb $0x10,0x31(%ebx) <== NOT EXECUTED
108861: 75 1e jne 108881 <rtems_termios_ioctl+0x16a><== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
108863: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108869: 80 e4 fb and $0xfb,%ah <== NOT EXECUTED
10886c: 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);
108872: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108878: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
10887b: 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)) {
108881: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108887: f6 c4 01 test $0x1,%ah
10888a: 74 43 je 1088cf <rtems_termios_ioctl+0x1b8><== ALWAYS TAKEN
10888c: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED
108890: 78 3d js 1088cf <rtems_termios_ioctl+0x1b8><== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
108892: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108898: 80 e4 fe and $0xfe,%ah <== NOT EXECUTED
10889b: 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)) {
1088a1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1088a7: a8 04 test $0x4,%al <== NOT EXECUTED
1088a9: 74 15 je 1088c0 <rtems_termios_ioctl+0x1a9><== NOT EXECUTED
1088ab: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED
1088b1: 85 c0 test %eax,%eax <== NOT EXECUTED
1088b3: 74 0b je 1088c0 <rtems_termios_ioctl+0x1a9><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
1088b5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1088b8: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1088bb: ff d0 call *%eax <== NOT EXECUTED
1088bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
1088c0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1088c6: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
1088c9: 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) {
1088cf: 83 7b 38 00 cmpl $0x0,0x38(%ebx)
1088d3: 79 0f jns 1088e4 <rtems_termios_ioctl+0x1cd><== ALWAYS TAKEN
tty->flow_ctrl |= FL_MDRTS;
1088d5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1088db: 80 cc 01 or $0x1,%ah <== NOT EXECUTED
1088de: 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) {
1088e4: 8b 53 30 mov 0x30(%ebx),%edx
1088e7: f6 c6 10 test $0x10,%dh
1088ea: 74 0f je 1088fb <rtems_termios_ioctl+0x1e4>
tty->flow_ctrl |= FL_MDXOF;
1088ec: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1088f2: 80 cc 04 or $0x4,%ah
1088f5: 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) {
1088fb: 80 e6 04 and $0x4,%dh
1088fe: 74 0f je 10890f <rtems_termios_ioctl+0x1f8><== NEVER TAKEN
tty->flow_ctrl |= FL_MDXON;
108900: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108906: 80 cc 02 or $0x2,%ah
108909: 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) {
10890f: f6 43 3c 02 testb $0x2,0x3c(%ebx)
108913: 75 39 jne 10894e <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] *
108915: 0f b6 73 46 movzbl 0x46(%ebx),%esi
rtems_clock_get_ticks_per_second() / 10;
108919: e8 6a 12 00 00 call 109b88 <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] *
10891e: 0f af c6 imul %esi,%eax
rtems_clock_get_ticks_per_second() / 10;
108921: b9 0a 00 00 00 mov $0xa,%ecx
108926: 31 d2 xor %edx,%edx
108928: 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] *
10892a: 89 43 54 mov %eax,0x54(%ebx)
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
10892d: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
108931: 74 15 je 108948 <rtems_termios_ioctl+0x231><== ALWAYS TAKEN
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
108933: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
10893a: 89 43 70 mov %eax,0x70(%ebx) <== NOT EXECUTED
if (tty->termios.c_cc[VMIN])
10893d: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED
108941: 75 19 jne 10895c <rtems_termios_ioctl+0x245><== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
108943: 89 43 74 mov %eax,0x74(%ebx) <== NOT EXECUTED
108946: eb 24 jmp 10896c <rtems_termios_ioctl+0x255><== NOT EXECUTED
} else {
if (tty->termios.c_cc[VMIN]) {
108948: 80 7b 47 00 cmpb $0x0,0x47(%ebx)
10894c: 74 17 je 108965 <rtems_termios_ioctl+0x24e><== ALWAYS TAKEN
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
10894e: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
108955: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx)
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
10895c: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx)
108963: eb 07 jmp 10896c <rtems_termios_ioctl+0x255>
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
108965: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx)
}
}
}
if (tty->device.setAttributes)
10896c: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax
108972: 85 c0 test %eax,%eax
108974: 0f 84 c7 00 00 00 je 108a41 <rtems_termios_ioctl+0x32a><== NEVER TAKEN
(*tty->device.setAttributes)(tty->minor, &tty->termios);
10897a: 56 push %esi
10897b: 56 push %esi
10897c: 8d 53 30 lea 0x30(%ebx),%edx
10897f: 52 push %edx
108980: ff 73 10 pushl 0x10(%ebx)
108983: ff d0 call *%eax
108985: 83 c4 10 add $0x10,%esp
108988: e9 b4 00 00 00 jmp 108a41 <rtems_termios_ioctl+0x32a>
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
10898d: 89 d8 mov %ebx,%eax
10898f: e8 64 f7 ff ff call 1080f8 <drainOutput>
break;
108994: e9 a8 00 00 00 jmp 108a41 <rtems_termios_ioctl+0x32a>
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
108999: 8b 06 mov (%esi),%eax <== NOT EXECUTED
10899b: 8b 56 04 mov 0x4(%esi),%edx <== NOT EXECUTED
10899e: 89 83 d4 00 00 00 mov %eax,0xd4(%ebx) <== NOT EXECUTED
1089a4: 89 93 d8 00 00 00 mov %edx,0xd8(%ebx) <== NOT EXECUTED
break;
1089aa: e9 92 00 00 00 jmp 108a41 <rtems_termios_ioctl+0x32a><== NOT EXECUTED
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
1089af: 8b 06 mov (%esi),%eax <== NOT EXECUTED
1089b1: 8b 56 04 mov 0x4(%esi),%edx <== NOT EXECUTED
1089b4: 89 83 dc 00 00 00 mov %eax,0xdc(%ebx) <== NOT EXECUTED
1089ba: 89 93 e0 00 00 00 mov %edx,0xe0(%ebx) <== NOT EXECUTED
break;
1089c0: eb 7f jmp 108a41 <rtems_termios_ioctl+0x32a><== NOT EXECUTED
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
1089c2: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
1089c8: c1 e0 05 shl $0x5,%eax
1089cb: 8b 80 98 3d 12 00 mov 0x123d98(%eax),%eax
1089d1: 85 c0 test %eax,%eax
1089d3: 74 0c je 1089e1 <rtems_termios_ioctl+0x2ca>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
1089d5: 83 ec 0c sub $0xc,%esp
1089d8: 53 push %ebx
1089d9: ff d0 call *%eax
1089db: 89 45 e4 mov %eax,-0x1c(%ebp)
1089de: 83 c4 10 add $0x10,%esp
}
tty->t_line=*(int*)(args->buffer);
1089e1: 8b 55 08 mov 0x8(%ebp),%edx
1089e4: 8b 42 08 mov 0x8(%edx),%eax
1089e7: 8b 00 mov (%eax),%eax
1089e9: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx)
tty->t_sc = NULL; /* ensure that no more valid data */
1089ef: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx)
1089f6: 00 00 00
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
1089f9: c1 e0 05 shl $0x5,%eax
1089fc: 8b 80 94 3d 12 00 mov 0x123d94(%eax),%eax
108a02: 85 c0 test %eax,%eax
108a04: 74 3b je 108a41 <rtems_termios_ioctl+0x32a><== NEVER TAKEN
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
108a06: 83 ec 0c sub $0xc,%esp
108a09: 53 push %ebx
108a0a: ff d0 call *%eax
108a0c: 89 45 e4 mov %eax,-0x1c(%ebp)
108a0f: e9 71 ff ff ff jmp 108985 <rtems_termios_ioctl+0x26e>
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
108a14: 8b 4d 08 mov 0x8(%ebp),%ecx
108a17: 8b 41 08 mov 0x8(%ecx),%eax
108a1a: 8b 93 cc 00 00 00 mov 0xcc(%ebx),%edx
108a20: 89 10 mov %edx,(%eax)
break;
108a22: eb 1d jmp 108a41 <rtems_termios_ioctl+0x32a>
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
108a24: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED
108a27: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED
if ( rawnc < 0 )
108a2a: 29 d0 sub %edx,%eax <== NOT EXECUTED
108a2c: 79 05 jns 108a33 <rtems_termios_ioctl+0x31c><== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
108a2e: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED
108a31: 01 d0 add %edx,%eax <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
108a33: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
108a36: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED
108a39: 03 43 20 add 0x20(%ebx),%eax <== NOT EXECUTED
108a3c: 2b 43 24 sub 0x24(%ebx),%eax <== NOT EXECUTED
108a3f: 89 02 mov %eax,(%edx) <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
108a41: 83 ec 0c sub $0xc,%esp
108a44: ff 73 18 pushl 0x18(%ebx)
108a47: e8 68 18 00 00 call 10a2b4 <rtems_semaphore_release>
args->ioctl_return = sc;
108a4c: 8b 55 e4 mov -0x1c(%ebp),%edx
108a4f: 8b 45 08 mov 0x8(%ebp),%eax
108a52: 89 50 0c mov %edx,0xc(%eax)
return sc;
108a55: 83 c4 10 add $0x10,%esp
}
108a58: 8b 45 e4 mov -0x1c(%ebp),%eax
108a5b: 8d 65 f4 lea -0xc(%ebp),%esp
108a5e: 5b pop %ebx
108a5f: 5e pop %esi
108a60: 5f pop %edi
108a61: c9 leave
108a62: c3 ret
00108155 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
108155: 55 push %ebp
108156: 89 e5 mov %esp,%ebp
108158: 57 push %edi
108159: 56 push %esi
10815a: 53 push %ebx
10815b: 83 ec 20 sub $0x20,%esp
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
10815e: 6a 00 push $0x0
108160: 6a 00 push $0x0
108162: ff 35 dc 40 12 00 pushl 0x1240dc
108168: e8 5b 20 00 00 call 10a1c8 <rtems_semaphore_obtain>
10816d: 89 45 e4 mov %eax,-0x1c(%ebp)
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
108170: 83 c4 10 add $0x10,%esp
108173: 85 c0 test %eax,%eax
108175: 0f 85 d3 03 00 00 jne 10854e <rtems_termios_open+0x3f9><== NEVER TAKEN
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
10817b: 8b 35 e4 40 12 00 mov 0x1240e4,%esi
108181: 89 f2 mov %esi,%edx
108183: eb 16 jmp 10819b <rtems_termios_open+0x46>
if ((tty->major == major) && (tty->minor == minor))
108185: 8b 45 08 mov 0x8(%ebp),%eax
108188: 39 42 0c cmp %eax,0xc(%edx)
10818b: 75 0c jne 108199 <rtems_termios_open+0x44>
10818d: 8b 4d 0c mov 0xc(%ebp),%ecx
108190: 39 4a 10 cmp %ecx,0x10(%edx)
108193: 0f 84 26 03 00 00 je 1084bf <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) {
108199: 8b 12 mov (%edx),%edx
10819b: 85 d2 test %edx,%edx
10819d: 75 e6 jne 108185 <rtems_termios_open+0x30>
10819f: e9 b5 03 00 00 jmp 108559 <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);
1081a4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1081a7: eb 30 jmp 1081d9 <rtems_termios_open+0x84><== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
1081a9: a1 48 1f 12 00 mov 0x121f48,%eax
1081ae: 89 42 64 mov %eax,0x64(%edx)
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
1081b1: 8b 42 64 mov 0x64(%edx),%eax
1081b4: 83 ec 0c sub $0xc,%esp
1081b7: 50 push %eax
1081b8: 89 55 e0 mov %edx,-0x20(%ebp)
1081bb: e8 c0 f3 ff ff call 107580 <malloc>
1081c0: 89 c7 mov %eax,%edi
1081c2: 8b 55 e0 mov -0x20(%ebp),%edx
1081c5: 89 42 58 mov %eax,0x58(%edx)
if (tty->rawInBuf.theBuf == NULL) {
1081c8: 83 c4 10 add $0x10,%esp
1081cb: 85 c0 test %eax,%eax
1081cd: 75 24 jne 1081f3 <rtems_termios_open+0x9e><== ALWAYS TAKEN
free(tty);
1081cf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1081d2: 52 push %edx <== NOT EXECUTED
1081d3: e8 0c f1 ff ff call 1072e4 <free> <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
1081d8: 5b pop %ebx <== NOT EXECUTED
1081d9: ff 35 dc 40 12 00 pushl 0x1240dc <== NOT EXECUTED
1081df: e8 d0 20 00 00 call 10a2b4 <rtems_semaphore_release><== NOT EXECUTED
return RTEMS_NO_MEMORY;
1081e4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1081e7: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp) <== NOT EXECUTED
1081ee: e9 5b 03 00 00 jmp 10854e <rtems_termios_open+0x3f9><== NOT EXECUTED
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
1081f3: a1 4c 1f 12 00 mov 0x121f4c,%eax
1081f8: 89 82 88 00 00 00 mov %eax,0x88(%edx)
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
1081fe: 8b 82 88 00 00 00 mov 0x88(%edx),%eax
108204: 83 ec 0c sub $0xc,%esp
108207: 50 push %eax
108208: 89 55 e0 mov %edx,-0x20(%ebp)
10820b: e8 70 f3 ff ff call 107580 <malloc>
108210: 8b 55 e0 mov -0x20(%ebp),%edx
108213: 89 42 7c mov %eax,0x7c(%edx)
if (tty->rawOutBuf.theBuf == NULL) {
108216: 83 c4 10 add $0x10,%esp
108219: 85 c0 test %eax,%eax
10821b: 75 05 jne 108222 <rtems_termios_open+0xcd><== ALWAYS TAKEN
free((void *)(tty->rawInBuf.theBuf));
10821d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108220: eb 2e jmp 108250 <rtems_termios_open+0xfb><== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
108222: 83 ec 0c sub $0xc,%esp
108225: ff 35 44 1f 12 00 pushl 0x121f44
10822b: 89 55 e0 mov %edx,-0x20(%ebp)
10822e: 89 45 dc mov %eax,-0x24(%ebp)
108231: e8 4a f3 ff ff call 107580 <malloc>
108236: 8b 55 e0 mov -0x20(%ebp),%edx
108239: 89 42 1c mov %eax,0x1c(%edx)
if (tty->cbuf == NULL) {
10823c: 83 c4 10 add $0x10,%esp
10823f: 85 c0 test %eax,%eax
108241: 8b 4d dc mov -0x24(%ebp),%ecx
108244: 75 19 jne 10825f <rtems_termios_open+0x10a><== ALWAYS TAKEN
free((void *)(tty->rawOutBuf.theBuf));
108246: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108249: 51 push %ecx <== NOT EXECUTED
10824a: e8 95 f0 ff ff call 1072e4 <free> <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
10824f: 59 pop %ecx <== NOT EXECUTED
108250: 57 push %edi <== NOT EXECUTED
108251: e8 8e f0 ff ff call 1072e4 <free> <== NOT EXECUTED
free(tty);
108256: 5a pop %edx <== NOT EXECUTED
108257: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
10825a: e9 73 ff ff ff jmp 1081d2 <rtems_termios_open+0x7d><== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
10825f: c7 82 d4 00 00 00 00 movl $0x0,0xd4(%edx)
108266: 00 00 00
tty->tty_snd.sw_arg = NULL;
108269: c7 82 d8 00 00 00 00 movl $0x0,0xd8(%edx)
108270: 00 00 00
tty->tty_rcv.sw_pfn = NULL;
108273: c7 82 dc 00 00 00 00 movl $0x0,0xdc(%edx)
10827a: 00 00 00
tty->tty_rcv.sw_arg = NULL;
10827d: c7 82 e0 00 00 00 00 movl $0x0,0xe0(%edx)
108284: 00 00 00
tty->tty_rcvwakeup = 0;
108287: c7 82 e4 00 00 00 00 movl $0x0,0xe4(%edx)
10828e: 00 00 00
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
108291: 89 32 mov %esi,(%edx)
tty->back = NULL;
108293: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
if (rtems_termios_ttyHead != NULL)
10829a: 85 f6 test %esi,%esi
10829c: 74 03 je 1082a1 <rtems_termios_open+0x14c>
rtems_termios_ttyHead->back = tty;
10829e: 89 56 04 mov %edx,0x4(%esi)
rtems_termios_ttyHead = tty;
1082a1: 89 1d e4 40 12 00 mov %ebx,0x1240e4
if (rtems_termios_ttyTail == NULL)
1082a7: 83 3d e0 40 12 00 00 cmpl $0x0,0x1240e0
1082ae: 75 06 jne 1082b6 <rtems_termios_open+0x161>
rtems_termios_ttyTail = tty;
1082b0: 89 1d e0 40 12 00 mov %ebx,0x1240e0
tty->minor = minor;
1082b6: 8b 45 0c mov 0xc(%ebp),%eax
1082b9: 89 43 10 mov %eax,0x10(%ebx)
tty->major = major;
1082bc: 8b 4d 08 mov 0x8(%ebp),%ecx
1082bf: 89 4b 0c mov %ecx,0xc(%ebx)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
1082c2: 83 ec 0c sub $0xc,%esp
1082c5: 8d 43 14 lea 0x14(%ebx),%eax
1082c8: 50 push %eax
1082c9: 6a 00 push $0x0
1082cb: 6a 54 push $0x54
1082cd: 6a 01 push $0x1
rtems_build_name ('T', 'R', 'i', c),
1082cf: 0f be 05 50 1f 12 00 movsbl 0x121f50,%eax
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
1082d6: 0d 00 69 52 54 or $0x54526900,%eax
1082db: 50 push %eax
1082dc: 89 55 e0 mov %edx,-0x20(%ebp)
1082df: e8 bc 1c 00 00 call 109fa0 <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)
1082e4: 83 c4 20 add $0x20,%esp
1082e7: 85 c0 test %eax,%eax
1082e9: 8b 55 e0 mov -0x20(%ebp),%edx
1082ec: 0f 85 42 02 00 00 jne 108534 <rtems_termios_open+0x3df>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
1082f2: 83 ec 0c sub $0xc,%esp
1082f5: 8d 43 18 lea 0x18(%ebx),%eax
1082f8: 50 push %eax
1082f9: 6a 00 push $0x0
1082fb: 6a 54 push $0x54
1082fd: 6a 01 push $0x1
rtems_build_name ('T', 'R', 'o', c),
1082ff: 0f be 05 50 1f 12 00 movsbl 0x121f50,%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 (
108306: 0d 00 6f 52 54 or $0x54526f00,%eax
10830b: 50 push %eax
10830c: 89 55 e0 mov %edx,-0x20(%ebp)
10830f: e8 8c 1c 00 00 call 109fa0 <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)
108314: 83 c4 20 add $0x20,%esp
108317: 85 c0 test %eax,%eax
108319: 8b 55 e0 mov -0x20(%ebp),%edx
10831c: 0f 85 12 02 00 00 jne 108534 <rtems_termios_open+0x3df>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
108322: 83 ec 0c sub $0xc,%esp
108325: 8d 83 8c 00 00 00 lea 0x8c(%ebx),%eax
10832b: 50 push %eax
10832c: 6a 00 push $0x0
10832e: 6a 20 push $0x20
108330: 6a 00 push $0x0
rtems_build_name ('T', 'R', 'x', c),
108332: 0f be 05 50 1f 12 00 movsbl 0x121f50,%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 (
108339: 0d 00 78 52 54 or $0x54527800,%eax
10833e: 50 push %eax
10833f: 89 55 e0 mov %edx,-0x20(%ebp)
108342: e8 59 1c 00 00 call 109fa0 <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)
108347: 83 c4 20 add $0x20,%esp
10834a: 85 c0 test %eax,%eax
10834c: 8b 55 e0 mov -0x20(%ebp),%edx
10834f: 0f 85 df 01 00 00 jne 108534 <rtems_termios_open+0x3df>
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
108355: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx)
10835c: 00 00 00
/*
* Set callbacks
*/
tty->device = *callbacks;
10835f: 8d bb 98 00 00 00 lea 0x98(%ebx),%edi
108365: b9 08 00 00 00 mov $0x8,%ecx
10836a: 8b 75 14 mov 0x14(%ebp),%esi
10836d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
10836f: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
108376: 75 74 jne 1083ec <rtems_termios_open+0x297>
sc = rtems_task_create (
108378: 50 push %eax
108379: 50 push %eax
10837a: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax
108380: 50 push %eax
108381: 6a 00 push $0x0
108383: 68 00 05 00 00 push $0x500
108388: 68 00 04 00 00 push $0x400
10838d: 6a 0a push $0xa
rtems_build_name ('T', 'x', 'T', c),
10838f: 0f be 05 50 1f 12 00 movsbl 0x121f50,%eax
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
108396: 0d 00 54 78 54 or $0x54785400,%eax
10839b: 50 push %eax
10839c: 89 55 e0 mov %edx,-0x20(%ebp)
10839f: e8 a0 1f 00 00 call 10a344 <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)
1083a4: 83 c4 20 add $0x20,%esp
1083a7: 85 c0 test %eax,%eax
1083a9: 8b 55 e0 mov -0x20(%ebp),%edx
1083ac: 0f 85 82 01 00 00 jne 108534 <rtems_termios_open+0x3df><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
1083b2: 57 push %edi
1083b3: 57 push %edi
1083b4: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax
1083ba: 50 push %eax
1083bb: 6a 00 push $0x0
1083bd: 68 00 05 00 00 push $0x500
1083c2: 68 00 04 00 00 push $0x400
1083c7: 6a 09 push $0x9
rtems_build_name ('R', 'x', 'T', c),
1083c9: 0f be 05 50 1f 12 00 movsbl 0x121f50,%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 (
1083d0: 0d 00 54 78 52 or $0x52785400,%eax
1083d5: 50 push %eax
1083d6: 89 55 e0 mov %edx,-0x20(%ebp)
1083d9: e8 66 1f 00 00 call 10a344 <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)
1083de: 83 c4 20 add $0x20,%esp
1083e1: 85 c0 test %eax,%eax
1083e3: 8b 55 e0 mov -0x20(%ebp),%edx
1083e6: 0f 85 48 01 00 00 jne 108534 <rtems_termios_open+0x3df><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
1083ec: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
1083f3: 74 09 je 1083fe <rtems_termios_open+0x2a9>
1083f5: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
1083fc: 75 30 jne 10842e <rtems_termios_open+0x2d9>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
1083fe: 83 ec 0c sub $0xc,%esp
108401: 8d 43 68 lea 0x68(%ebx),%eax
108404: 50 push %eax
108405: 6a 00 push $0x0
108407: 6a 24 push $0x24
108409: 6a 00 push $0x0
rtems_build_name ('T', 'R', 'r', c),
10840b: 0f be 05 50 1f 12 00 movsbl 0x121f50,%eax
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
108412: 0d 00 72 52 54 or $0x54527200,%eax
108417: 50 push %eax
108418: 89 55 e0 mov %edx,-0x20(%ebp)
10841b: e8 80 1b 00 00 call 109fa0 <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)
108420: 83 c4 20 add $0x20,%esp
108423: 85 c0 test %eax,%eax
108425: 8b 55 e0 mov -0x20(%ebp),%edx
108428: 0f 85 06 01 00 00 jne 108534 <rtems_termios_open+0x3df>
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
10842e: c7 43 30 02 25 00 00 movl $0x2502,0x30(%ebx)
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
108435: c7 43 34 05 18 00 00 movl $0x1805,0x34(%ebx)
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
10843c: c7 43 38 bd 08 00 00 movl $0x8bd,0x38(%ebx)
tty->termios.c_lflag =
108443: c7 43 3c 3b 82 00 00 movl $0x823b,0x3c(%ebx)
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
10844a: c6 43 41 03 movb $0x3,0x41(%ebx)
tty->termios.c_cc[VQUIT] = '\034';
10844e: c6 43 42 1c movb $0x1c,0x42(%ebx)
tty->termios.c_cc[VERASE] = '\177';
108452: c6 43 43 7f movb $0x7f,0x43(%ebx)
tty->termios.c_cc[VKILL] = '\025';
108456: c6 43 44 15 movb $0x15,0x44(%ebx)
tty->termios.c_cc[VEOF] = '\004';
10845a: c6 43 45 04 movb $0x4,0x45(%ebx)
tty->termios.c_cc[VEOL] = '\000';
10845e: c6 43 4c 00 movb $0x0,0x4c(%ebx)
tty->termios.c_cc[VEOL2] = '\000';
108462: c6 43 51 00 movb $0x0,0x51(%ebx)
tty->termios.c_cc[VSTART] = '\021';
108466: c6 43 49 11 movb $0x11,0x49(%ebx)
tty->termios.c_cc[VSTOP] = '\023';
10846a: c6 43 4a 13 movb $0x13,0x4a(%ebx)
tty->termios.c_cc[VSUSP] = '\032';
10846e: c6 43 4b 1a movb $0x1a,0x4b(%ebx)
tty->termios.c_cc[VREPRINT] = '\022';
108472: c6 43 4d 12 movb $0x12,0x4d(%ebx)
tty->termios.c_cc[VDISCARD] = '\017';
108476: c6 43 4e 0f movb $0xf,0x4e(%ebx)
tty->termios.c_cc[VWERASE] = '\027';
10847a: c6 43 4f 17 movb $0x17,0x4f(%ebx)
tty->termios.c_cc[VLNEXT] = '\026';
10847e: c6 43 50 16 movb $0x16,0x50(%ebx)
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
108482: c7 83 b8 00 00 00 00 movl $0x0,0xb8(%ebx)
108489: 00 00 00
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
10848c: 8b 43 64 mov 0x64(%ebx),%eax
10848f: d1 e8 shr %eax
108491: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
tty->highwater = tty->rawInBuf.Size * 3/4;
108497: 8b 43 64 mov 0x64(%ebx),%eax
10849a: 8d 04 40 lea (%eax,%eax,2),%eax
10849d: c1 e8 02 shr $0x2,%eax
1084a0: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx)
/*
* Bump name characer
*/
if (c++ == 'z')
1084a6: a0 50 1f 12 00 mov 0x121f50,%al
1084ab: 8d 48 01 lea 0x1(%eax),%ecx
1084ae: 88 0d 50 1f 12 00 mov %cl,0x121f50
1084b4: 3c 7a cmp $0x7a,%al
1084b6: 75 07 jne 1084bf <rtems_termios_open+0x36a><== ALWAYS TAKEN
c = 'a';
1084b8: c6 05 50 1f 12 00 61 movb $0x61,0x121f50 <== NOT EXECUTED
}
args->iop->data1 = tty;
1084bf: 8b 4d 10 mov 0x10(%ebp),%ecx
1084c2: 8b 01 mov (%ecx),%eax
1084c4: 89 50 34 mov %edx,0x34(%eax)
if (!tty->refcount++) {
1084c7: 8b 42 08 mov 0x8(%edx),%eax
1084ca: 8d 48 01 lea 0x1(%eax),%ecx
1084cd: 89 4a 08 mov %ecx,0x8(%edx)
1084d0: 85 c0 test %eax,%eax
1084d2: 75 69 jne 10853d <rtems_termios_open+0x3e8>
if (tty->device.firstOpen)
1084d4: 8b 82 98 00 00 00 mov 0x98(%edx),%eax
1084da: 85 c0 test %eax,%eax
1084dc: 74 15 je 1084f3 <rtems_termios_open+0x39e>
(*tty->device.firstOpen)(major, minor, arg);
1084de: 56 push %esi
1084df: ff 75 10 pushl 0x10(%ebp)
1084e2: ff 75 0c pushl 0xc(%ebp)
1084e5: ff 75 08 pushl 0x8(%ebp)
1084e8: 89 55 e0 mov %edx,-0x20(%ebp)
1084eb: ff d0 call *%eax
1084ed: 83 c4 10 add $0x10,%esp
1084f0: 8b 55 e0 mov -0x20(%ebp),%edx
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
1084f3: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx)
1084fa: 75 41 jne 10853d <rtems_termios_open+0x3e8>
sc = rtems_task_start(
1084fc: 53 push %ebx
1084fd: 52 push %edx
1084fe: 68 0f 96 10 00 push $0x10960f
108503: ff b2 c4 00 00 00 pushl 0xc4(%edx)
108509: 89 55 e0 mov %edx,-0x20(%ebp)
10850c: e8 a7 20 00 00 call 10a5b8 <rtems_task_start>
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
108511: 83 c4 10 add $0x10,%esp
108514: 85 c0 test %eax,%eax
108516: 8b 55 e0 mov -0x20(%ebp),%edx
108519: 75 19 jne 108534 <rtems_termios_open+0x3df><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
10851b: 51 push %ecx
10851c: 52 push %edx
10851d: 68 41 98 10 00 push $0x109841
108522: ff b2 c8 00 00 00 pushl 0xc8(%edx)
108528: e8 8b 20 00 00 call 10a5b8 <rtems_task_start>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
10852d: 83 c4 10 add $0x10,%esp
108530: 85 c0 test %eax,%eax
108532: 74 09 je 10853d <rtems_termios_open+0x3e8><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
108534: 83 ec 0c sub $0xc,%esp
108537: 50 push %eax
108538: e8 53 22 00 00 call 10a790 <rtems_fatal_error_occurred>
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
10853d: 83 ec 0c sub $0xc,%esp
108540: ff 35 dc 40 12 00 pushl 0x1240dc
108546: e8 69 1d 00 00 call 10a2b4 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
10854b: 83 c4 10 add $0x10,%esp
}
10854e: 8b 45 e4 mov -0x1c(%ebp),%eax
108551: 8d 65 f4 lea -0xc(%ebp),%esp
108554: 5b pop %ebx
108555: 5e pop %esi
108556: 5f pop %edi
108557: c9 leave
108558: c3 ret
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
108559: 52 push %edx
10855a: 52 push %edx
10855b: 68 e8 00 00 00 push $0xe8
108560: 6a 01 push $0x1
108562: e8 c1 eb ff ff call 107128 <calloc>
108567: 89 c2 mov %eax,%edx
108569: 89 c3 mov %eax,%ebx
if (tty == NULL) {
10856b: 83 c4 10 add $0x10,%esp
10856e: 85 c0 test %eax,%eax
108570: 0f 85 33 fc ff ff jne 1081a9 <rtems_termios_open+0x54><== ALWAYS TAKEN
108576: e9 29 fc ff ff jmp 1081a4 <rtems_termios_open+0x4f><== NOT EXECUTED
00108a63 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
108a63: 55 push %ebp
108a64: 89 e5 mov %esp,%ebp
108a66: 57 push %edi
108a67: 56 push %esi
108a68: 53 push %ebx
108a69: 83 ec 3c sub $0x3c,%esp
108a6c: 8b 45 08 mov 0x8(%ebp),%eax
108a6f: 8b 75 0c mov 0xc(%ebp),%esi
108a72: 8b 5d 10 mov 0x10(%ebp),%ebx
const unsigned char *buf = _buf;
108a75: 89 c7 mov %eax,%edi
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
108a77: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx)
108a7e: 75 1b jne 108a9b <rtems_termios_puts+0x38>
(*tty->device.write)(tty->minor, (void *)buf, len);
108a80: 89 75 10 mov %esi,0x10(%ebp)
108a83: 89 45 0c mov %eax,0xc(%ebp)
108a86: 8b 43 10 mov 0x10(%ebx),%eax
108a89: 89 45 08 mov %eax,0x8(%ebp)
108a8c: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
108a92: 8d 65 f4 lea -0xc(%ebp),%esp
108a95: 5b pop %ebx
108a96: 5e pop %esi
108a97: 5f pop %edi
108a98: 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);
108a99: ff e0 jmp *%eax
return;
}
newHead = tty->rawOutBuf.Head;
108a9b: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
108aa1: 89 45 e4 mov %eax,-0x1c(%ebp)
while (len) {
108aa4: e9 ca 00 00 00 jmp 108b73 <rtems_termios_puts+0x110>
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
108aa9: 8b 45 e4 mov -0x1c(%ebp),%eax
108aac: 40 inc %eax
108aad: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
108ab3: 31 d2 xor %edx,%edx
108ab5: f7 f1 div %ecx
108ab7: 89 55 c4 mov %edx,-0x3c(%ebp)
108aba: 89 55 e4 mov %edx,-0x1c(%ebp)
rtems_interrupt_disable (level);
108abd: 9c pushf
108abe: fa cli
108abf: 8f 45 d4 popl -0x2c(%ebp)
108ac2: 8b 55 d4 mov -0x2c(%ebp),%edx
108ac5: 8b 4d c4 mov -0x3c(%ebp),%ecx
while (newHead == tty->rawOutBuf.Tail) {
108ac8: eb 35 jmp 108aff <rtems_termios_puts+0x9c>
tty->rawOutBufState = rob_wait;
108aca: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
108ad1: 00 00 00
rtems_interrupt_enable (level);
108ad4: 52 push %edx
108ad5: 9d popf
sc = rtems_semaphore_obtain(
108ad6: 50 push %eax
108ad7: 6a 00 push $0x0
108ad9: 6a 00 push $0x0
108adb: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
108ae1: 89 4d e0 mov %ecx,-0x20(%ebp)
108ae4: e8 df 16 00 00 call 10a1c8 <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
108ae9: 83 c4 10 add $0x10,%esp
108aec: 85 c0 test %eax,%eax
108aee: 8b 4d e0 mov -0x20(%ebp),%ecx
108af1: 74 09 je 108afc <rtems_termios_puts+0x99><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
108af3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108af6: 50 push %eax <== NOT EXECUTED
108af7: e8 94 1c 00 00 call 10a790 <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_interrupt_disable (level);
108afc: 9c pushf
108afd: fa cli
108afe: 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) {
108aff: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
108b05: 39 c1 cmp %eax,%ecx
108b07: 74 c1 je 108aca <rtems_termios_puts+0x67>
108b09: 89 55 d4 mov %edx,-0x2c(%ebp)
108b0c: 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++;
108b0f: 8b 8b 80 00 00 00 mov 0x80(%ebx),%ecx
108b15: 8a 07 mov (%edi),%al
108b17: 8b 53 7c mov 0x7c(%ebx),%edx
108b1a: 88 04 0a mov %al,(%edx,%ecx,1)
108b1d: 47 inc %edi
tty->rawOutBuf.Head = newHead;
108b1e: 8b 4d c4 mov -0x3c(%ebp),%ecx
108b21: 89 8b 80 00 00 00 mov %ecx,0x80(%ebx)
if (tty->rawOutBufState == rob_idle) {
108b27: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx)
108b2e: 75 3e jne 108b6e <rtems_termios_puts+0x10b>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
108b30: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108b36: a8 10 test $0x10,%al
108b38: 75 1b jne 108b55 <rtems_termios_puts+0xf2><== NEVER TAKEN
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
108b3a: 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,
108b40: 51 push %ecx
108b41: 6a 01 push $0x1
108b43: 03 43 7c add 0x7c(%ebx),%eax
108b46: 50 push %eax
108b47: ff 73 10 pushl 0x10(%ebx)
108b4a: ff 93 a4 00 00 00 call *0xa4(%ebx)
108b50: 83 c4 10 add $0x10,%esp
108b53: eb 0f jmp 108b64 <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;
108b55: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108b5b: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
108b5e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
108b64: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
108b6b: 00 00 00
}
rtems_interrupt_enable (level);
108b6e: ff 75 d4 pushl -0x2c(%ebp)
108b71: 9d popf
len--;
108b72: 4e dec %esi
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
108b73: 85 f6 test %esi,%esi
108b75: 0f 85 2e ff ff ff jne 108aa9 <rtems_termios_puts+0x46>
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
108b7b: 8d 65 f4 lea -0xc(%ebp),%esp
108b7e: 5b pop %ebx
108b7f: 5e pop %esi
108b80: 5f pop %edi
108b81: c9 leave
108b82: c3 ret
0010908a <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
10908a: 55 push %ebp
10908b: 89 e5 mov %esp,%ebp
10908d: 57 push %edi
10908e: 56 push %esi
10908f: 53 push %ebx
109090: 83 ec 40 sub $0x40,%esp
109093: 8b 75 08 mov 0x8(%ebp),%esi
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
109096: 8b 06 mov (%esi),%eax
109098: 8b 58 34 mov 0x34(%eax),%ebx
uint32_t count = args->count;
10909b: 8b 46 10 mov 0x10(%esi),%eax
10909e: 89 45 e4 mov %eax,-0x1c(%ebp)
char *buffer = args->buffer;
1090a1: 8b 46 0c mov 0xc(%esi),%eax
1090a4: 89 45 e0 mov %eax,-0x20(%ebp)
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
1090a7: 6a 00 push $0x0
1090a9: 6a 00 push $0x0
1090ab: ff 73 14 pushl 0x14(%ebx)
1090ae: e8 15 11 00 00 call 10a1c8 <rtems_semaphore_obtain>
1090b3: 89 45 dc mov %eax,-0x24(%ebp)
if (sc != RTEMS_SUCCESSFUL)
1090b6: 83 c4 10 add $0x10,%esp
1090b9: 85 c0 test %eax,%eax
1090bb: 0f 85 9d 02 00 00 jne 10935e <rtems_termios_read+0x2d4><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
1090c1: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
1090c7: c1 e0 05 shl $0x5,%eax
1090ca: 8b 80 9c 3d 12 00 mov 0x123d9c(%eax),%eax
1090d0: 85 c0 test %eax,%eax
1090d2: 74 19 je 1090ed <rtems_termios_read+0x63>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
1090d4: 57 push %edi
1090d5: 57 push %edi
1090d6: 56 push %esi
1090d7: 53 push %ebx
1090d8: ff d0 call *%eax
1090da: 89 45 dc mov %eax,-0x24(%ebp)
tty->tty_rcvwakeup = 0;
1090dd: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
1090e4: 00 00 00
rtems_semaphore_release (tty->isem);
1090e7: 59 pop %ecx
1090e8: e9 66 02 00 00 jmp 109353 <rtems_termios_read+0x2c9>
return sc;
}
if (tty->cindex == tty->ccount) {
1090ed: 8b 43 20 mov 0x20(%ebx),%eax
1090f0: 39 43 24 cmp %eax,0x24(%ebx)
1090f3: 0f 85 2d 02 00 00 jne 109326 <rtems_termios_read+0x29c><== NEVER TAKEN
tty->cindex = tty->ccount = 0;
1090f9: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
109100: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
tty->read_start_column = tty->column;
109107: 8b 43 28 mov 0x28(%ebx),%eax
10910a: 89 43 2c mov %eax,0x2c(%ebx)
if (tty->device.pollRead != NULL &&
10910d: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
109114: 0f 84 c4 00 00 00 je 1091de <rtems_termios_read+0x154>
10911a: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx)
109121: 0f 85 b7 00 00 00 jne 1091de <rtems_termios_read+0x154>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
109127: f6 43 3c 02 testb $0x2,0x3c(%ebx)
10912b: 74 35 je 109162 <rtems_termios_read+0xd8><== NEVER TAKEN
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
10912d: 83 ec 0c sub $0xc,%esp
109130: ff 73 10 pushl 0x10(%ebx)
109133: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (n < 0) {
109139: 83 c4 10 add $0x10,%esp
10913c: 85 c0 test %eax,%eax
10913e: 79 0f jns 10914f <rtems_termios_read+0xc5>
rtems_task_wake_after (1);
109140: 83 ec 0c sub $0xc,%esp
109143: 6a 01 push $0x1
109145: e8 d2 14 00 00 call 10a61c <rtems_task_wake_after>
10914a: 83 c4 10 add $0x10,%esp
10914d: eb de jmp 10912d <rtems_termios_read+0xa3>
} else {
if (siproc (n, tty))
10914f: 0f b6 c0 movzbl %al,%eax
109152: 89 da mov %ebx,%edx
109154: e8 38 fe ff ff call 108f91 <siproc>
109159: 85 c0 test %eax,%eax
10915b: 74 d0 je 10912d <rtems_termios_read+0xa3>
10915d: e9 c4 01 00 00 jmp 109326 <rtems_termios_read+0x29c>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
109162: e8 35 0a 00 00 call 109b9c <rtems_clock_get_ticks_since_boot><== NOT EXECUTED
109167: 89 c7 mov %eax,%edi <== NOT EXECUTED
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
109169: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10916c: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10916f: ff 93 a0 00 00 00 call *0xa0(%ebx) <== NOT EXECUTED
if (n < 0) {
109175: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109178: 85 c0 test %eax,%eax <== NOT EXECUTED
10917a: 79 3d jns 1091b9 <rtems_termios_read+0x12f><== NOT EXECUTED
if (tty->termios.c_cc[VMIN]) {
10917c: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED
109180: 74 0e je 109190 <rtems_termios_read+0x106><== NOT EXECUTED
if (tty->termios.c_cc[VTIME] && tty->ccount) {
109182: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED
109186: 74 22 je 1091aa <rtems_termios_read+0x120><== NOT EXECUTED
109188: 83 7b 20 00 cmpl $0x0,0x20(%ebx) <== NOT EXECUTED
10918c: 74 1c je 1091aa <rtems_termios_read+0x120><== NOT EXECUTED
10918e: eb 0a jmp 10919a <rtems_termios_read+0x110><== NOT EXECUTED
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
109190: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED
109194: 0f 84 8c 01 00 00 je 109326 <rtems_termios_read+0x29c><== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
10919a: e8 fd 09 00 00 call 109b9c <rtems_clock_get_ticks_since_boot><== NOT EXECUTED
if ((now - then) > tty->vtimeTicks) {
10919f: 29 f8 sub %edi,%eax <== NOT EXECUTED
1091a1: 3b 43 54 cmp 0x54(%ebx),%eax <== NOT EXECUTED
1091a4: 0f 87 7c 01 00 00 ja 109326 <rtems_termios_read+0x29c><== NOT EXECUTED
break;
}
}
rtems_task_wake_after (1);
1091aa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1091ad: 6a 01 push $0x1 <== NOT EXECUTED
1091af: e8 68 14 00 00 call 10a61c <rtems_task_wake_after> <== NOT EXECUTED
1091b4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1091b7: eb b0 jmp 109169 <rtems_termios_read+0xdf><== NOT EXECUTED
} else {
siproc (n, tty);
1091b9: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
1091bc: 89 da mov %ebx,%edx <== NOT EXECUTED
1091be: e8 ce fd ff ff call 108f91 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
1091c3: 8a 43 47 mov 0x47(%ebx),%al <== NOT EXECUTED
1091c6: 0f b6 d0 movzbl %al,%edx <== NOT EXECUTED
1091c9: 39 53 20 cmp %edx,0x20(%ebx) <== NOT EXECUTED
1091cc: 0f 8d 54 01 00 00 jge 109326 <rtems_termios_read+0x29c><== NOT EXECUTED
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
1091d2: 84 c0 test %al,%al <== NOT EXECUTED
1091d4: 74 93 je 109169 <rtems_termios_read+0xdf><== NOT EXECUTED
1091d6: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED
1091da: 74 8d je 109169 <rtems_termios_read+0xdf><== NOT EXECUTED
1091dc: eb 84 jmp 109162 <rtems_termios_read+0xd8><== NOT EXECUTED
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
1091de: 8b 53 74 mov 0x74(%ebx),%edx
rtems_status_code sc;
int wait = (int)1;
1091e1: 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)(
1091e6: 8d 43 49 lea 0x49(%ebx),%eax
1091e9: 89 45 d0 mov %eax,-0x30(%ebp)
1091ec: e9 e6 00 00 00 jmp 1092d7 <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;
1091f1: 8b 43 5c mov 0x5c(%ebx),%eax
1091f4: 8b 4b 64 mov 0x64(%ebx),%ecx
1091f7: 40 inc %eax
1091f8: 31 d2 xor %edx,%edx
1091fa: f7 f1 div %ecx
c = tty->rawInBuf.theBuf[newHead];
1091fc: 8b 43 58 mov 0x58(%ebx),%eax
1091ff: 8a 04 10 mov (%eax,%edx,1),%al
109202: 88 45 db mov %al,-0x25(%ebp)
tty->rawInBuf.Head = newHead;
109205: 89 53 5c mov %edx,0x5c(%ebx)
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
109208: 8b 43 60 mov 0x60(%ebx),%eax
10920b: 89 45 c4 mov %eax,-0x3c(%ebp)
10920e: 8b 4b 64 mov 0x64(%ebx),%ecx
% tty->rawInBuf.Size)
109211: 8b 43 64 mov 0x64(%ebx),%eax
109214: 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)
109217: 8b 45 c4 mov -0x3c(%ebp),%eax
10921a: 8d 04 01 lea (%ecx,%eax,1),%eax
10921d: 29 d0 sub %edx,%eax
% tty->rawInBuf.Size)
10921f: 31 d2 xor %edx,%edx
109221: 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)
109224: 3b 93 bc 00 00 00 cmp 0xbc(%ebx),%edx
10922a: 73 74 jae 1092a0 <rtems_termios_read+0x216><== NEVER TAKEN
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
10922c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109232: 83 e0 fe and $0xfffffffe,%eax
109235: 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))
10923b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109241: 25 02 02 00 00 and $0x202,%eax
109246: 3d 02 02 00 00 cmp $0x202,%eax
10924b: 75 24 jne 109271 <rtems_termios_read+0x1e7><== ALWAYS TAKEN
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
10924d: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
109254: 74 0a je 109260 <rtems_termios_read+0x1d6><== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
109256: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10925c: a8 20 test $0x20,%al <== NOT EXECUTED
10925e: 74 11 je 109271 <rtems_termios_read+0x1e7><== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
109260: 52 push %edx <== NOT EXECUTED
109261: 6a 01 push $0x1 <== NOT EXECUTED
109263: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED
109266: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109269: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
10926f: eb 2c jmp 10929d <rtems_termios_read+0x213><== NOT EXECUTED
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
109271: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109277: f6 c4 01 test $0x1,%ah
10927a: 74 24 je 1092a0 <rtems_termios_read+0x216><== ALWAYS TAKEN
tty->flow_ctrl &= ~FL_IRTSOFF;
10927c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109282: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
109285: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
10928b: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED
109291: 85 c0 test %eax,%eax <== NOT EXECUTED
109293: 74 0b je 1092a0 <rtems_termios_read+0x216><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
109295: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109298: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10929b: ff d0 call *%eax <== NOT EXECUTED
10929d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
1092a0: f6 43 3c 02 testb $0x2,0x3c(%ebx)
1092a4: 74 12 je 1092b8 <rtems_termios_read+0x22e><== NEVER TAKEN
if (siproc (c, tty))
1092a6: 0f b6 45 db movzbl -0x25(%ebp),%eax
1092aa: 89 da mov %ebx,%edx
1092ac: e8 e0 fc ff ff call 108f91 <siproc>
wait = 0;
1092b1: 85 c0 test %eax,%eax
1092b3: 0f 94 c0 sete %al
1092b6: eb 15 jmp 1092cd <rtems_termios_read+0x243>
} else {
siproc (c, tty);
1092b8: 0f b6 45 db movzbl -0x25(%ebp),%eax <== NOT EXECUTED
1092bc: 89 da mov %ebx,%edx <== NOT EXECUTED
1092be: e8 ce fc ff ff call 108f91 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
1092c3: 0f b6 43 47 movzbl 0x47(%ebx),%eax <== NOT EXECUTED
wait = 0;
1092c7: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED
1092ca: 0f 9c c0 setl %al <== NOT EXECUTED
1092cd: 0f b6 c0 movzbl %al,%eax
1092d0: f7 d8 neg %eax
1092d2: 21 c7 and %eax,%edi
}
timeout = tty->rawInBufSemaphoreTimeout;
1092d4: 8b 53 70 mov 0x70(%ebx),%edx
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
1092d7: 8b 4b 5c mov 0x5c(%ebx),%ecx
1092da: 8b 43 60 mov 0x60(%ebx),%eax
1092dd: 39 c1 cmp %eax,%ecx
1092df: 74 0f je 1092f0 <rtems_termios_read+0x266>
(tty->ccount < (CBUFSIZE-1))) {
1092e1: a1 44 1f 12 00 mov 0x121f44,%eax
1092e6: 48 dec %eax
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
1092e7: 39 43 20 cmp %eax,0x20(%ebx)
1092ea: 0f 8c 01 ff ff ff jl 1091f1 <rtems_termios_read+0x167><== ALWAYS TAKEN
}
/*
* Wait for characters
*/
if ( wait ) {
1092f0: 85 ff test %edi,%edi
1092f2: 74 32 je 109326 <rtems_termios_read+0x29c>
sc = rtems_semaphore_obtain(
1092f4: 50 push %eax
1092f5: 52 push %edx
1092f6: ff 73 6c pushl 0x6c(%ebx)
1092f9: ff 73 68 pushl 0x68(%ebx)
1092fc: 89 55 cc mov %edx,-0x34(%ebp)
1092ff: e8 c4 0e 00 00 call 10a1c8 <rtems_semaphore_obtain>
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
109304: 83 c4 10 add $0x10,%esp
109307: 85 c0 test %eax,%eax
109309: 8b 55 cc mov -0x34(%ebp),%edx
10930c: 74 c9 je 1092d7 <rtems_termios_read+0x24d><== ALWAYS TAKEN
10930e: eb 16 jmp 109326 <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++];
109310: 8b 7b 1c mov 0x1c(%ebx),%edi
109313: 8b 45 e4 mov -0x1c(%ebp),%eax
109316: 8a 04 07 mov (%edi,%eax,1),%al
109319: 88 01 mov %al,(%ecx)
10931b: 41 inc %ecx
10931c: 8b 45 e4 mov -0x1c(%ebp),%eax
10931f: 40 inc %eax
109320: 89 43 24 mov %eax,0x24(%ebx)
count--;
109323: 4a dec %edx
109324: eb 06 jmp 10932c <rtems_termios_read+0x2a2>
109326: 8b 55 e4 mov -0x1c(%ebp),%edx
109329: 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)) {
10932c: 85 d2 test %edx,%edx
10932e: 74 0b je 10933b <rtems_termios_read+0x2b1><== NEVER TAKEN
109330: 8b 43 24 mov 0x24(%ebx),%eax
109333: 89 45 e4 mov %eax,-0x1c(%ebp)
109336: 3b 43 20 cmp 0x20(%ebx),%eax
109339: 7c d5 jl 109310 <rtems_termios_read+0x286>
10933b: 89 55 e4 mov %edx,-0x1c(%ebp)
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
10933e: 8b 46 10 mov 0x10(%esi),%eax
109341: 29 d0 sub %edx,%eax
109343: 89 46 18 mov %eax,0x18(%esi)
tty->tty_rcvwakeup = 0;
109346: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10934d: 00 00 00
rtems_semaphore_release (tty->isem);
109350: 83 ec 0c sub $0xc,%esp
109353: ff 73 14 pushl 0x14(%ebx)
109356: e8 59 0f 00 00 call 10a2b4 <rtems_semaphore_release>
return sc;
10935b: 83 c4 10 add $0x10,%esp
}
10935e: 8b 45 dc mov -0x24(%ebp),%eax
109361: 8d 65 f4 lea -0xc(%ebp),%esp
109364: 5b pop %ebx
109365: 5e pop %esi
109366: 5f pop %edi
109367: c9 leave
109368: c3 ret
00109673 <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)
{
109673: 55 push %ebp
109674: 89 e5 mov %esp,%ebp
109676: 57 push %edi
109677: 56 push %esi
109678: 53 push %ebx
109679: 83 ec 0c sub $0xc,%esp
10967c: 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))
10967f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109685: 25 03 04 00 00 and $0x403,%eax
10968a: 3d 01 04 00 00 cmp $0x401,%eax
10968f: 75 2c jne 1096bd <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);
109691: 57 push %edi <== NOT EXECUTED
109692: 6a 01 push $0x1 <== NOT EXECUTED
109694: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED
109697: 50 push %eax <== NOT EXECUTED
109698: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10969b: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
rtems_interrupt_disable(level);
1096a1: 9c pushf <== NOT EXECUTED
1096a2: fa cli <== NOT EXECUTED
1096a3: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
1096a4: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
1096aa: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1096b0: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
1096b3: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
1096b9: 52 push %edx <== NOT EXECUTED
1096ba: 9d popf <== NOT EXECUTED
1096bb: eb 38 jmp 1096f5 <rtems_termios_refill_transmitter+0x82><== NOT EXECUTED
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
1096bd: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1096c3: 83 e0 03 and $0x3,%eax
1096c6: 83 f8 02 cmp $0x2,%eax
1096c9: 75 37 jne 109702 <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);
1096cb: 56 push %esi <== NOT EXECUTED
1096cc: 6a 01 push $0x1 <== NOT EXECUTED
1096ce: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED
1096d1: 50 push %eax <== NOT EXECUTED
1096d2: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1096d5: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
rtems_interrupt_disable(level);
1096db: 9c pushf <== NOT EXECUTED
1096dc: fa cli <== NOT EXECUTED
1096dd: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
1096de: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
1096e4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1096ea: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
1096ed: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
1096f3: 52 push %edx <== NOT EXECUTED
1096f4: 9d popf <== NOT EXECUTED
1096f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
nToSend = 1;
1096f8: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
1096fd: e9 35 01 00 00 jmp 109837 <rtems_termios_refill_transmitter+0x1c4><== NOT EXECUTED
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
109702: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
109708: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
10970e: 39 c2 cmp %eax,%edx
109710: 75 25 jne 109737 <rtems_termios_refill_transmitter+0xc4>
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
109712: 31 f6 xor %esi,%esi
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
109714: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx)
10971b: 0f 85 16 01 00 00 jne 109837 <rtems_termios_refill_transmitter+0x1c4><== ALWAYS TAKEN
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
109721: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109724: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED
10972a: e8 85 0b 00 00 call 10a2b4 <rtems_semaphore_release><== NOT EXECUTED
10972f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109732: e9 00 01 00 00 jmp 109837 <rtems_termios_refill_transmitter+0x1c4><== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
109737: 9c pushf
109738: fa cli
109739: 58 pop %eax
len = tty->t_dqlen;
10973a: 8b bb 90 00 00 00 mov 0x90(%ebx),%edi
tty->t_dqlen = 0;
109740: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx)
109747: 00 00 00
rtems_interrupt_enable(level);
10974a: 50 push %eax
10974b: 9d popf
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
10974c: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
109752: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
109758: 8d 04 07 lea (%edi,%eax,1),%eax
10975b: 31 d2 xor %edx,%edx
10975d: f7 f1 div %ecx
10975f: 89 d7 mov %edx,%edi
tty->rawOutBuf.Tail = newTail;
109761: 89 93 84 00 00 00 mov %edx,0x84(%ebx)
if (tty->rawOutBufState == rob_wait) {
109767: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx)
10976e: 75 11 jne 109781 <rtems_termios_refill_transmitter+0x10e>
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
109770: 83 ec 0c sub $0xc,%esp
109773: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
109779: e8 36 0b 00 00 call 10a2b4 <rtems_semaphore_release>
10977e: 83 c4 10 add $0x10,%esp
}
if (newTail == tty->rawOutBuf.Head) {
109781: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
109787: 39 c7 cmp %eax,%edi
109789: 75 2a jne 1097b5 <rtems_termios_refill_transmitter+0x142>
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
10978b: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx)
109792: 00 00 00
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
109795: 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;
10979b: 31 f6 xor %esi,%esi
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
10979d: 85 c0 test %eax,%eax
10979f: 0f 84 8c 00 00 00 je 109831 <rtems_termios_refill_transmitter+0x1be><== ALWAYS TAKEN
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
1097a5: 51 push %ecx <== NOT EXECUTED
1097a6: 51 push %ecx <== NOT EXECUTED
1097a7: ff b3 d8 00 00 00 pushl 0xd8(%ebx) <== NOT EXECUTED
1097ad: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED
1097b0: 52 push %edx <== NOT EXECUTED
1097b1: ff d0 call *%eax <== NOT EXECUTED
1097b3: eb 79 jmp 10982e <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))
1097b5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1097bb: 25 10 02 00 00 and $0x210,%eax
1097c0: 3d 10 02 00 00 cmp $0x210,%eax
1097c5: 75 22 jne 1097e9 <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);
1097c7: 9c pushf <== NOT EXECUTED
1097c8: fa cli <== NOT EXECUTED
1097c9: 5a pop %edx <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
1097ca: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1097d0: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
1097d3: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
1097d9: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED
1097e0: 00 00 00
rtems_interrupt_enable(level);
1097e3: 52 push %edx <== NOT EXECUTED
1097e4: 9d popf <== NOT EXECUTED
nToSend = 0;
1097e5: 31 f6 xor %esi,%esi <== NOT EXECUTED
1097e7: eb 48 jmp 109831 <rtems_termios_refill_transmitter+0x1be><== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
1097e9: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
1097ef: 39 c7 cmp %eax,%edi
1097f1: 76 08 jbe 1097fb <rtems_termios_refill_transmitter+0x188>
nToSend = tty->rawOutBuf.Size - newTail;
1097f3: 8b b3 88 00 00 00 mov 0x88(%ebx),%esi
1097f9: eb 06 jmp 109801 <rtems_termios_refill_transmitter+0x18e>
else
nToSend = tty->rawOutBuf.Head - newTail;
1097fb: 8b b3 80 00 00 00 mov 0x80(%ebx),%esi
109801: 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)) {
109803: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109809: f6 c4 06 test $0x6,%ah
10980c: 74 05 je 109813 <rtems_termios_refill_transmitter+0x1a0>
nToSend = 1;
10980e: be 01 00 00 00 mov $0x1,%esi
}
tty->rawOutBufState = rob_busy; /*apm*/
109813: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
10981a: 00 00 00
(*tty->device.write)(
10981d: 52 push %edx
10981e: 56 push %esi
10981f: 8b 43 7c mov 0x7c(%ebx),%eax
109822: 01 f8 add %edi,%eax
109824: 50 push %eax
109825: ff 73 10 pushl 0x10(%ebx)
109828: ff 93 a4 00 00 00 call *0xa4(%ebx)
10982e: 83 c4 10 add $0x10,%esp
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
109831: 89 bb 84 00 00 00 mov %edi,0x84(%ebx)
}
return nToSend;
}
109837: 89 f0 mov %esi,%eax
109839: 8d 65 f4 lea -0xc(%ebp),%esp
10983c: 5b pop %ebx
10983d: 5e pop %esi
10983e: 5f pop %edi
10983f: c9 leave
109840: c3 ret
0010960f <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
10960f: 55 push %ebp
109610: 89 e5 mov %esp,%ebp
109612: 57 push %edi
109613: 56 push %esi
109614: 53 push %ebx
109615: 83 ec 1c sub $0x1c,%esp
109618: 8b 5d 08 mov 0x8(%ebp),%ebx
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
10961b: 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);
10961e: 8d 75 e7 lea -0x19(%ebp),%esi
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
109621: 57 push %edi
109622: 6a 00 push $0x0
109624: 6a 02 push $0x2
109626: 6a 03 push $0x3
109628: e8 d3 05 00 00 call 109c00 <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) {
10962d: 83 c4 10 add $0x10,%esp
109630: f6 45 e0 01 testb $0x1,-0x20(%ebp)
109634: 74 17 je 10964d <rtems_termios_rxdaemon+0x3e><== ALWAYS TAKEN
tty->rxTaskId = 0;
109636: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED
10963d: 00 00 00
rtems_task_delete(RTEMS_SELF);
109640: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109643: 6a 00 push $0x0 <== NOT EXECUTED
109645: e8 32 0e 00 00 call 10a47c <rtems_task_delete> <== NOT EXECUTED
10964a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
10964d: 83 ec 0c sub $0xc,%esp
109650: ff 73 10 pushl 0x10(%ebx)
109653: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (c != EOF) {
109659: 83 c4 10 add $0x10,%esp
10965c: 83 f8 ff cmp $0xffffffff,%eax
10965f: 74 c0 je 109621 <rtems_termios_rxdaemon+0x12>
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
109661: 88 45 e7 mov %al,-0x19(%ebp)
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
109664: 50 push %eax
109665: 6a 01 push $0x1
109667: 56 push %esi
109668: 53 push %ebx
109669: e8 16 fd ff ff call 109384 <rtems_termios_enqueue_raw_characters>
10966e: 83 c4 10 add $0x10,%esp
109671: eb ae jmp 109621 <rtems_termios_rxdaemon+0x12>
0010b0f4 <rtems_termios_set_initial_baud>:
int rtems_termios_set_initial_baud(
struct rtems_termios_tty *ttyp,
int32_t baud
)
{
10b0f4: 55 push %ebp <== NOT EXECUTED
10b0f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10b0f7: 53 push %ebx <== NOT EXECUTED
10b0f8: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
10b0fb: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
int cflags_baud;
cflags_baud = rtems_termios_number_to_baud(baud);
10b0fe: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10b101: e8 c6 e6 ff ff call 1097cc <rtems_termios_number_to_baud><== NOT EXECUTED
10b106: 89 c1 mov %eax,%ecx <== NOT EXECUTED
if ( cflags_baud == -1 )
10b108: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return -1;
10b10b: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
)
{
int cflags_baud;
cflags_baud = rtems_termios_number_to_baud(baud);
if ( cflags_baud == -1 )
10b10e: 83 f9 ff cmp $0xffffffff,%ecx <== NOT EXECUTED
10b111: 74 10 je 10b123 <rtems_termios_set_initial_baud+0x2f><== NOT EXECUTED
return -1;
ttyp->termios.c_cflag = (ttyp->termios.c_cflag & ~CBAUD) | cflags_baud;
10b113: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED
10b116: 81 e2 f0 ef ff ff and $0xffffeff0,%edx <== NOT EXECUTED
10b11c: 09 ca or %ecx,%edx <== NOT EXECUTED
10b11e: 89 53 38 mov %edx,0x38(%ebx) <== NOT EXECUTED
return 0;
10b121: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
10b123: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10b126: c9 leave <== NOT EXECUTED
10b127: c3 ret <== NOT EXECUTED
00109841 <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
109841: 55 push %ebp
109842: 89 e5 mov %esp,%ebp
109844: 56 push %esi
109845: 53 push %ebx
109846: 83 ec 10 sub $0x10,%esp
109849: 8b 5d 08 mov 0x8(%ebp),%ebx
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
10984c: 8d 75 f4 lea -0xc(%ebp),%esi
10984f: 56 push %esi
109850: 6a 00 push $0x0
109852: 6a 02 push $0x2
109854: 6a 03 push $0x3
109856: e8 a5 03 00 00 call 109c00 <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) {
10985b: 83 c4 10 add $0x10,%esp
10985e: f6 45 f4 01 testb $0x1,-0xc(%ebp)
109862: 74 17 je 10987b <rtems_termios_txdaemon+0x3a><== ALWAYS TAKEN
tty->txTaskId = 0;
109864: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED
10986b: 00 00 00
rtems_task_delete(RTEMS_SELF);
10986e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109871: 6a 00 push $0x0 <== NOT EXECUTED
109873: e8 04 0c 00 00 call 10a47c <rtems_task_delete> <== NOT EXECUTED
109878: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
10987b: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
109881: c1 e0 05 shl $0x5,%eax
109884: 8b 80 a8 3d 12 00 mov 0x123da8(%eax),%eax
10988a: 85 c0 test %eax,%eax
10988c: 74 09 je 109897 <rtems_termios_txdaemon+0x56><== ALWAYS TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
10988e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109891: 53 push %ebx <== NOT EXECUTED
109892: ff d0 call *%eax <== NOT EXECUTED
109894: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
109897: 83 ec 0c sub $0xc,%esp
10989a: 53 push %ebx
10989b: e8 d3 fd ff ff call 109673 <rtems_termios_refill_transmitter>
}
1098a0: 83 c4 10 add $0x10,%esp
1098a3: eb aa jmp 10984f <rtems_termios_txdaemon+0xe>
00108fe3 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
108fe3: 55 push %ebp
108fe4: 89 e5 mov %esp,%ebp
108fe6: 57 push %edi
108fe7: 56 push %esi
108fe8: 53 push %ebx
108fe9: 83 ec 20 sub $0x20,%esp
108fec: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
108fef: 8b 03 mov (%ebx),%eax
108ff1: 8b 70 34 mov 0x34(%eax),%esi
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108ff4: 6a 00 push $0x0
108ff6: 6a 00 push $0x0
108ff8: ff 76 18 pushl 0x18(%esi)
108ffb: e8 c8 11 00 00 call 10a1c8 <rtems_semaphore_obtain>
109000: 89 c7 mov %eax,%edi
if (sc != RTEMS_SUCCESSFUL)
109002: 83 c4 10 add $0x10,%esp
109005: 85 c0 test %eax,%eax
109007: 75 77 jne 109080 <rtems_termios_write+0x9d><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
109009: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax
10900f: c1 e0 05 shl $0x5,%eax
109012: 8b 80 a0 3d 12 00 mov 0x123da0(%eax),%eax
109018: 85 c0 test %eax,%eax
10901a: 74 0b je 109027 <rtems_termios_write+0x44>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
10901c: 57 push %edi
10901d: 57 push %edi
10901e: 53 push %ebx
10901f: 56 push %esi
109020: ff d0 call *%eax
109022: 89 c7 mov %eax,%edi
rtems_semaphore_release (tty->osem);
109024: 5b pop %ebx
109025: eb 4e jmp 109075 <rtems_termios_write+0x92>
return sc;
}
if (tty->termios.c_oflag & OPOST) {
109027: f6 46 34 01 testb $0x1,0x34(%esi)
10902b: 74 2f je 10905c <rtems_termios_write+0x79><== NEVER TAKEN
uint32_t count = args->count;
10902d: 8b 4b 10 mov 0x10(%ebx),%ecx
char *buffer = args->buffer;
109030: 8b 43 0c mov 0xc(%ebx),%eax
109033: 89 45 e4 mov %eax,-0x1c(%ebp)
while (count--)
109036: eb 18 jmp 109050 <rtems_termios_write+0x6d>
oproc (*buffer++, tty);
109038: 8b 55 e4 mov -0x1c(%ebp),%edx
10903b: 0f b6 02 movzbl (%edx),%eax
10903e: 42 inc %edx
10903f: 89 55 e4 mov %edx,-0x1c(%ebp)
109042: 89 f2 mov %esi,%edx
109044: 89 4d e0 mov %ecx,-0x20(%ebp)
109047: e8 37 fb ff ff call 108b83 <oproc>
10904c: 8b 4d e0 mov -0x20(%ebp),%ecx
10904f: 49 dec %ecx
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
109050: 85 c9 test %ecx,%ecx
109052: 75 e4 jne 109038 <rtems_termios_write+0x55>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
109054: 8b 43 10 mov 0x10(%ebx),%eax
109057: 89 43 18 mov %eax,0x18(%ebx)
10905a: eb 16 jmp 109072 <rtems_termios_write+0x8f>
} else {
rtems_termios_puts (args->buffer, args->count, tty);
10905c: 51 push %ecx <== NOT EXECUTED
10905d: 56 push %esi <== NOT EXECUTED
10905e: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109061: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED
109064: e8 fa f9 ff ff call 108a63 <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
109069: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
10906c: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED
10906f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
rtems_semaphore_release (tty->osem);
109072: 83 ec 0c sub $0xc,%esp
109075: ff 76 18 pushl 0x18(%esi)
109078: e8 37 12 00 00 call 10a2b4 <rtems_semaphore_release>
return sc;
10907d: 83 c4 10 add $0x10,%esp
}
109080: 89 f8 mov %edi,%eax
109082: 8d 65 f4 lea -0xc(%ebp),%esp
109085: 5b pop %ebx
109086: 5e pop %esi
109087: 5f pop %edi
109088: c9 leave
109089: c3 ret
00116498 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
116498: 55 push %ebp
116499: 89 e5 mov %esp,%ebp
11649b: 83 ec 1c sub $0x1c,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
11649e: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
1164a1: 50 push %eax
1164a2: ff 75 08 pushl 0x8(%ebp)
1164a5: 68 04 ef 13 00 push $0x13ef04
1164aa: e8 35 27 00 00 call 118be4 <_Objects_Get>
switch ( location ) {
1164af: 83 c4 10 add $0x10,%esp
1164b2: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
1164b6: 75 1e jne 1164d6 <rtems_timer_cancel+0x3e>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
1164b8: 83 78 38 04 cmpl $0x4,0x38(%eax)
1164bc: 74 0f je 1164cd <rtems_timer_cancel+0x35><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
1164be: 83 ec 0c sub $0xc,%esp
1164c1: 83 c0 10 add $0x10,%eax
1164c4: 50 push %eax
1164c5: e8 36 41 00 00 call 11a600 <_Watchdog_Remove>
1164ca: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
1164cd: e8 ec 2e 00 00 call 1193be <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1164d2: 31 c0 xor %eax,%eax
1164d4: eb 05 jmp 1164db <rtems_timer_cancel+0x43>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1164d6: b8 04 00 00 00 mov $0x4,%eax
}
1164db: c9 leave
1164dc: c3 ret
001168f8 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
1168f8: 55 push %ebp
1168f9: 89 e5 mov %esp,%ebp
1168fb: 57 push %edi
1168fc: 56 push %esi
1168fd: 53 push %ebx
1168fe: 83 ec 1c sub $0x1c,%esp
116901: 8b 7d 0c mov 0xc(%ebp),%edi
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
116904: 8b 35 44 ef 13 00 mov 0x13ef44,%esi
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
11690a: 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 )
11690f: 85 f6 test %esi,%esi
116911: 0f 84 b1 00 00 00 je 1169c8 <rtems_timer_server_fire_when+0xd0>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
116917: b3 0b mov $0xb,%bl
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
116919: 80 3d cc e5 13 00 00 cmpb $0x0,0x13e5cc
116920: 0f 84 a2 00 00 00 je 1169c8 <rtems_timer_server_fire_when+0xd0><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
116926: b3 09 mov $0x9,%bl
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
116928: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
11692c: 0f 84 96 00 00 00 je 1169c8 <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
116932: 83 ec 0c sub $0xc,%esp
116935: 57 push %edi
116936: e8 99 d6 ff ff call 113fd4 <_TOD_Validate>
11693b: 83 c4 10 add $0x10,%esp
return RTEMS_INVALID_CLOCK;
11693e: b3 14 mov $0x14,%bl
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
116940: 84 c0 test %al,%al
116942: 0f 84 80 00 00 00 je 1169c8 <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
116948: 83 ec 0c sub $0xc,%esp
11694b: 57 push %edi
11694c: e8 1b d6 ff ff call 113f6c <_TOD_To_seconds>
116951: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
116953: 83 c4 10 add $0x10,%esp
116956: 3b 05 44 e6 13 00 cmp 0x13e644,%eax
11695c: 76 6a jbe 1169c8 <rtems_timer_server_fire_when+0xd0>
11695e: 51 push %ecx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
11695f: 8d 45 e4 lea -0x1c(%ebp),%eax
116962: 50 push %eax
116963: ff 75 08 pushl 0x8(%ebp)
116966: 68 04 ef 13 00 push $0x13ef04
11696b: e8 74 22 00 00 call 118be4 <_Objects_Get>
116970: 89 c3 mov %eax,%ebx
switch ( location ) {
116972: 83 c4 10 add $0x10,%esp
116975: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
116979: 75 48 jne 1169c3 <rtems_timer_server_fire_when+0xcb>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
11697b: 83 ec 0c sub $0xc,%esp
11697e: 8d 40 10 lea 0x10(%eax),%eax
116981: 50 push %eax
116982: e8 79 3c 00 00 call 11a600 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
116987: 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;
11698e: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
the_watchdog->routine = routine;
116995: 8b 45 10 mov 0x10(%ebp),%eax
116998: 89 43 2c mov %eax,0x2c(%ebx)
the_watchdog->id = id;
11699b: 8b 45 08 mov 0x8(%ebp),%eax
11699e: 89 43 30 mov %eax,0x30(%ebx)
the_watchdog->user_data = user_data;
1169a1: 8b 45 14 mov 0x14(%ebp),%eax
1169a4: 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();
1169a7: 2b 3d 44 e6 13 00 sub 0x13e644,%edi
1169ad: 89 7b 1c mov %edi,0x1c(%ebx)
(*timer_server->schedule_operation)( timer_server, the_timer );
1169b0: 58 pop %eax
1169b1: 5a pop %edx
1169b2: 53 push %ebx
1169b3: 56 push %esi
1169b4: ff 56 04 call *0x4(%esi)
_Thread_Enable_dispatch();
1169b7: e8 02 2a 00 00 call 1193be <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1169bc: 83 c4 10 add $0x10,%esp
1169bf: 31 db xor %ebx,%ebx
1169c1: eb 05 jmp 1169c8 <rtems_timer_server_fire_when+0xd0>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1169c3: bb 04 00 00 00 mov $0x4,%ebx
}
1169c8: 89 d8 mov %ebx,%eax
1169ca: 8d 65 f4 lea -0xc(%ebp),%esp
1169cd: 5b pop %ebx
1169ce: 5e pop %esi
1169cf: 5f pop %edi
1169d0: c9 leave
1169d1: c3 ret
0010b0a1 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
10b0a1: 55 push %ebp
10b0a2: 89 e5 mov %esp,%ebp
10b0a4: 57 push %edi
10b0a5: 56 push %esi
10b0a6: 53 push %ebx
10b0a7: 83 ec 1c sub $0x1c,%esp
10b0aa: 89 c3 mov %eax,%ebx
10b0ac: 89 55 e4 mov %edx,-0x1c(%ebp)
10b0af: 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) {
10b0b2: a9 00 00 00 20 test $0x20000000,%eax
10b0b7: 74 2c je 10b0e5 <rtems_verror+0x44>
if (rtems_panic_in_progress++)
10b0b9: a1 08 a2 12 00 mov 0x12a208,%eax
10b0be: 8d 50 01 lea 0x1(%eax),%edx
10b0c1: 89 15 08 a2 12 00 mov %edx,0x12a208
10b0c7: 85 c0 test %eax,%eax
10b0c9: 74 0b je 10b0d6 <rtems_verror+0x35> <== ALWAYS TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b0cb: a1 58 a3 12 00 mov 0x12a358,%eax <== NOT EXECUTED
10b0d0: 40 inc %eax <== NOT EXECUTED
10b0d1: a3 58 a3 12 00 mov %eax,0x12a358 <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
10b0d6: 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)
10b0d8: 83 3d 08 a2 12 00 02 cmpl $0x2,0x12a208
10b0df: 0f 8f da 00 00 00 jg 10b1bf <rtems_verror+0x11e> <== NEVER TAKEN
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
10b0e5: 83 ec 0c sub $0xc,%esp
10b0e8: a1 a0 80 12 00 mov 0x1280a0,%eax
10b0ed: ff 70 08 pushl 0x8(%eax)
10b0f0: e8 93 ac 00 00 call 115d88 <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
10b0f5: 89 df mov %ebx,%edi
10b0f7: 81 e7 ff ff ff 8f and $0x8fffffff,%edi
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
10b0fd: 83 c4 10 add $0x10,%esp
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
10b100: 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? */
10b102: 81 e3 00 00 00 40 and $0x40000000,%ebx
10b108: 74 07 je 10b111 <rtems_verror+0x70>
local_errno = errno;
10b10a: e8 e1 a8 00 00 call 1159f0 <__errno>
10b10f: 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);
10b111: 53 push %ebx
10b112: ff 75 e0 pushl -0x20(%ebp)
10b115: ff 75 e4 pushl -0x1c(%ebp)
10b118: a1 a0 80 12 00 mov 0x1280a0,%eax
10b11d: ff 70 0c pushl 0xc(%eax)
10b120: e8 e7 09 01 00 call 11bb0c <vfprintf>
10b125: 89 c3 mov %eax,%ebx
if (status)
10b127: 83 c4 10 add $0x10,%esp
10b12a: 85 ff test %edi,%edi
10b12c: 74 24 je 10b152 <rtems_verror+0xb1>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
10b12e: 83 ec 0c sub $0xc,%esp
10b131: 57 push %edi
10b132: e8 55 ff ff ff call 10b08c <rtems_status_text>
10b137: 83 c4 0c add $0xc,%esp
10b13a: 50 push %eax
10b13b: 68 9f 3d 12 00 push $0x123d9f
10b140: a1 a0 80 12 00 mov 0x1280a0,%eax
10b145: ff 70 0c pushl 0xc(%eax)
10b148: e8 2f b0 00 00 call 11617c <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
10b14d: 01 c3 add %eax,%ebx
10b14f: 83 c4 10 add $0x10,%esp
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
10b152: 83 fe 00 cmp $0x0,%esi
10b155: 74 40 je 10b197 <rtems_verror+0xf6>
if ((local_errno > 0) && *strerror(local_errno))
10b157: 7e 25 jle 10b17e <rtems_verror+0xdd>
10b159: 83 ec 0c sub $0xc,%esp
10b15c: 56 push %esi
10b15d: e8 be b7 00 00 call 116920 <strerror>
10b162: 83 c4 10 add $0x10,%esp
10b165: 80 38 00 cmpb $0x0,(%eax)
10b168: 74 14 je 10b17e <rtems_verror+0xdd> <== NEVER TAKEN
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
10b16a: 83 ec 0c sub $0xc,%esp
10b16d: 56 push %esi
10b16e: e8 ad b7 00 00 call 116920 <strerror>
10b173: 83 c4 0c add $0xc,%esp
10b176: 50 push %eax
10b177: 68 ad 3d 12 00 push $0x123dad
10b17c: eb 07 jmp 10b185 <rtems_verror+0xe4>
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
10b17e: 51 push %ecx
10b17f: 56 push %esi
10b180: 68 ba 3d 12 00 push $0x123dba
10b185: a1 a0 80 12 00 mov 0x1280a0,%eax
10b18a: ff 70 0c pushl 0xc(%eax)
10b18d: e8 ea af 00 00 call 11617c <fprintf>
10b192: 01 c3 add %eax,%ebx
10b194: 83 c4 10 add $0x10,%esp
}
chars_written += fprintf(stderr, "\n");
10b197: 52 push %edx
10b198: 52 push %edx
10b199: 68 b8 44 12 00 push $0x1244b8
10b19e: a1 a0 80 12 00 mov 0x1280a0,%eax
10b1a3: ff 70 0c pushl 0xc(%eax)
10b1a6: e8 d1 af 00 00 call 11617c <fprintf>
10b1ab: 8d 34 18 lea (%eax,%ebx,1),%esi
(void) fflush(stderr);
10b1ae: 58 pop %eax
10b1af: a1 a0 80 12 00 mov 0x1280a0,%eax
10b1b4: ff 70 0c pushl 0xc(%eax)
10b1b7: e8 cc ab 00 00 call 115d88 <fflush>
return chars_written;
10b1bc: 83 c4 10 add $0x10,%esp
}
10b1bf: 89 f0 mov %esi,%eax
10b1c1: 8d 65 f4 lea -0xc(%ebp),%esp
10b1c4: 5b pop %ebx
10b1c5: 5e pop %esi
10b1c6: 5f pop %edi
10b1c7: c9 leave
10b1c8: c3 ret
001078e4 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
1078e4: 55 push %ebp
1078e5: 89 e5 mov %esp,%ebp
1078e7: 57 push %edi
1078e8: 56 push %esi
1078e9: 53 push %ebx
1078ea: 83 ec 3c sub $0x3c,%esp
1078ed: 89 c3 mov %eax,%ebx
1078ef: 89 55 e0 mov %edx,-0x20(%ebp)
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
int sign = 0;
1078f2: 31 f6 xor %esi,%esi
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
1078f4: c7 45 e4 ff ff ff 7f movl $0x7fffffff,-0x1c(%ebp)
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
1078fb: 31 ff xor %edi,%edi
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
1078fd: 89 7d c4 mov %edi,-0x3c(%ebp)
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
107900: 8b 43 04 mov 0x4(%ebx),%eax
107903: 48 dec %eax
107904: 89 43 04 mov %eax,0x4(%ebx)
107907: 85 c0 test %eax,%eax
107909: 79 15 jns 107920 <scanInt+0x3c> <== ALWAYS TAKEN
10790b: 50 push %eax <== NOT EXECUTED
10790c: 50 push %eax <== NOT EXECUTED
10790d: 53 push %ebx <== NOT EXECUTED
10790e: ff 35 20 40 12 00 pushl 0x124020 <== NOT EXECUTED
107914: e8 db bf 00 00 call 1138f4 <__srget_r> <== NOT EXECUTED
107919: 89 c1 mov %eax,%ecx <== NOT EXECUTED
10791b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10791e: eb 08 jmp 107928 <scanInt+0x44> <== NOT EXECUTED
107920: 8b 03 mov (%ebx),%eax
107922: 0f b6 08 movzbl (%eax),%ecx
107925: 40 inc %eax
107926: 89 03 mov %eax,(%ebx)
if (c == ':')
107928: 83 f9 3a cmp $0x3a,%ecx
10792b: 74 4a je 107977 <scanInt+0x93>
break;
if (sign == 0) {
10792d: 85 f6 test %esi,%esi
10792f: 75 11 jne 107942 <scanInt+0x5e>
if (c == '-') {
sign = -1;
limit++;
continue;
}
sign = 1;
107931: 66 be 01 00 mov $0x1,%si
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
107935: 83 f9 2d cmp $0x2d,%ecx
107938: 75 08 jne 107942 <scanInt+0x5e>
sign = -1;
limit++;
10793a: ff 45 e4 incl -0x1c(%ebp)
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
10793d: 83 ce ff or $0xffffffff,%esi
limit++;
continue;
107940: eb be jmp 107900 <scanInt+0x1c>
}
sign = 1;
}
if (!isdigit(c))
107942: a1 0c 40 12 00 mov 0x12400c,%eax
107947: f6 44 08 01 04 testb $0x4,0x1(%eax,%ecx,1)
10794c: 74 41 je 10798f <scanInt+0xab>
return 0;
d = c - '0';
if ((i > (limit / 10))
10794e: 8b 45 e4 mov -0x1c(%ebp),%eax
107951: bf 0a 00 00 00 mov $0xa,%edi
107956: 31 d2 xor %edx,%edx
107958: f7 f7 div %edi
10795a: 89 55 d4 mov %edx,-0x2c(%ebp)
10795d: 39 45 c4 cmp %eax,-0x3c(%ebp)
107960: 77 2d ja 10798f <scanInt+0xab> <== NEVER TAKEN
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
107962: 83 e9 30 sub $0x30,%ecx
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
107965: 39 45 c4 cmp %eax,-0x3c(%ebp)
107968: 75 04 jne 10796e <scanInt+0x8a> <== ALWAYS TAKEN
10796a: 39 d1 cmp %edx,%ecx <== NOT EXECUTED
10796c: 77 21 ja 10798f <scanInt+0xab> <== NOT EXECUTED
return 0;
i = i * 10 + d;
10796e: 6b 7d c4 0a imul $0xa,-0x3c(%ebp),%edi
107972: 8d 3c 39 lea (%ecx,%edi,1),%edi
107975: eb 86 jmp 1078fd <scanInt+0x19>
107977: 8b 7d c4 mov -0x3c(%ebp),%edi
}
if (sign == 0)
return 0;
10797a: 31 c0 xor %eax,%eax
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
10797c: 85 f6 test %esi,%esi
10797e: 74 11 je 107991 <scanInt+0xad> <== NEVER TAKEN
return 0;
*val = i * sign;
107980: 0f af f7 imul %edi,%esi
107983: 8b 45 e0 mov -0x20(%ebp),%eax
107986: 89 30 mov %esi,(%eax)
return 1;
107988: b8 01 00 00 00 mov $0x1,%eax
10798d: eb 02 jmp 107991 <scanInt+0xad>
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
10798f: 31 c0 xor %eax,%eax
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
107991: 8d 65 f4 lea -0xc(%ebp),%esp
107994: 5b pop %ebx
107995: 5e pop %esi
107996: 5f pop %edi
107997: c9 leave
107998: c3 ret
00107999 <scanString>:
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
107999: 55 push %ebp
10799a: 89 e5 mov %esp,%ebp
10799c: 57 push %edi
10799d: 56 push %esi
10799e: 53 push %ebx
10799f: 83 ec 1c sub $0x1c,%esp
1079a2: 89 c3 mov %eax,%ebx
1079a4: 89 ce mov %ecx,%esi
1079a6: 8b 7d 08 mov 0x8(%ebp),%edi
1079a9: 8b 4d 0c mov 0xc(%ebp),%ecx
int c;
*name = *bufp;
1079ac: 8b 06 mov (%esi),%eax
1079ae: 89 02 mov %eax,(%edx)
for (;;) {
c = getc(fp);
1079b0: 8b 43 04 mov 0x4(%ebx),%eax
1079b3: 48 dec %eax
1079b4: 89 43 04 mov %eax,0x4(%ebx)
1079b7: 85 c0 test %eax,%eax
1079b9: 79 19 jns 1079d4 <scanString+0x3b>
1079bb: 52 push %edx
1079bc: 52 push %edx
1079bd: 53 push %ebx
1079be: ff 35 20 40 12 00 pushl 0x124020
1079c4: 89 4d e4 mov %ecx,-0x1c(%ebp)
1079c7: e8 28 bf 00 00 call 1138f4 <__srget_r>
1079cc: 83 c4 10 add $0x10,%esp
1079cf: 8b 4d e4 mov -0x1c(%ebp),%ecx
1079d2: eb 08 jmp 1079dc <scanString+0x43>
1079d4: 8b 13 mov (%ebx),%edx
1079d6: 0f b6 02 movzbl (%edx),%eax
1079d9: 42 inc %edx
1079da: 89 13 mov %edx,(%ebx)
if (c == ':') {
1079dc: 83 f8 3a cmp $0x3a,%eax
1079df: 75 08 jne 1079e9 <scanString+0x50>
if (nlFlag)
return 0;
1079e1: 30 c0 xor %al,%al
*name = *bufp;
for (;;) {
c = getc(fp);
if (c == ':') {
if (nlFlag)
1079e3: 85 c9 test %ecx,%ecx
1079e5: 74 23 je 107a0a <scanString+0x71>
1079e7: eb 33 jmp 107a1c <scanString+0x83>
return 0;
break;
}
if (c == '\n') {
1079e9: 83 f8 0a cmp $0xa,%eax
1079ec: 75 08 jne 1079f6 <scanString+0x5d>
if (!nlFlag)
return 0;
1079ee: 30 c0 xor %al,%al
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
if (!nlFlag)
1079f0: 85 c9 test %ecx,%ecx
1079f2: 75 16 jne 107a0a <scanString+0x71>
1079f4: eb 26 jmp 107a1c <scanString+0x83>
return 0;
break;
}
if (c == EOF)
1079f6: 83 f8 ff cmp $0xffffffff,%eax
1079f9: 74 1f je 107a1a <scanString+0x81>
return 0;
if (*nleft < 2)
1079fb: 83 3f 01 cmpl $0x1,(%edi)
1079fe: 76 1a jbe 107a1a <scanString+0x81> <== NEVER TAKEN
return 0;
**bufp = c;
107a00: 8b 16 mov (%esi),%edx
107a02: 88 02 mov %al,(%edx)
++(*bufp);
107a04: ff 06 incl (%esi)
--(*nleft);
107a06: ff 0f decl (%edi)
}
107a08: eb a6 jmp 1079b0 <scanString+0x17>
**bufp = '\0';
107a0a: 8b 06 mov (%esi),%eax
107a0c: c6 00 00 movb $0x0,(%eax)
++(*bufp);
107a0f: ff 06 incl (%esi)
--(*nleft);
107a11: ff 0f decl (%edi)
return 1;
107a13: b8 01 00 00 00 mov $0x1,%eax
107a18: eb 02 jmp 107a1c <scanString+0x83>
break;
}
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
107a1a: 31 c0 xor %eax,%eax
}
**bufp = '\0';
++(*bufp);
--(*nleft);
return 1;
}
107a1c: 8d 65 f4 lea -0xc(%ebp),%esp
107a1f: 5b pop %ebx
107a20: 5e pop %esi
107a21: 5f pop %edi
107a22: c9 leave
107a23: c3 ret
00107a24 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
107a24: 55 push %ebp
107a25: 89 e5 mov %esp,%ebp
107a27: 57 push %edi
107a28: 56 push %esi
107a29: 53 push %ebx
107a2a: 83 ec 34 sub $0x34,%esp
107a2d: 89 c7 mov %eax,%edi
107a2f: 89 d3 mov %edx,%ebx
107a31: 89 4d d4 mov %ecx,-0x2c(%ebp)
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
107a34: 6a 00 push $0x0
107a36: 8d 45 08 lea 0x8(%ebp),%eax
107a39: 50 push %eax
107a3a: 8d 4d d4 lea -0x2c(%ebp),%ecx
107a3d: 89 f8 mov %edi,%eax
107a3f: e8 55 ff ff ff call 107999 <scanString>
107a44: 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;
107a47: 31 f6 xor %esi,%esi
{
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
107a49: 85 c0 test %eax,%eax
107a4b: 0f 84 c2 00 00 00 je 107b13 <scangr+0xef>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
107a51: 50 push %eax
107a52: 50 push %eax
107a53: 8d 53 04 lea 0x4(%ebx),%edx
107a56: 6a 00 push $0x0
107a58: 8d 45 08 lea 0x8(%ebp),%eax
107a5b: 50 push %eax
107a5c: 8d 4d d4 lea -0x2c(%ebp),%ecx
107a5f: 89 f8 mov %edi,%eax
107a61: e8 33 ff ff ff call 107999 <scanString>
107a66: 83 c4 10 add $0x10,%esp
107a69: 85 c0 test %eax,%eax
107a6b: 0f 84 a2 00 00 00 je 107b13 <scangr+0xef> <== NEVER TAKEN
|| !scanInt(fp, &grgid)
107a71: 8d 55 e4 lea -0x1c(%ebp),%edx
107a74: 89 f8 mov %edi,%eax
107a76: e8 69 fe ff ff call 1078e4 <scanInt>
107a7b: 85 c0 test %eax,%eax
107a7d: 0f 84 90 00 00 00 je 107b13 <scangr+0xef> <== NEVER TAKEN
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
107a83: 51 push %ecx
107a84: 51 push %ecx
107a85: 8d 55 e0 lea -0x20(%ebp),%edx
107a88: 6a 01 push $0x1
107a8a: 8d 45 08 lea 0x8(%ebp),%eax
107a8d: 50 push %eax
107a8e: 8d 4d d4 lea -0x2c(%ebp),%ecx
107a91: 89 f8 mov %edi,%eax
107a93: e8 01 ff ff ff call 107999 <scanString>
107a98: 83 c4 10 add $0x10,%esp
107a9b: 85 c0 test %eax,%eax
107a9d: 74 74 je 107b13 <scangr+0xef> <== NEVER TAKEN
return 0;
grp->gr_gid = grgid;
107a9f: 8b 45 e4 mov -0x1c(%ebp),%eax
107aa2: 66 89 43 08 mov %ax,0x8(%ebx)
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107aa6: 8b 4d e0 mov -0x20(%ebp),%ecx
107aa9: 89 ca mov %ecx,%edx
107aab: b8 01 00 00 00 mov $0x1,%eax
107ab0: 89 c6 mov %eax,%esi
107ab2: eb 0b jmp 107abf <scangr+0x9b>
if(*cp == ',')
memcount++;
107ab4: 3c 2c cmp $0x2c,%al
107ab6: 0f 94 c0 sete %al
107ab9: 0f b6 c0 movzbl %al,%eax
107abc: 01 c6 add %eax,%esi
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107abe: 42 inc %edx
107abf: 8a 02 mov (%edx),%al
107ac1: 84 c0 test %al,%al
107ac3: 75 ef jne 107ab4 <scangr+0x90>
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
107ac5: 8d 04 b5 13 00 00 00 lea 0x13(,%esi,4),%eax
return 0;
107acc: 31 f6 xor %esi,%esi
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
107ace: 39 45 08 cmp %eax,0x8(%ebp)
107ad1: 72 40 jb 107b13 <scangr+0xef> <== NEVER TAKEN
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
107ad3: 8b 45 d4 mov -0x2c(%ebp),%eax
107ad6: 83 c0 0f add $0xf,%eax
107ad9: 83 e0 f0 and $0xfffffff0,%eax
107adc: 89 43 0c mov %eax,0xc(%ebx)
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
107adf: 89 08 mov %ecx,(%eax)
}
/*
* Extract a single group record from the database
*/
static int scangr(
107ae1: 8b 45 e0 mov -0x20(%ebp),%eax
107ae4: 40 inc %eax
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107ae5: ba 01 00 00 00 mov $0x1,%edx
107aea: eb 11 jmp 107afd <scangr+0xd9>
if(*cp == ',') {
107aec: 80 f9 2c cmp $0x2c,%cl
107aef: 75 0b jne 107afc <scangr+0xd8>
*cp = '\0';
107af1: c6 40 ff 00 movb $0x0,-0x1(%eax)
grp->gr_mem[memcount++] = cp + 1;
107af5: 8b 4b 0c mov 0xc(%ebx),%ecx
107af8: 89 04 91 mov %eax,(%ecx,%edx,4)
107afb: 42 inc %edx
107afc: 40 inc %eax
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107afd: 8a 48 ff mov -0x1(%eax),%cl
107b00: 84 c9 test %cl,%cl
107b02: 75 e8 jne 107aec <scangr+0xc8>
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
107b04: 8b 43 0c mov 0xc(%ebx),%eax
107b07: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4)
return 1;
107b0e: be 01 00 00 00 mov $0x1,%esi
}
107b13: 89 f0 mov %esi,%eax
107b15: 8d 65 f4 lea -0xc(%ebp),%esp
107b18: 5b pop %ebx
107b19: 5e pop %esi
107b1a: 5f pop %edi
107b1b: c9 leave
107b1c: c3 ret
00107b1d <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
107b1d: 55 push %ebp
107b1e: 89 e5 mov %esp,%ebp
107b20: 57 push %edi
107b21: 56 push %esi
107b22: 53 push %ebx
107b23: 83 ec 34 sub $0x34,%esp
107b26: 89 c6 mov %eax,%esi
107b28: 89 d3 mov %edx,%ebx
107b2a: 89 4d d4 mov %ecx,-0x2c(%ebp)
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
107b2d: 8d 7d d4 lea -0x2c(%ebp),%edi
107b30: 6a 00 push $0x0
107b32: 8d 45 08 lea 0x8(%ebp),%eax
107b35: 50 push %eax
107b36: 89 f9 mov %edi,%ecx
107b38: 89 f0 mov %esi,%eax
107b3a: e8 5a fe ff ff call 107999 <scanString>
107b3f: 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;
107b42: 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)
107b49: 85 c0 test %eax,%eax
107b4b: 0f 84 c4 00 00 00 je 107c15 <scanpw+0xf8>
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
107b51: 51 push %ecx
107b52: 51 push %ecx
107b53: 8d 53 04 lea 0x4(%ebx),%edx
107b56: 6a 00 push $0x0
107b58: 8d 45 08 lea 0x8(%ebp),%eax
107b5b: 50 push %eax
107b5c: 89 f9 mov %edi,%ecx
107b5e: 89 f0 mov %esi,%eax
107b60: e8 34 fe ff ff call 107999 <scanString>
107b65: 83 c4 10 add $0x10,%esp
107b68: 85 c0 test %eax,%eax
107b6a: 0f 84 a5 00 00 00 je 107c15 <scanpw+0xf8> <== NEVER TAKEN
|| !scanInt(fp, &pwuid)
107b70: 8d 55 e4 lea -0x1c(%ebp),%edx
107b73: 89 f0 mov %esi,%eax
107b75: e8 6a fd ff ff call 1078e4 <scanInt>
107b7a: 85 c0 test %eax,%eax
107b7c: 0f 84 93 00 00 00 je 107c15 <scanpw+0xf8> <== NEVER TAKEN
|| !scanInt(fp, &pwgid)
107b82: 8d 55 e0 lea -0x20(%ebp),%edx
107b85: 89 f0 mov %esi,%eax
107b87: e8 58 fd ff ff call 1078e4 <scanInt>
107b8c: 85 c0 test %eax,%eax
107b8e: 0f 84 81 00 00 00 je 107c15 <scanpw+0xf8>
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
107b94: 52 push %edx
107b95: 52 push %edx
107b96: 8d 53 0c lea 0xc(%ebx),%edx
107b99: 6a 00 push $0x0
107b9b: 8d 45 08 lea 0x8(%ebp),%eax
107b9e: 50 push %eax
107b9f: 89 f9 mov %edi,%ecx
107ba1: 89 f0 mov %esi,%eax
107ba3: e8 f1 fd ff ff call 107999 <scanString>
107ba8: 83 c4 10 add $0x10,%esp
107bab: 85 c0 test %eax,%eax
107bad: 74 66 je 107c15 <scanpw+0xf8> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
107baf: 50 push %eax
107bb0: 50 push %eax
107bb1: 8d 53 10 lea 0x10(%ebx),%edx
107bb4: 6a 00 push $0x0
107bb6: 8d 45 08 lea 0x8(%ebp),%eax
107bb9: 50 push %eax
107bba: 89 f9 mov %edi,%ecx
107bbc: 89 f0 mov %esi,%eax
107bbe: e8 d6 fd ff ff call 107999 <scanString>
107bc3: 83 c4 10 add $0x10,%esp
107bc6: 85 c0 test %eax,%eax
107bc8: 74 4b je 107c15 <scanpw+0xf8> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
107bca: 51 push %ecx
107bcb: 51 push %ecx
107bcc: 8d 53 14 lea 0x14(%ebx),%edx
107bcf: 6a 00 push $0x0
107bd1: 8d 45 08 lea 0x8(%ebp),%eax
107bd4: 50 push %eax
107bd5: 89 f9 mov %edi,%ecx
107bd7: 89 f0 mov %esi,%eax
107bd9: e8 bb fd ff ff call 107999 <scanString>
107bde: 83 c4 10 add $0x10,%esp
107be1: 85 c0 test %eax,%eax
107be3: 74 30 je 107c15 <scanpw+0xf8> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
107be5: 52 push %edx
107be6: 52 push %edx
107be7: 8d 53 18 lea 0x18(%ebx),%edx
107bea: 6a 01 push $0x1
107bec: 8d 45 08 lea 0x8(%ebp),%eax
107bef: 50 push %eax
107bf0: 89 f9 mov %edi,%ecx
107bf2: 89 f0 mov %esi,%eax
107bf4: e8 a0 fd ff ff call 107999 <scanString>
107bf9: 83 c4 10 add $0x10,%esp
107bfc: 85 c0 test %eax,%eax
107bfe: 74 15 je 107c15 <scanpw+0xf8>
return 0;
pwd->pw_uid = pwuid;
107c00: 8b 45 e4 mov -0x1c(%ebp),%eax
107c03: 66 89 43 08 mov %ax,0x8(%ebx)
pwd->pw_gid = pwgid;
107c07: 8b 45 e0 mov -0x20(%ebp),%eax
107c0a: 66 89 43 0a mov %ax,0xa(%ebx)
return 1;
107c0e: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp)
}
107c15: 8b 45 d0 mov -0x30(%ebp),%eax
107c18: 8d 65 f4 lea -0xc(%ebp),%esp
107c1b: 5b pop %ebx
107c1c: 5e pop %esi
107c1d: 5f pop %edi
107c1e: c9 leave
107c1f: c3 ret
0010a948 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
10a948: 55 push %ebp
10a949: 89 e5 mov %esp,%ebp
10a94b: 83 ec 08 sub $0x8,%esp
10a94e: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a951: 83 f9 04 cmp $0x4,%ecx
10a954: 77 0b ja 10a961 <sched_get_priority_max+0x19>
10a956: b8 01 00 00 00 mov $0x1,%eax
10a95b: d3 e0 shl %cl,%eax
10a95d: a8 17 test $0x17,%al
10a95f: 75 10 jne 10a971 <sched_get_priority_max+0x29><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a961: e8 f2 73 00 00 call 111d58 <__errno>
10a966: c7 00 16 00 00 00 movl $0x16,(%eax)
10a96c: 83 c8 ff or $0xffffffff,%eax
10a96f: eb 08 jmp 10a979 <sched_get_priority_max+0x31>
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
10a971: 0f b6 05 18 12 12 00 movzbl 0x121218,%eax
10a978: 48 dec %eax
}
10a979: c9 leave
10a97a: c3 ret
0010a97c <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
10a97c: 55 push %ebp
10a97d: 89 e5 mov %esp,%ebp
10a97f: 83 ec 08 sub $0x8,%esp
10a982: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a985: 83 f9 04 cmp $0x4,%ecx
10a988: 77 11 ja 10a99b <sched_get_priority_min+0x1f>
10a98a: ba 01 00 00 00 mov $0x1,%edx
10a98f: d3 e2 shl %cl,%edx
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
10a991: b8 01 00 00 00 mov $0x1,%eax
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
10a996: 80 e2 17 and $0x17,%dl
10a999: 75 0e jne 10a9a9 <sched_get_priority_min+0x2d><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a99b: e8 b8 73 00 00 call 111d58 <__errno>
10a9a0: c7 00 16 00 00 00 movl $0x16,(%eax)
10a9a6: 83 c8 ff or $0xffffffff,%eax
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
10a9a9: c9 leave
10a9aa: c3 ret
0010a9ac <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
10a9ac: 55 push %ebp
10a9ad: 89 e5 mov %esp,%ebp
10a9af: 56 push %esi
10a9b0: 53 push %ebx
10a9b1: 8b 75 08 mov 0x8(%ebp),%esi
10a9b4: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
10a9b7: 85 f6 test %esi,%esi
10a9b9: 74 16 je 10a9d1 <sched_rr_get_interval+0x25><== NEVER TAKEN
10a9bb: e8 fc cf ff ff call 1079bc <getpid>
10a9c0: 39 c6 cmp %eax,%esi
10a9c2: 74 0d je 10a9d1 <sched_rr_get_interval+0x25>
rtems_set_errno_and_return_minus_one( ESRCH );
10a9c4: e8 8f 73 00 00 call 111d58 <__errno>
10a9c9: c7 00 03 00 00 00 movl $0x3,(%eax)
10a9cf: eb 0f jmp 10a9e0 <sched_rr_get_interval+0x34>
if ( !interval )
10a9d1: 85 db test %ebx,%ebx
10a9d3: 75 10 jne 10a9e5 <sched_rr_get_interval+0x39>
rtems_set_errno_and_return_minus_one( EINVAL );
10a9d5: e8 7e 73 00 00 call 111d58 <__errno>
10a9da: c7 00 16 00 00 00 movl $0x16,(%eax)
10a9e0: 83 c8 ff or $0xffffffff,%eax
10a9e3: eb 13 jmp 10a9f8 <sched_rr_get_interval+0x4c>
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
10a9e5: 50 push %eax
10a9e6: 50 push %eax
10a9e7: 53 push %ebx
10a9e8: ff 35 a4 51 12 00 pushl 0x1251a4
10a9ee: e8 b5 2f 00 00 call 10d9a8 <_Timespec_From_ticks>
return 0;
10a9f3: 83 c4 10 add $0x10,%esp
10a9f6: 31 c0 xor %eax,%eax
}
10a9f8: 8d 65 f8 lea -0x8(%ebp),%esp
10a9fb: 5b pop %ebx
10a9fc: 5e pop %esi
10a9fd: c9 leave
10a9fe: c3 ret
0010d094 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
10d094: 55 push %ebp
10d095: 89 e5 mov %esp,%ebp
10d097: 57 push %edi
10d098: 56 push %esi
10d099: 53 push %ebx
10d09a: 83 ec 2c sub $0x2c,%esp
10d09d: 8b 75 08 mov 0x8(%ebp),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10d0a0: a1 cc a3 12 00 mov 0x12a3cc,%eax
10d0a5: 40 inc %eax
10d0a6: a3 cc a3 12 00 mov %eax,0x12a3cc
va_list arg;
mode_t mode;
unsigned int value = 0;
10d0ab: 31 ff xor %edi,%edi
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
10d0ad: 8b 45 0c mov 0xc(%ebp),%eax
10d0b0: 25 00 02 00 00 and $0x200,%eax
10d0b5: 89 45 d4 mov %eax,-0x2c(%ebp)
10d0b8: 74 03 je 10d0bd <sem_open+0x29>
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
10d0ba: 8b 7d 14 mov 0x14(%ebp),%edi
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
10d0bd: 52 push %edx
10d0be: 52 push %edx
10d0bf: 8d 45 e4 lea -0x1c(%ebp),%eax
10d0c2: 50 push %eax
10d0c3: 56 push %esi
10d0c4: e8 23 58 00 00 call 1128ec <_POSIX_Semaphore_Name_to_id>
10d0c9: 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 ) {
10d0cb: 83 c4 10 add $0x10,%esp
10d0ce: 85 c0 test %eax,%eax
10d0d0: 74 19 je 10d0eb <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) ) ) {
10d0d2: 83 f8 02 cmp $0x2,%eax
10d0d5: 75 06 jne 10d0dd <sem_open+0x49> <== NEVER TAKEN
10d0d7: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10d0db: 75 59 jne 10d136 <sem_open+0xa2>
_Thread_Enable_dispatch();
10d0dd: e8 6c 25 00 00 call 10f64e <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
10d0e2: e8 79 7f 00 00 call 115060 <__errno>
10d0e7: 89 18 mov %ebx,(%eax)
10d0e9: eb 1f jmp 10d10a <sem_open+0x76>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
10d0eb: 8b 45 0c mov 0xc(%ebp),%eax
10d0ee: 25 00 0a 00 00 and $0xa00,%eax
10d0f3: 3d 00 0a 00 00 cmp $0xa00,%eax
10d0f8: 75 15 jne 10d10f <sem_open+0x7b>
_Thread_Enable_dispatch();
10d0fa: e8 4f 25 00 00 call 10f64e <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
10d0ff: e8 5c 7f 00 00 call 115060 <__errno>
10d104: c7 00 11 00 00 00 movl $0x11,(%eax)
10d10a: 83 c8 ff or $0xffffffff,%eax
10d10d: eb 4a jmp 10d159 <sem_open+0xc5>
10d10f: 50 push %eax
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
10d110: 8d 45 dc lea -0x24(%ebp),%eax
10d113: 50 push %eax
10d114: ff 75 e4 pushl -0x1c(%ebp)
10d117: 68 98 a6 12 00 push $0x12a698
10d11c: e8 df 1c 00 00 call 10ee00 <_Objects_Get>
10d121: 89 45 e0 mov %eax,-0x20(%ebp)
the_semaphore->open_count += 1;
10d124: ff 40 18 incl 0x18(%eax)
_Thread_Enable_dispatch();
10d127: e8 22 25 00 00 call 10f64e <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10d12c: e8 1d 25 00 00 call 10f64e <_Thread_Enable_dispatch>
goto return_id;
10d131: 83 c4 10 add $0x10,%esp
10d134: eb 1d jmp 10d153 <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(
10d136: 8d 45 e0 lea -0x20(%ebp),%eax
10d139: 50 push %eax
10d13a: 57 push %edi
10d13b: 6a 00 push $0x0
10d13d: 56 push %esi
10d13e: e8 75 56 00 00 call 1127b8 <_POSIX_Semaphore_Create_support>
10d143: 89 c3 mov %eax,%ebx
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
10d145: e8 04 25 00 00 call 10f64e <_Thread_Enable_dispatch>
if ( status == -1 )
10d14a: 83 c4 10 add $0x10,%esp
return SEM_FAILED;
10d14d: 83 c8 ff or $0xffffffff,%eax
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
if ( status == -1 )
10d150: 43 inc %ebx
10d151: 74 06 je 10d159 <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;
10d153: 8b 45 e0 mov -0x20(%ebp),%eax
10d156: 83 c0 08 add $0x8,%eax
#endif
return id;
}
10d159: 8d 65 f4 lea -0xc(%ebp),%esp
10d15c: 5b pop %ebx
10d15d: 5e pop %esi
10d15e: 5f pop %edi
10d15f: c9 leave
10d160: c3 ret
0010a830 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
10a830: 55 push %ebp
10a831: 89 e5 mov %esp,%ebp
10a833: 57 push %edi
10a834: 56 push %esi
10a835: 53 push %ebx
10a836: 83 ec 1c sub $0x1c,%esp
10a839: 8b 5d 08 mov 0x8(%ebp),%ebx
10a83c: 8b 55 0c mov 0xc(%ebp),%edx
10a83f: 8b 45 10 mov 0x10(%ebp),%eax
ISR_Level level;
if ( oact )
10a842: 85 c0 test %eax,%eax
10a844: 74 12 je 10a858 <sigaction+0x28>
*oact = _POSIX_signals_Vectors[ sig ];
10a846: 6b f3 0c imul $0xc,%ebx,%esi
10a849: 81 c6 84 67 12 00 add $0x126784,%esi
10a84f: b9 03 00 00 00 mov $0x3,%ecx
10a854: 89 c7 mov %eax,%edi
10a856: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !sig )
10a858: 85 db test %ebx,%ebx
10a85a: 74 0d je 10a869 <sigaction+0x39>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a85c: 8d 43 ff lea -0x1(%ebx),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
10a85f: 83 f8 1f cmp $0x1f,%eax
10a862: 77 05 ja 10a869 <sigaction+0x39>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
10a864: 83 fb 09 cmp $0x9,%ebx
10a867: 75 10 jne 10a879 <sigaction+0x49>
rtems_set_errno_and_return_minus_one( EINVAL );
10a869: e8 6e 77 00 00 call 111fdc <__errno>
10a86e: c7 00 16 00 00 00 movl $0x16,(%eax)
10a874: 83 c8 ff or $0xffffffff,%eax
10a877: eb 57 jmp 10a8d0 <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;
10a879: 31 c0 xor %eax,%eax
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
10a87b: 85 d2 test %edx,%edx
10a87d: 74 51 je 10a8d0 <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 );
10a87f: 9c pushf
10a880: fa cli
10a881: 8f 45 e4 popl -0x1c(%ebp)
if ( act->sa_handler == SIG_DFL ) {
10a884: 83 7a 08 00 cmpl $0x0,0x8(%edx)
10a888: 75 1a jne 10a8a4 <sigaction+0x74>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
10a88a: 6b f3 0c imul $0xc,%ebx,%esi
10a88d: 8d 86 84 67 12 00 lea 0x126784(%esi),%eax
10a893: 81 c6 28 0b 12 00 add $0x120b28,%esi
10a899: b9 03 00 00 00 mov $0x3,%ecx
10a89e: 89 c7 mov %eax,%edi
10a8a0: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a8a2: eb 26 jmp 10a8ca <sigaction+0x9a>
} else {
_POSIX_signals_Clear_process_signals( sig );
10a8a4: 83 ec 0c sub $0xc,%esp
10a8a7: 53 push %ebx
10a8a8: 89 55 e0 mov %edx,-0x20(%ebp)
10a8ab: e8 54 4d 00 00 call 10f604 <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
10a8b0: 6b db 0c imul $0xc,%ebx,%ebx
10a8b3: 81 c3 84 67 12 00 add $0x126784,%ebx
10a8b9: b9 03 00 00 00 mov $0x3,%ecx
10a8be: 8b 55 e0 mov -0x20(%ebp),%edx
10a8c1: 89 df mov %ebx,%edi
10a8c3: 89 d6 mov %edx,%esi
10a8c5: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a8c7: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10a8ca: ff 75 e4 pushl -0x1c(%ebp)
10a8cd: 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;
10a8ce: 31 c0 xor %eax,%eax
}
10a8d0: 8d 65 f4 lea -0xc(%ebp),%esp
10a8d3: 5b pop %ebx
10a8d4: 5e pop %esi
10a8d5: 5f pop %edi
10a8d6: c9 leave
10a8d7: c3 ret
0010c820 <sigsuspend>:
#include <rtems/seterr.h>
int sigsuspend(
const sigset_t *sigmask
)
{
10c820: 55 push %ebp
10c821: 89 e5 mov %esp,%ebp
10c823: 56 push %esi
10c824: 53 push %ebx
10c825: 83 ec 14 sub $0x14,%esp
int status;
POSIX_API_Control *api;
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
status = sigprocmask( SIG_BLOCK, sigmask, &saved_signals_blocked );
10c828: 8d 5d f4 lea -0xc(%ebp),%ebx
10c82b: 53 push %ebx
10c82c: ff 75 08 pushl 0x8(%ebp)
10c82f: 6a 01 push $0x1
10c831: e8 c6 ff ff ff call 10c7fc <sigprocmask>
(void) sigfillset( &all_signals );
10c836: 8d 75 f0 lea -0x10(%ebp),%esi
10c839: 89 34 24 mov %esi,(%esp)
10c83c: e8 17 ff ff ff call 10c758 <sigfillset>
status = sigtimedwait( &all_signals, NULL, NULL );
10c841: 83 c4 0c add $0xc,%esp
10c844: 6a 00 push $0x0
10c846: 6a 00 push $0x0
10c848: 56 push %esi
10c849: e8 69 00 00 00 call 10c8b7 <sigtimedwait>
10c84e: 89 c6 mov %eax,%esi
(void) sigprocmask( SIG_SETMASK, &saved_signals_blocked, NULL );
10c850: 83 c4 0c add $0xc,%esp
10c853: 6a 00 push $0x0
10c855: 53 push %ebx
10c856: 6a 00 push $0x0
10c858: e8 9f ff ff ff call 10c7fc <sigprocmask>
/*
* sigtimedwait() returns the signal number while sigsuspend()
* is supposed to return -1 and EINTR when a signal is caught.
*/
if ( status != -1 )
10c85d: 83 c4 10 add $0x10,%esp
10c860: 46 inc %esi
10c861: 74 0b je 10c86e <sigsuspend+0x4e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINTR );
10c863: e8 04 75 00 00 call 113d6c <__errno>
10c868: c7 00 04 00 00 00 movl $0x4,(%eax)
return status;
}
10c86e: 83 c8 ff or $0xffffffff,%eax
10c871: 8d 65 f8 lea -0x8(%ebp),%esp
10c874: 5b pop %ebx
10c875: 5e pop %esi
10c876: c9 leave
10c877: c3 ret
0010abf7 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
10abf7: 55 push %ebp
10abf8: 89 e5 mov %esp,%ebp
10abfa: 57 push %edi
10abfb: 56 push %esi
10abfc: 53 push %ebx
10abfd: 83 ec 2c sub $0x2c,%esp
10ac00: 8b 7d 08 mov 0x8(%ebp),%edi
10ac03: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
10ac06: 85 ff test %edi,%edi
10ac08: 74 24 je 10ac2e <sigtimedwait+0x37>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
10ac0a: 85 db test %ebx,%ebx
10ac0c: 74 33 je 10ac41 <sigtimedwait+0x4a>
if ( !_Timespec_Is_valid( timeout ) )
10ac0e: 83 ec 0c sub $0xc,%esp
10ac11: 53 push %ebx
10ac12: e8 29 30 00 00 call 10dc40 <_Timespec_Is_valid>
10ac17: 83 c4 10 add $0x10,%esp
10ac1a: 84 c0 test %al,%al
10ac1c: 74 10 je 10ac2e <sigtimedwait+0x37>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
10ac1e: 83 ec 0c sub $0xc,%esp
10ac21: 53 push %ebx
10ac22: e8 71 30 00 00 call 10dc98 <_Timespec_To_ticks>
if ( !interval )
10ac27: 83 c4 10 add $0x10,%esp
10ac2a: 85 c0 test %eax,%eax
10ac2c: 75 15 jne 10ac43 <sigtimedwait+0x4c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10ac2e: e8 2d 79 00 00 call 112560 <__errno>
10ac33: c7 00 16 00 00 00 movl $0x16,(%eax)
10ac39: 83 cf ff or $0xffffffff,%edi
10ac3c: e9 13 01 00 00 jmp 10ad54 <sigtimedwait+0x15d>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
10ac41: 31 c0 xor %eax,%eax
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
10ac43: 8b 5d 0c mov 0xc(%ebp),%ebx
10ac46: 85 db test %ebx,%ebx
10ac48: 75 03 jne 10ac4d <sigtimedwait+0x56>
10ac4a: 8d 5d dc lea -0x24(%ebp),%ebx
the_thread = _Thread_Executing;
10ac4d: 8b 15 74 78 12 00 mov 0x127874,%edx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10ac53: 8b b2 f8 00 00 00 mov 0xf8(%edx),%esi
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
10ac59: 9c pushf
10ac5a: fa cli
10ac5b: 8f 45 d4 popl -0x2c(%ebp)
if ( *set & api->signals_pending ) {
10ac5e: 8b 0f mov (%edi),%ecx
10ac60: 89 4d d0 mov %ecx,-0x30(%ebp)
10ac63: 8b 8e d0 00 00 00 mov 0xd0(%esi),%ecx
10ac69: 85 4d d0 test %ecx,-0x30(%ebp)
10ac6c: 74 32 je 10aca0 <sigtimedwait+0xa9>
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_highest( api->signals_pending );
10ac6e: 83 ec 0c sub $0xc,%esp
10ac71: 51 push %ecx
10ac72: e8 41 ff ff ff call 10abb8 <_POSIX_signals_Get_highest>
10ac77: 89 03 mov %eax,(%ebx)
_POSIX_signals_Clear_signals(
10ac79: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ac80: 6a 00 push $0x0
10ac82: 53 push %ebx
10ac83: 50 push %eax
10ac84: 56 push %esi
10ac85: e8 a2 4f 00 00 call 10fc2c <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
10ac8a: ff 75 d4 pushl -0x2c(%ebp)
10ac8d: 9d popf
the_info->si_code = SI_USER;
10ac8e: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
the_info->si_value.sival_int = 0;
10ac95: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
return the_info->si_signo;
10ac9c: 8b 3b mov (%ebx),%edi
10ac9e: eb 3b jmp 10acdb <sigtimedwait+0xe4>
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
10aca0: 8b 0d 78 7a 12 00 mov 0x127a78,%ecx
10aca6: 85 4d d0 test %ecx,-0x30(%ebp)
10aca9: 74 35 je 10ace0 <sigtimedwait+0xe9>
signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending );
10acab: 83 ec 0c sub $0xc,%esp
10acae: 51 push %ecx
10acaf: e8 04 ff ff ff call 10abb8 <_POSIX_signals_Get_highest>
10acb4: 89 c7 mov %eax,%edi
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
10acb6: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10acbd: 6a 01 push $0x1
10acbf: 53 push %ebx
10acc0: 50 push %eax
10acc1: 56 push %esi
10acc2: e8 65 4f 00 00 call 10fc2c <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
10acc7: ff 75 d4 pushl -0x2c(%ebp)
10acca: 9d popf
the_info->si_signo = signo;
10accb: 89 3b mov %edi,(%ebx)
the_info->si_code = SI_USER;
10accd: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
the_info->si_value.sival_int = 0;
10acd4: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
return signo;
10acdb: 83 c4 20 add $0x20,%esp
10acde: eb 74 jmp 10ad54 <sigtimedwait+0x15d>
}
the_info->si_signo = -1;
10ace0: c7 03 ff ff ff ff movl $0xffffffff,(%ebx)
10ace6: 8b 0d 24 73 12 00 mov 0x127324,%ecx
10acec: 41 inc %ecx
10aced: 89 0d 24 73 12 00 mov %ecx,0x127324
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
10acf3: c7 42 44 10 7a 12 00 movl $0x127a10,0x44(%edx)
the_thread->Wait.return_code = EINTR;
10acfa: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx)
the_thread->Wait.option = *set;
10ad01: 8b 0f mov (%edi),%ecx
10ad03: 89 4a 30 mov %ecx,0x30(%edx)
the_thread->Wait.return_argument = the_info;
10ad06: 89 5a 28 mov %ebx,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;
10ad09: c7 05 40 7a 12 00 01 movl $0x1,0x127a40
10ad10: 00 00 00
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
10ad13: ff 75 d4 pushl -0x2c(%ebp)
10ad16: 9d popf
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
10ad17: 52 push %edx
10ad18: 68 38 d8 10 00 push $0x10d838
10ad1d: 50 push %eax
10ad1e: 68 10 7a 12 00 push $0x127a10
10ad23: e8 38 28 00 00 call 10d560 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10ad28: e8 a9 23 00 00 call 10d0d6 <_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 );
10ad2d: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ad34: 6a 00 push $0x0
10ad36: 53 push %ebx
10ad37: ff 33 pushl (%ebx)
10ad39: 56 push %esi
10ad3a: e8 ed 4e 00 00 call 10fc2c <_POSIX_signals_Clear_signals>
errno = _Thread_Executing->Wait.return_code;
10ad3f: 83 c4 20 add $0x20,%esp
10ad42: e8 19 78 00 00 call 112560 <__errno>
10ad47: 8b 15 74 78 12 00 mov 0x127874,%edx
10ad4d: 8b 52 34 mov 0x34(%edx),%edx
10ad50: 89 10 mov %edx,(%eax)
return the_info->si_signo;
10ad52: 8b 3b mov (%ebx),%edi
}
10ad54: 89 f8 mov %edi,%eax
10ad56: 8d 65 f4 lea -0xc(%ebp),%esp
10ad59: 5b pop %ebx
10ad5a: 5e pop %esi
10ad5b: 5f pop %edi
10ad5c: c9 leave
10ad5d: c3 ret
0010ca38 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
10ca38: 55 push %ebp
10ca39: 89 e5 mov %esp,%ebp
10ca3b: 53 push %ebx
10ca3c: 83 ec 08 sub $0x8,%esp
10ca3f: 8b 5d 0c mov 0xc(%ebp),%ebx
int status;
status = sigtimedwait( set, NULL, NULL );
10ca42: 6a 00 push $0x0
10ca44: 6a 00 push $0x0
10ca46: ff 75 08 pushl 0x8(%ebp)
10ca49: e8 69 fe ff ff call 10c8b7 <sigtimedwait>
10ca4e: 89 c2 mov %eax,%edx
if ( status != -1 ) {
10ca50: 83 c4 10 add $0x10,%esp
10ca53: 83 f8 ff cmp $0xffffffff,%eax
10ca56: 74 0a je 10ca62 <sigwait+0x2a>
if ( sig )
*sig = status;
return 0;
10ca58: 31 c0 xor %eax,%eax
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
10ca5a: 85 db test %ebx,%ebx
10ca5c: 74 0b je 10ca69 <sigwait+0x31> <== NEVER TAKEN
*sig = status;
10ca5e: 89 13 mov %edx,(%ebx)
10ca60: eb 07 jmp 10ca69 <sigwait+0x31>
return 0;
}
return errno;
10ca62: e8 05 73 00 00 call 113d6c <__errno>
10ca67: 8b 00 mov (%eax),%eax
}
10ca69: 8b 5d fc mov -0x4(%ebp),%ebx
10ca6c: c9 leave
10ca6d: c3 ret
00108f91 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
108f91: 55 push %ebp
108f92: 89 e5 mov %esp,%ebp
108f94: 56 push %esi
108f95: 53 push %ebx
108f96: 89 d3 mov %edx,%ebx
108f98: 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)) {
108f9a: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx)
108fa1: 74 30 je 108fd3 <siproc+0x42> <== NEVER TAKEN
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108fa3: 52 push %edx
108fa4: 6a 00 push $0x0
108fa6: 6a 00 push $0x0
108fa8: ff 73 18 pushl 0x18(%ebx)
108fab: e8 18 12 00 00 call 10a1c8 <rtems_semaphore_obtain>
i = iproc (c, tty);
108fb0: 89 f2 mov %esi,%edx
108fb2: 0f b6 c2 movzbl %dl,%eax
108fb5: 89 da mov %ebx,%edx
108fb7: e8 b5 fe ff ff call 108e71 <iproc>
108fbc: 89 c6 mov %eax,%esi
rtems_semaphore_release (tty->osem);
108fbe: 58 pop %eax
108fbf: ff 73 18 pushl 0x18(%ebx)
108fc2: e8 ed 12 00 00 call 10a2b4 <rtems_semaphore_release>
108fc7: 83 c4 10 add $0x10,%esp
}
else {
i = iproc (c, tty);
}
return i;
}
108fca: 89 f0 mov %esi,%eax
108fcc: 8d 65 f8 lea -0x8(%ebp),%esp
108fcf: 5b pop %ebx
108fd0: 5e pop %esi
108fd1: c9 leave
108fd2: 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);
108fd3: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
108fd6: 89 da mov %ebx,%edx <== NOT EXECUTED
}
return i;
}
108fd8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
108fdb: 5b pop %ebx <== NOT EXECUTED
108fdc: 5e pop %esi <== NOT EXECUTED
108fdd: 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);
108fde: e9 8e fe ff ff jmp 108e71 <iproc> <== NOT EXECUTED
0010a050 <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
10a050: 55 push %ebp
10a051: 89 e5 mov %esp,%ebp
10a053: 57 push %edi
10a054: 56 push %esi
10a055: 53 push %ebx
10a056: 83 ec 38 sub $0x38,%esp
10a059: 8b 55 08 mov 0x8(%ebp),%edx
10a05c: 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 ) )
10a05f: 31 c0 xor %eax,%eax
10a061: 83 c9 ff or $0xffffffff,%ecx
10a064: 89 d7 mov %edx,%edi
10a066: f2 ae repnz scas %es:(%edi),%al
10a068: f7 d1 not %ecx
10a06a: 49 dec %ecx
10a06b: 6a 01 push $0x1
10a06d: 8d 5d d4 lea -0x2c(%ebp),%ebx
10a070: 53 push %ebx
10a071: 6a 00 push $0x0
10a073: 51 push %ecx
10a074: 52 push %edx
10a075: e8 eb ed ff ff call 108e65 <rtems_filesystem_evaluate_path>
10a07a: 83 c4 20 add $0x20,%esp
return -1;
10a07d: 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 ) )
10a080: 85 c0 test %eax,%eax
10a082: 75 26 jne 10a0aa <statvfs+0x5a> <== NEVER TAKEN
return -1;
mt_entry = loc.mt_entry;
10a084: 8b 55 e4 mov -0x1c(%ebp),%edx
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
10a087: b9 0e 00 00 00 mov $0xe,%ecx
10a08c: 89 f7 mov %esi,%edi
10a08e: f3 ab rep stos %eax,%es:(%edi)
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
10a090: 50 push %eax
10a091: 50 push %eax
10a092: 8b 42 28 mov 0x28(%edx),%eax
10a095: 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;
10a096: 83 c2 1c add $0x1c,%edx
memset (sb, 0, sizeof (struct statvfs));
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
10a099: 52 push %edx
10a09a: ff 50 44 call *0x44(%eax)
10a09d: 89 c7 mov %eax,%edi
rtems_filesystem_freenode( &loc );
10a09f: 89 1c 24 mov %ebx,(%esp)
10a0a2: e8 a5 ee ff ff call 108f4c <rtems_filesystem_freenode>
return result;
10a0a7: 83 c4 10 add $0x10,%esp
}
10a0aa: 89 f8 mov %edi,%eax
10a0ac: 8d 65 f4 lea -0xc(%ebp),%esp
10a0af: 5b pop %ebx
10a0b0: 5e pop %esi
10a0b1: 5f pop %edi
10a0b2: c9 leave
10a0b3: c3 ret
00108ea8 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
108ea8: 55 push %ebp
108ea9: 89 e5 mov %esp,%ebp
108eab: 53 push %ebx
108eac: 83 ec 04 sub $0x4,%esp
108eaf: 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;
108eb2: 8b 88 f0 00 00 00 mov 0xf0(%eax),%ecx
if ( this_reent ) {
108eb8: 85 c9 test %ecx,%ecx
108eba: 74 32 je 108eee <sync_per_thread+0x46> <== NEVER TAKEN
current_reent = _Thread_Executing->libc_reent;
108ebc: 8b 15 34 67 12 00 mov 0x126734,%edx
108ec2: 8b 9a f0 00 00 00 mov 0xf0(%edx),%ebx
_Thread_Executing->libc_reent = this_reent;
108ec8: 89 8a f0 00 00 00 mov %ecx,0xf0(%edx)
_fwalk (t->libc_reent, sync_wrapper);
108ece: 52 push %edx
108ecf: 52 push %edx
108ed0: 68 f3 8e 10 00 push $0x108ef3
108ed5: ff b0 f0 00 00 00 pushl 0xf0(%eax)
108edb: e8 84 9f 00 00 call 112e64 <_fwalk>
_Thread_Executing->libc_reent = current_reent;
108ee0: a1 34 67 12 00 mov 0x126734,%eax
108ee5: 89 98 f0 00 00 00 mov %ebx,0xf0(%eax)
108eeb: 83 c4 10 add $0x10,%esp
}
}
108eee: 8b 5d fc mov -0x4(%ebp),%ebx
108ef1: c9 leave
108ef2: c3 ret
00109580 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
109580: 55 push %ebp
109581: 89 e5 mov %esp,%ebp
109583: 56 push %esi
109584: 53 push %ebx
109585: 8b 5d 08 mov 0x8(%ebp),%ebx
109588: 8b 45 0c mov 0xc(%ebp),%eax
10958b: 8b 75 10 mov 0x10(%ebp),%esi
switch (opt) {
10958e: 85 c0 test %eax,%eax
109590: 74 22 je 1095b4 <tcsetattr+0x34>
109592: 48 dec %eax
109593: 74 0d je 1095a2 <tcsetattr+0x22>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
109595: e8 7a 93 00 00 call 112914 <__errno>
10959a: c7 00 86 00 00 00 movl $0x86,(%eax)
1095a0: eb 2a jmp 1095cc <tcsetattr+0x4c>
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
1095a2: 50 push %eax
1095a3: 6a 00 push $0x0
1095a5: 6a 03 push $0x3
1095a7: 53 push %ebx
1095a8: e8 a7 64 00 00 call 10fa54 <ioctl>
1095ad: 83 c4 10 add $0x10,%esp
1095b0: 85 c0 test %eax,%eax
1095b2: 78 18 js 1095cc <tcsetattr+0x4c> <== NEVER TAKEN
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
1095b4: 89 75 10 mov %esi,0x10(%ebp)
1095b7: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp)
1095be: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
1095c1: 8d 65 f8 lea -0x8(%ebp),%esp
1095c4: 5b pop %ebx
1095c5: 5e pop %esi
1095c6: c9 leave
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
1095c7: e9 88 64 00 00 jmp 10fa54 <ioctl>
}
}
1095cc: 83 c8 ff or $0xffffffff,%eax
1095cf: 8d 65 f8 lea -0x8(%ebp),%esp
1095d2: 5b pop %ebx
1095d3: 5e pop %esi
1095d4: c9 leave
1095d5: c3 ret
0010a094 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
10a094: 55 push %ebp
10a095: 89 e5 mov %esp,%ebp
10a097: 56 push %esi
10a098: 53 push %ebx
10a099: 8b 5d 0c mov 0xc(%ebp),%ebx
10a09c: 8b 75 10 mov 0x10(%ebp),%esi
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
10a09f: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
10a0a3: 75 1d jne 10a0c2 <timer_create+0x2e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
10a0a5: 85 f6 test %esi,%esi
10a0a7: 74 19 je 10a0c2 <timer_create+0x2e>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
10a0a9: 85 db test %ebx,%ebx
10a0ab: 74 22 je 10a0cf <timer_create+0x3b>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
10a0ad: 8b 03 mov (%ebx),%eax
10a0af: 48 dec %eax
10a0b0: 83 f8 01 cmp $0x1,%eax
10a0b3: 77 0d ja 10a0c2 <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 )
10a0b5: 8b 43 04 mov 0x4(%ebx),%eax
10a0b8: 85 c0 test %eax,%eax
10a0ba: 74 06 je 10a0c2 <timer_create+0x2e> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a0bc: 48 dec %eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
10a0bd: 83 f8 1f cmp $0x1f,%eax
10a0c0: 76 0d jbe 10a0cf <timer_create+0x3b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10a0c2: e8 a1 7c 00 00 call 111d68 <__errno>
10a0c7: c7 00 16 00 00 00 movl $0x16,(%eax)
10a0cd: eb 2f jmp 10a0fe <timer_create+0x6a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a0cf: a1 38 62 12 00 mov 0x126238,%eax
10a0d4: 40 inc %eax
10a0d5: a3 38 62 12 00 mov %eax,0x126238
* 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 );
10a0da: 83 ec 0c sub $0xc,%esp
10a0dd: 68 44 65 12 00 push $0x126544
10a0e2: e8 71 1b 00 00 call 10bc58 <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
10a0e7: 83 c4 10 add $0x10,%esp
10a0ea: 85 c0 test %eax,%eax
10a0ec: 75 18 jne 10a106 <timer_create+0x72>
_Thread_Enable_dispatch();
10a0ee: e8 6b 27 00 00 call 10c85e <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
10a0f3: e8 70 7c 00 00 call 111d68 <__errno>
10a0f8: c7 00 0b 00 00 00 movl $0xb,(%eax)
10a0fe: 83 c8 ff or $0xffffffff,%eax
10a101: e9 83 00 00 00 jmp 10a189 <timer_create+0xf5>
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
10a106: c6 40 3c 02 movb $0x2,0x3c(%eax)
ptimer->thread_id = _Thread_Executing->Object.id;
10a10a: 8b 15 88 67 12 00 mov 0x126788,%edx
10a110: 8b 52 08 mov 0x8(%edx),%edx
10a113: 89 50 38 mov %edx,0x38(%eax)
if ( evp != NULL ) {
10a116: 85 db test %ebx,%ebx
10a118: 74 11 je 10a12b <timer_create+0x97>
ptimer->inf.sigev_notify = evp->sigev_notify;
10a11a: 8b 13 mov (%ebx),%edx
10a11c: 89 50 40 mov %edx,0x40(%eax)
ptimer->inf.sigev_signo = evp->sigev_signo;
10a11f: 8b 53 04 mov 0x4(%ebx),%edx
10a122: 89 50 44 mov %edx,0x44(%eax)
ptimer->inf.sigev_value = evp->sigev_value;
10a125: 8b 53 08 mov 0x8(%ebx),%edx
10a128: 89 50 48 mov %edx,0x48(%eax)
}
ptimer->overrun = 0;
10a12b: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax)
ptimer->timer_data.it_value.tv_sec = 0;
10a132: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
ptimer->timer_data.it_value.tv_nsec = 0;
10a139: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
ptimer->timer_data.it_interval.tv_sec = 0;
10a140: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
ptimer->timer_data.it_interval.tv_nsec = 0;
10a147: 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;
10a14e: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10a155: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10a15c: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10a163: 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 ),
10a16a: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a16d: 0f b7 da movzwl %dx,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a170: 8b 0d 60 65 12 00 mov 0x126560,%ecx
10a176: 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;
10a179: 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;
10a180: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10a182: e8 d7 26 00 00 call 10c85e <_Thread_Enable_dispatch>
return 0;
10a187: 31 c0 xor %eax,%eax
}
10a189: 8d 65 f8 lea -0x8(%ebp),%esp
10a18c: 5b pop %ebx
10a18d: 5e pop %esi
10a18e: c9 leave
10a18f: c3 ret
0010a190 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
10a190: 55 push %ebp
10a191: 89 e5 mov %esp,%ebp
10a193: 57 push %edi
10a194: 56 push %esi
10a195: 53 push %ebx
10a196: 83 ec 2c sub $0x2c,%esp
10a199: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
10a19c: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a1a0: 0f 84 58 01 00 00 je 10a2fe <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) ) ) {
10a1a6: 83 ec 0c sub $0xc,%esp
10a1a9: 8b 45 10 mov 0x10(%ebp),%eax
10a1ac: 83 c0 08 add $0x8,%eax
10a1af: 50 push %eax
10a1b0: e8 37 32 00 00 call 10d3ec <_Timespec_Is_valid>
10a1b5: 83 c4 10 add $0x10,%esp
10a1b8: 84 c0 test %al,%al
10a1ba: 0f 84 3e 01 00 00 je 10a2fe <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
10a1c0: 83 ec 0c sub $0xc,%esp
10a1c3: ff 75 10 pushl 0x10(%ebp)
10a1c6: e8 21 32 00 00 call 10d3ec <_Timespec_Is_valid>
10a1cb: 83 c4 10 add $0x10,%esp
10a1ce: 84 c0 test %al,%al
10a1d0: 0f 84 28 01 00 00 je 10a2fe <timer_settime+0x16e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
10a1d6: 85 db test %ebx,%ebx
10a1d8: 74 09 je 10a1e3 <timer_settime+0x53>
10a1da: 83 fb 04 cmp $0x4,%ebx
10a1dd: 0f 85 1b 01 00 00 jne 10a2fe <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
10a1e3: 8d 7d cc lea -0x34(%ebp),%edi
10a1e6: b9 04 00 00 00 mov $0x4,%ecx
10a1eb: 8b 75 10 mov 0x10(%ebp),%esi
10a1ee: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
10a1f0: 83 fb 04 cmp $0x4,%ebx
10a1f3: 75 2f jne 10a224 <timer_settime+0x94>
struct timespec now;
_TOD_Get( &now );
10a1f5: 83 ec 0c sub $0xc,%esp
10a1f8: 8d 5d dc lea -0x24(%ebp),%ebx
10a1fb: 53 push %ebx
10a1fc: e8 9b 15 00 00 call 10b79c <_TOD_Get>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
10a201: 59 pop %ecx
10a202: 5e pop %esi
10a203: 8d 75 d4 lea -0x2c(%ebp),%esi
10a206: 56 push %esi
10a207: 53 push %ebx
10a208: e8 bb 31 00 00 call 10d3c8 <_Timespec_Greater_than>
10a20d: 83 c4 10 add $0x10,%esp
10a210: 84 c0 test %al,%al
10a212: 0f 85 e6 00 00 00 jne 10a2fe <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
10a218: 52 push %edx
10a219: 56 push %esi
10a21a: 56 push %esi
10a21b: 53 push %ebx
10a21c: e8 ef 31 00 00 call 10d410 <_Timespec_Subtract>
10a221: 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 );
10a224: 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 );
10a225: 8d 45 e4 lea -0x1c(%ebp),%eax
10a228: 50 push %eax
10a229: ff 75 08 pushl 0x8(%ebp)
10a22c: 68 44 65 12 00 push $0x126544
10a231: e8 4e 1e 00 00 call 10c084 <_Objects_Get>
10a236: 89 c3 mov %eax,%ebx
switch ( location ) {
10a238: 83 c4 10 add $0x10,%esp
10a23b: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10a23f: 0f 85 b9 00 00 00 jne 10a2fe <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 ) {
10a245: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10a249: 75 3b jne 10a286 <timer_settime+0xf6>
10a24b: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10a24f: 75 35 jne 10a286 <timer_settime+0xf6>
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
10a251: 83 ec 0c sub $0xc,%esp
10a254: 8d 40 10 lea 0x10(%eax),%eax
10a257: 50 push %eax
10a258: e8 77 35 00 00 call 10d7d4 <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
10a25d: 83 c4 10 add $0x10,%esp
10a260: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a264: 74 0d je 10a273 <timer_settime+0xe3>
*ovalue = ptimer->timer_data;
10a266: 8d 73 54 lea 0x54(%ebx),%esi
10a269: b9 04 00 00 00 mov $0x4,%ecx
10a26e: 8b 7d 14 mov 0x14(%ebp),%edi
10a271: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* The new data are set */
ptimer->timer_data = normalize;
10a273: 8d 7b 54 lea 0x54(%ebx),%edi
10a276: 8d 75 cc lea -0x34(%ebp),%esi
10a279: b9 04 00 00 00 mov $0x4,%ecx
10a27e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a280: c6 43 3c 04 movb $0x4,0x3c(%ebx)
10a284: eb 35 jmp 10a2bb <timer_settime+0x12b>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
10a286: 83 ec 0c sub $0xc,%esp
10a289: ff 75 10 pushl 0x10(%ebp)
10a28c: e8 b3 31 00 00 call 10d444 <_Timespec_To_ticks>
10a291: 89 43 64 mov %eax,0x64(%ebx)
initial_period = _Timespec_To_ticks( &normalize.it_value );
10a294: 8d 45 d4 lea -0x2c(%ebp),%eax
10a297: 89 04 24 mov %eax,(%esp)
10a29a: e8 a5 31 00 00 call 10d444 <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
10a29f: 89 1c 24 mov %ebx,(%esp)
10a2a2: 68 14 a3 10 00 push $0x10a314
10a2a7: ff 73 08 pushl 0x8(%ebx)
10a2aa: 50 push %eax
10a2ab: 8d 43 10 lea 0x10(%ebx),%eax
10a2ae: 50 push %eax
10a2af: e8 e8 55 00 00 call 10f89c <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
10a2b4: 83 c4 20 add $0x20,%esp
10a2b7: 84 c0 test %al,%al
10a2b9: 75 07 jne 10a2c2 <timer_settime+0x132>
_Thread_Enable_dispatch();
10a2bb: e8 9e 25 00 00 call 10c85e <_Thread_Enable_dispatch>
10a2c0: eb 38 jmp 10a2fa <timer_settime+0x16a>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
10a2c2: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a2c6: 74 0d je 10a2d5 <timer_settime+0x145>
*ovalue = ptimer->timer_data;
10a2c8: 8d 73 54 lea 0x54(%ebx),%esi
10a2cb: b9 04 00 00 00 mov $0x4,%ecx
10a2d0: 8b 7d 14 mov 0x14(%ebp),%edi
10a2d3: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ptimer->timer_data = normalize;
10a2d5: 8d 7b 54 lea 0x54(%ebx),%edi
10a2d8: 8d 75 cc lea -0x34(%ebp),%esi
10a2db: b9 04 00 00 00 mov $0x4,%ecx
10a2e0: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a2e2: c6 43 3c 03 movb $0x3,0x3c(%ebx)
_TOD_Get( &ptimer->time );
10a2e6: 83 ec 0c sub $0xc,%esp
10a2e9: 83 c3 6c add $0x6c,%ebx
10a2ec: 53 push %ebx
10a2ed: e8 aa 14 00 00 call 10b79c <_TOD_Get>
_Thread_Enable_dispatch();
10a2f2: e8 67 25 00 00 call 10c85e <_Thread_Enable_dispatch>
return 0;
10a2f7: 83 c4 10 add $0x10,%esp
10a2fa: 31 c0 xor %eax,%eax
10a2fc: eb 0e jmp 10a30c <timer_settime+0x17c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10a2fe: e8 65 7a 00 00 call 111d68 <__errno>
10a303: c7 00 16 00 00 00 movl $0x16,(%eax)
10a309: 83 c8 ff or $0xffffffff,%eax
}
10a30c: 8d 65 f4 lea -0xc(%ebp),%esp
10a30f: 5b pop %ebx
10a310: 5e pop %esi
10a311: 5f pop %edi
10a312: c9 leave
10a313: c3 ret
0010bfa4 <truncate>:
int truncate(
const char *path,
off_t length
)
{
10bfa4: 55 push %ebp <== NOT EXECUTED
10bfa5: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10bfa7: 56 push %esi <== NOT EXECUTED
10bfa8: 53 push %ebx <== NOT EXECUTED
10bfa9: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED
10bfac: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
10bfaf: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED
int status;
int fd;
fd = open( path, O_WRONLY );
10bfb2: 6a 01 push $0x1 <== NOT EXECUTED
10bfb4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10bfb7: 89 55 f4 mov %edx,-0xc(%ebp) <== NOT EXECUTED
10bfba: 89 4d f0 mov %ecx,-0x10(%ebp) <== NOT EXECUTED
10bfbd: e8 e2 df ff ff call 109fa4 <open> <== NOT EXECUTED
10bfc2: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if ( fd == -1 )
10bfc4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return -1;
10bfc7: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED
{
int status;
int fd;
fd = open( path, O_WRONLY );
if ( fd == -1 )
10bfca: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED
10bfcd: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED
10bfd0: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED
10bfd3: 74 16 je 10bfeb <truncate+0x47> <== NOT EXECUTED
return -1;
status = ftruncate( fd, length );
10bfd5: 50 push %eax <== NOT EXECUTED
10bfd6: 51 push %ecx <== NOT EXECUTED
10bfd7: 52 push %edx <== NOT EXECUTED
10bfd8: 53 push %ebx <== NOT EXECUTED
10bfd9: e8 92 4a 00 00 call 110a70 <ftruncate> <== NOT EXECUTED
10bfde: 89 c6 mov %eax,%esi <== NOT EXECUTED
(void) close( fd );
10bfe0: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10bfe3: e8 cc cf ff ff call 108fb4 <close> <== NOT EXECUTED
return status;
10bfe8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
10bfeb: 89 f0 mov %esi,%eax <== NOT EXECUTED
10bfed: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10bff0: 5b pop %ebx <== NOT EXECUTED
10bff1: 5e pop %esi <== NOT EXECUTED
10bff2: c9 leave <== NOT EXECUTED
10bff3: c3 ret <== NOT EXECUTED
00109fcc <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
109fcc: 55 push %ebp
109fcd: 89 e5 mov %esp,%ebp
109fcf: 57 push %edi
109fd0: 56 push %esi
109fd1: 53 push %ebx
109fd2: 83 ec 1c sub $0x1c,%esp
109fd5: 8b 75 08 mov 0x8(%ebp),%esi
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
109fd8: 83 3d 28 6b 12 00 00 cmpl $0x0,0x126b28
109fdf: 75 2c jne 10a00d <ualarm+0x41> <== NEVER TAKEN
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
109fe1: c7 05 14 6b 12 00 00 movl $0x0,0x126b14
109fe8: 00 00 00
the_watchdog->routine = routine;
109feb: c7 05 28 6b 12 00 94 movl $0x109f94,0x126b28
109ff2: 9f 10 00
the_watchdog->id = id;
109ff5: c7 05 2c 6b 12 00 00 movl $0x0,0x126b2c
109ffc: 00 00 00
the_watchdog->user_data = user_data;
109fff: c7 05 30 6b 12 00 00 movl $0x0,0x126b30
10a006: 00 00 00
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
10a009: 31 db xor %ebx,%ebx
10a00b: eb 4f jmp 10a05c <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 );
10a00d: 83 ec 0c sub $0xc,%esp
10a010: 68 0c 6b 12 00 push $0x126b0c
10a015: e8 aa 33 00 00 call 10d3c4 <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
10a01a: 83 e8 02 sub $0x2,%eax
10a01d: 83 c4 10 add $0x10,%esp
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
10a020: 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) ) {
10a022: 83 f8 01 cmp $0x1,%eax
10a025: 77 35 ja 10a05c <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);
10a027: a1 20 6b 12 00 mov 0x126b20,%eax
10a02c: 03 05 18 6b 12 00 add 0x126b18,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
10a032: 57 push %edi
10a033: 57 push %edi
10a034: 8d 55 e0 lea -0x20(%ebp),%edx
10a037: 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);
10a038: 2b 05 24 6b 12 00 sub 0x126b24,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
10a03e: 50 push %eax
10a03f: e8 28 2f 00 00 call 10cf6c <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
10a044: 69 4d e0 40 42 0f 00 imul $0xf4240,-0x20(%ebp),%ecx
remaining += tp.tv_nsec / 1000;
10a04b: 8b 45 e4 mov -0x1c(%ebp),%eax
10a04e: bf e8 03 00 00 mov $0x3e8,%edi
10a053: 99 cltd
10a054: f7 ff idiv %edi
10a056: 8d 1c 08 lea (%eax,%ecx,1),%ebx
10a059: 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 ) {
10a05c: 85 f6 test %esi,%esi
10a05e: 74 44 je 10a0a4 <ualarm+0xd8>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
10a060: b9 40 42 0f 00 mov $0xf4240,%ecx
10a065: 89 f0 mov %esi,%eax
10a067: 31 d2 xor %edx,%edx
10a069: f7 f1 div %ecx
10a06b: 89 45 e0 mov %eax,-0x20(%ebp)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
10a06e: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx
10a074: 89 55 e4 mov %edx,-0x1c(%ebp)
ticks = _Timespec_To_ticks( &tp );
10a077: 83 ec 0c sub $0xc,%esp
10a07a: 8d 75 e0 lea -0x20(%ebp),%esi
10a07d: 56 push %esi
10a07e: e8 45 2f 00 00 call 10cfc8 <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
10a083: 89 34 24 mov %esi,(%esp)
10a086: e8 3d 2f 00 00 call 10cfc8 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a08b: a3 18 6b 12 00 mov %eax,0x126b18
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a090: 59 pop %ecx
10a091: 5e pop %esi
10a092: 68 0c 6b 12 00 push $0x126b0c
10a097: 68 fc 62 12 00 push $0x1262fc
10a09c: e8 0b 32 00 00 call 10d2ac <_Watchdog_Insert>
10a0a1: 83 c4 10 add $0x10,%esp
}
return remaining;
}
10a0a4: 89 d8 mov %ebx,%eax
10a0a6: 8d 65 f4 lea -0xc(%ebp),%esp
10a0a9: 5b pop %ebx
10a0aa: 5e pop %esi
10a0ab: 5f pop %edi
10a0ac: c9 leave
10a0ad: c3 ret
0010a728 <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
10a728: 55 push %ebp
10a729: 89 e5 mov %esp,%ebp
10a72b: 57 push %edi
10a72c: 56 push %esi
10a72d: 53 push %ebx
10a72e: 83 ec 58 sub $0x58,%esp
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
10a731: ff 75 08 pushl 0x8(%ebp)
10a734: e8 51 d8 ff ff call 107f8a <rtems_filesystem_dirname>
10a739: 89 45 b4 mov %eax,-0x4c(%ebp)
if ( parentpathlen == 0 )
10a73c: 83 c4 10 add $0x10,%esp
10a73f: 85 c0 test %eax,%eax
10a741: 8d 45 d0 lea -0x30(%ebp),%eax
10a744: 75 15 jne 10a75b <unlink+0x33>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
10a746: 51 push %ecx
10a747: 50 push %eax
10a748: 8d 45 e4 lea -0x1c(%ebp),%eax
10a74b: 50 push %eax
10a74c: ff 75 08 pushl 0x8(%ebp)
10a74f: e8 20 e6 ff ff call 108d74 <rtems_filesystem_get_start_loc>
10a754: 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;
10a757: 31 db xor %ebx,%ebx
10a759: eb 25 jmp 10a780 <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,
10a75b: 83 ec 0c sub $0xc,%esp
10a75e: 6a 00 push $0x0
10a760: 50 push %eax
10a761: 6a 02 push $0x2
10a763: ff 75 b4 pushl -0x4c(%ebp)
10a766: ff 75 08 pushl 0x8(%ebp)
10a769: e8 b3 d7 ff ff call 107f21 <rtems_filesystem_evaluate_path>
10a76e: 89 c2 mov %eax,%edx
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
10a770: 83 c4 20 add $0x20,%esp
return -1;
10a773: 83 c8 ff or $0xffffffff,%eax
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
10a776: 85 d2 test %edx,%edx
10a778: 0f 85 d6 00 00 00 jne 10a854 <unlink+0x12c> <== NEVER TAKEN
return -1;
free_parentloc = true;
10a77e: b3 01 mov $0x1,%bl
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
10a780: 8d 7d bc lea -0x44(%ebp),%edi
10a783: 8d 75 d0 lea -0x30(%ebp),%esi
10a786: b9 05 00 00 00 mov $0x5,%ecx
10a78b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = path + parentpathlen;
10a78d: 8b 75 08 mov 0x8(%ebp),%esi
10a790: 03 75 b4 add -0x4c(%ebp),%esi
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
10a793: 83 c9 ff or $0xffffffff,%ecx
10a796: 89 f7 mov %esi,%edi
10a798: 31 c0 xor %eax,%eax
10a79a: f2 ae repnz scas %es:(%edi),%al
10a79c: f7 d1 not %ecx
10a79e: 49 dec %ecx
10a79f: 52 push %edx
10a7a0: 52 push %edx
10a7a1: 51 push %ecx
10a7a2: 56 push %esi
10a7a3: e8 21 d8 ff ff call 107fc9 <rtems_filesystem_prefix_separators>
10a7a8: 01 c6 add %eax,%esi
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
10a7aa: 83 c9 ff or $0xffffffff,%ecx
10a7ad: 89 f7 mov %esi,%edi
10a7af: 31 c0 xor %eax,%eax
10a7b1: f2 ae repnz scas %es:(%edi),%al
10a7b3: f7 d1 not %ecx
10a7b5: 49 dec %ecx
10a7b6: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10a7bd: 8d 7d bc lea -0x44(%ebp),%edi
10a7c0: 57 push %edi
10a7c1: 6a 00 push $0x0
10a7c3: 51 push %ecx
10a7c4: 56 push %esi
10a7c5: e8 d2 d6 ff ff call 107e9c <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
10a7ca: 83 c4 20 add $0x20,%esp
10a7cd: 85 c0 test %eax,%eax
10a7cf: 74 13 je 10a7e4 <unlink+0xbc> <== ALWAYS TAKEN
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
10a7d1: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
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 )
10a7d4: 84 db test %bl,%bl <== NOT EXECUTED
10a7d6: 74 7c je 10a854 <unlink+0x12c> <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
10a7d8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a7db: 8d 55 d0 lea -0x30(%ebp),%edx <== NOT EXECUTED
10a7de: 52 push %edx <== NOT EXECUTED
10a7df: 89 45 b0 mov %eax,-0x50(%ebp) <== NOT EXECUTED
10a7e2: eb 65 jmp 10a849 <unlink+0x121> <== NOT EXECUTED
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
10a7e4: 83 ec 0c sub $0xc,%esp
10a7e7: 57 push %edi
10a7e8: 8b 45 c8 mov -0x38(%ebp),%eax
10a7eb: ff 50 10 call *0x10(%eax)
10a7ee: 83 c4 10 add $0x10,%esp
10a7f1: 48 dec %eax
10a7f2: 75 2f jne 10a823 <unlink+0xfb>
rtems_filesystem_freenode( &loc );
10a7f4: 83 ec 0c sub $0xc,%esp
10a7f7: 57 push %edi
10a7f8: e8 0b d8 ff ff call 108008 <rtems_filesystem_freenode>
if ( free_parentloc )
10a7fd: 83 c4 10 add $0x10,%esp
10a800: 84 db test %bl,%bl
10a802: 74 0f je 10a813 <unlink+0xeb> <== ALWAYS TAKEN
rtems_filesystem_freenode( &parentloc );
10a804: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a807: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED
10a80a: 50 push %eax <== NOT EXECUTED
10a80b: e8 f8 d7 ff ff call 108008 <rtems_filesystem_freenode><== NOT EXECUTED
10a810: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EISDIR );
10a813: e8 38 a0 00 00 call 114850 <__errno>
10a818: c7 00 15 00 00 00 movl $0x15,(%eax)
10a81e: 83 c8 ff or $0xffffffff,%eax
10a821: eb 31 jmp 10a854 <unlink+0x12c>
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
10a823: 50 push %eax
10a824: 50 push %eax
10a825: 57 push %edi
10a826: 8d 75 d0 lea -0x30(%ebp),%esi
10a829: 56 push %esi
10a82a: 8b 45 c8 mov -0x38(%ebp),%eax
10a82d: ff 50 0c call *0xc(%eax)
rtems_filesystem_freenode( &loc );
10a830: 89 3c 24 mov %edi,(%esp)
10a833: 89 45 b0 mov %eax,-0x50(%ebp)
10a836: e8 cd d7 ff ff call 108008 <rtems_filesystem_freenode>
if ( free_parentloc )
10a83b: 83 c4 10 add $0x10,%esp
10a83e: 84 db test %bl,%bl
10a840: 8b 45 b0 mov -0x50(%ebp),%eax
10a843: 74 0f je 10a854 <unlink+0x12c>
rtems_filesystem_freenode( &parentloc );
10a845: 83 ec 0c sub $0xc,%esp
10a848: 56 push %esi
10a849: e8 ba d7 ff ff call 108008 <rtems_filesystem_freenode>
10a84e: 83 c4 10 add $0x10,%esp
10a851: 8b 45 b0 mov -0x50(%ebp),%eax
return result;
}
10a854: 8d 65 f4 lea -0xc(%ebp),%esp
10a857: 5b pop %ebx
10a858: 5e pop %esi
10a859: 5f pop %edi
10a85a: c9 leave
10a85b: c3 ret
0010a999 <unmount>:
*/
int unmount(
const char *path
)
{
10a999: 55 push %ebp
10a99a: 89 e5 mov %esp,%ebp
10a99c: 57 push %edi
10a99d: 56 push %esi
10a99e: 53 push %ebx
10a99f: 83 ec 38 sub $0x38,%esp
10a9a2: 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 ) )
10a9a5: 83 cb ff or $0xffffffff,%ebx
10a9a8: 31 c0 xor %eax,%eax
10a9aa: 89 d9 mov %ebx,%ecx
10a9ac: 89 d7 mov %edx,%edi
10a9ae: f2 ae repnz scas %es:(%edi),%al
10a9b0: f7 d1 not %ecx
10a9b2: 49 dec %ecx
10a9b3: 6a 01 push $0x1
10a9b5: 8d 7d d4 lea -0x2c(%ebp),%edi
10a9b8: 57 push %edi
10a9b9: 6a 00 push $0x0
10a9bb: 51 push %ecx
10a9bc: 52 push %edx
10a9bd: e8 f7 d4 ff ff call 107eb9 <rtems_filesystem_evaluate_path>
10a9c2: 83 c4 20 add $0x20,%esp
10a9c5: 85 c0 test %eax,%eax
10a9c7: 0f 85 f2 00 00 00 jne 10aabf <unmount+0x126>
return -1;
mt_entry = loc.mt_entry;
10a9cd: 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 ){
10a9d0: 8b 45 d4 mov -0x2c(%ebp),%eax
10a9d3: 39 46 1c cmp %eax,0x1c(%esi)
10a9d6: 74 1c je 10a9f4 <unmount+0x5b>
rtems_filesystem_freenode( &loc );
10a9d8: 83 ec 0c sub $0xc,%esp
10a9db: 57 push %edi
10a9dc: e8 bf d5 ff ff call 107fa0 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EACCES );
10a9e1: e8 f6 76 00 00 call 1120dc <__errno>
10a9e6: c7 00 0d 00 00 00 movl $0xd,(%eax)
10a9ec: 83 c4 10 add $0x10,%esp
10a9ef: e9 cb 00 00 00 jmp 10aabf <unmount+0x126>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
10a9f4: 83 ec 0c sub $0xc,%esp
10a9f7: 57 push %edi
10a9f8: e8 a3 d5 ff ff call 107fa0 <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 )
10a9fd: 83 c4 10 add $0x10,%esp
10aa00: a1 e0 4f 12 00 mov 0x124fe0,%eax
10aa05: 39 70 14 cmp %esi,0x14(%eax)
10aa08: 74 25 je 10aa2f <unmount+0x96>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
10aa0a: 51 push %ecx
10aa0b: 51 push %ecx
10aa0c: ff 76 2c pushl 0x2c(%esi)
10aa0f: 68 88 a9 10 00 push $0x10a988
10aa14: e8 7c dc ff ff call 108695 <rtems_filesystem_mount_iterate>
10aa19: 83 c4 10 add $0x10,%esp
10aa1c: 84 c0 test %al,%al
10aa1e: 75 0f jne 10aa2f <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 )
10aa20: 83 ec 0c sub $0xc,%esp
10aa23: 56 push %esi
10aa24: e8 5f d8 ff ff call 108288 <rtems_libio_is_open_files_in_fs>
10aa29: 83 c4 10 add $0x10,%esp
10aa2c: 48 dec %eax
10aa2d: 75 10 jne 10aa3f <unmount+0xa6>
rtems_set_errno_and_return_minus_one( EBUSY );
10aa2f: e8 a8 76 00 00 call 1120dc <__errno>
10aa34: c7 00 10 00 00 00 movl $0x10,(%eax)
10aa3a: e9 80 00 00 00 jmp 10aabf <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 )
10aa3f: 83 ec 0c sub $0xc,%esp
10aa42: 8b 46 14 mov 0x14(%esi),%eax
10aa45: 56 push %esi
10aa46: ff 50 28 call *0x28(%eax)
10aa49: 83 c4 10 add $0x10,%esp
return -1;
10aa4c: 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 )
10aa4f: 85 c0 test %eax,%eax
10aa51: 75 6f jne 10aac2 <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){
10aa53: 83 ec 0c sub $0xc,%esp
10aa56: 8b 46 28 mov 0x28(%esi),%eax
10aa59: 56 push %esi
10aa5a: ff 50 2c call *0x2c(%eax)
10aa5d: 83 c4 10 add $0x10,%esp
10aa60: 85 c0 test %eax,%eax
10aa62: 74 1d je 10aa81 <unmount+0xe8> <== ALWAYS TAKEN
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
10aa64: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa67: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED
10aa6a: 56 push %esi <== NOT EXECUTED
10aa6b: ff 50 20 call *0x20(%eax) <== NOT EXECUTED
10aa6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
return -1;
10aa71: 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 )
10aa73: 85 c0 test %eax,%eax <== NOT EXECUTED
10aa75: 74 4b je 10aac2 <unmount+0x129> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
10aa77: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa7a: 6a 00 push $0x0 <== NOT EXECUTED
10aa7c: e8 8b 0e 00 00 call 10b90c <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 );
10aa81: 52 push %edx
10aa82: 6a 00 push $0x0
10aa84: 6a 00 push $0x0
10aa86: ff 35 c8 71 12 00 pushl 0x1271c8
10aa8c: e8 f7 08 00 00 call 10b388 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10aa91: 89 34 24 mov %esi,(%esp)
10aa94: e8 3b 11 00 00 call 10bbd4 <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10aa99: 58 pop %eax
10aa9a: ff 35 c8 71 12 00 pushl 0x1271c8
10aaa0: e8 cf 09 00 00 call 10b474 <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;
10aaa5: 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 );
10aaa8: 89 04 24 mov %eax,(%esp)
10aaab: e8 f0 d4 ff ff call 107fa0 <rtems_filesystem_freenode>
free( mt_entry );
10aab0: 89 34 24 mov %esi,(%esp)
10aab3: e8 fc d4 ff ff call 107fb4 <free>
return 0;
10aab8: 83 c4 10 add $0x10,%esp
10aabb: 31 d2 xor %edx,%edx
10aabd: eb 03 jmp 10aac2 <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;
10aabf: 83 ca ff or $0xffffffff,%edx
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
10aac2: 89 d0 mov %edx,%eax
10aac4: 8d 65 f4 lea -0xc(%ebp),%esp
10aac7: 5b pop %ebx
10aac8: 5e pop %esi
10aac9: 5f pop %edi
10aaca: c9 leave
10aacb: c3 ret
0010a894 <utime>:
int utime(
const char *path,
const struct utimbuf *times
)
{
10a894: 55 push %ebp
10a895: 89 e5 mov %esp,%ebp
10a897: 57 push %edi
10a898: 53 push %ebx
10a899: 83 ec 3c sub $0x3c,%esp
10a89c: 8b 55 08 mov 0x8(%ebp),%edx
10a89f: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_filesystem_location_info_t temp_loc;
int result;
struct utimbuf now;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
10a8a2: 31 c0 xor %eax,%eax
10a8a4: 83 c9 ff or $0xffffffff,%ecx
10a8a7: 89 d7 mov %edx,%edi
10a8a9: f2 ae repnz scas %es:(%edi),%al
10a8ab: f7 d1 not %ecx
10a8ad: 49 dec %ecx
10a8ae: 6a 01 push $0x1
10a8b0: 8d 45 dc lea -0x24(%ebp),%eax
10a8b3: 50 push %eax
10a8b4: 6a 00 push $0x0
10a8b6: 51 push %ecx
10a8b7: 52 push %edx
10a8b8: e8 60 d1 ff ff call 107a1d <rtems_filesystem_evaluate_path>
10a8bd: 89 c2 mov %eax,%edx
10a8bf: 83 c4 20 add $0x20,%esp
return -1;
10a8c2: 83 c8 ff or $0xffffffff,%eax
{
rtems_filesystem_location_info_t temp_loc;
int result;
struct utimbuf now;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
10a8c5: 85 d2 test %edx,%edx
10a8c7: 75 3b jne 10a904 <utime+0x70>
return -1;
if ( times == NULL ) {
10a8c9: 85 db test %ebx,%ebx
10a8cb: 75 16 jne 10a8e3 <utime+0x4f> <== ALWAYS TAKEN
now.actime = now.modtime = time( NULL );
10a8cd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a8d0: 6a 00 push $0x0 <== NOT EXECUTED
10a8d2: e8 c5 ba 00 00 call 11639c <time> <== NOT EXECUTED
10a8d7: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED
10a8da: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED
10a8dd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
times = &now;
10a8e0: 8d 5d f0 lea -0x10(%ebp),%ebx <== NOT EXECUTED
}
result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime );
10a8e3: 50 push %eax
10a8e4: ff 73 04 pushl 0x4(%ebx)
10a8e7: ff 33 pushl (%ebx)
10a8e9: 8d 5d dc lea -0x24(%ebp),%ebx
10a8ec: 53 push %ebx
10a8ed: 8b 45 e8 mov -0x18(%ebp),%eax
10a8f0: ff 50 30 call *0x30(%eax)
rtems_filesystem_freenode( &temp_loc );
10a8f3: 89 1c 24 mov %ebx,(%esp)
10a8f6: 89 45 d4 mov %eax,-0x2c(%ebp)
10a8f9: e8 3e d4 ff ff call 107d3c <rtems_filesystem_freenode>
return result;
10a8fe: 83 c4 10 add $0x10,%esp
10a901: 8b 45 d4 mov -0x2c(%ebp),%eax
}
10a904: 8d 65 f8 lea -0x8(%ebp),%esp
10a907: 5b pop %ebx
10a908: 5f pop %edi
10a909: c9 leave
10a90a: c3 ret
0010990c <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
10990c: 55 push %ebp
10990d: 89 e5 mov %esp,%ebp
10990f: 57 push %edi
109910: 56 push %esi
109911: 53 push %ebx
109912: 83 ec 4c sub $0x4c,%esp
109915: 8b 5d 08 mov 0x8(%ebp),%ebx
109918: 8b 7d 0c mov 0xc(%ebp),%edi
10991b: 89 f8 mov %edi,%eax
for (; *fmt != '\0'; fmt++) {
10991d: e9 51 02 00 00 jmp 109b73 <vprintk+0x267>
bool minus = false;
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
109922: 80 fa 25 cmp $0x25,%dl
109925: 74 0b je 109932 <vprintk+0x26>
BSP_output_char(*fmt);
109927: 83 ec 0c sub $0xc,%esp
10992a: 0f be d2 movsbl %dl,%edx
10992d: e9 5b 01 00 00 jmp 109a8d <vprintk+0x181>
continue;
}
fmt++;
109932: 43 inc %ebx
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
109933: c6 45 c0 20 movb $0x20,-0x40(%ebp)
if (*fmt != '%') {
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
109937: 80 3b 30 cmpb $0x30,(%ebx)
10993a: 75 05 jne 109941 <vprintk+0x35>
lead = '0';
fmt++;
10993c: 43 inc %ebx
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
10993d: c6 45 c0 30 movb $0x30,-0x40(%ebp)
{
for (; *fmt != '\0'; fmt++) {
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
109941: 31 d2 xor %edx,%edx
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
109943: 80 3b 2d cmpb $0x2d,(%ebx)
109946: 75 03 jne 10994b <vprintk+0x3f>
minus = true;
fmt++;
109948: 43 inc %ebx
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
109949: b2 01 mov $0x1,%dl
{
for (; *fmt != '\0'; fmt++) {
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
10994b: 31 ff xor %edi,%edi
10994d: eb 0c jmp 10995b <vprintk+0x4f>
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
10994f: 6b ff 0a imul $0xa,%edi,%edi
width += ((unsigned) *fmt - '0');
109952: 0f be 4d c4 movsbl -0x3c(%ebp),%ecx
109956: 8d 7c 0f d0 lea -0x30(%edi,%ecx,1),%edi
fmt++;
10995a: 43 inc %ebx
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
10995b: 8a 0b mov (%ebx),%cl
10995d: 88 4d c4 mov %cl,-0x3c(%ebp)
109960: 83 e9 30 sub $0x30,%ecx
109963: 80 f9 09 cmp $0x9,%cl
109966: 76 e7 jbe 10994f <vprintk+0x43>
109968: 89 7d bc mov %edi,-0x44(%ebp)
)
{
for (; *fmt != '\0'; fmt++) {
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
10996b: c6 45 b8 00 movb $0x0,-0x48(%ebp)
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
10996f: 80 7d c4 6c cmpb $0x6c,-0x3c(%ebp)
109973: 75 0a jne 10997f <vprintk+0x73>
lflag = true;
c = *++fmt;
109975: 43 inc %ebx
109976: 8a 0b mov (%ebx),%cl
109978: 88 4d c4 mov %cl,-0x3c(%ebp)
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
lflag = true;
10997b: c6 45 b8 01 movb $0x1,-0x48(%ebp)
c = *++fmt;
}
if ( c == 'c' ) {
10997f: 80 7d c4 63 cmpb $0x63,-0x3c(%ebp)
109983: 75 1b jne 1099a0 <vprintk+0x94>
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
109985: 8d 50 04 lea 0x4(%eax),%edx
109988: 89 55 c4 mov %edx,-0x3c(%ebp)
BSP_output_char(chr);
10998b: 83 ec 0c sub $0xc,%esp
10998e: 0f be 00 movsbl (%eax),%eax
109991: 50 push %eax
109992: ff 15 5c 02 12 00 call *0x12025c
continue;
109998: 83 c4 10 add $0x10,%esp
10999b: e9 cf 01 00 00 jmp 109b6f <vprintk+0x263>
}
if ( c == 's' ) {
1099a0: 80 7d c4 73 cmpb $0x73,-0x3c(%ebp)
1099a4: 0f 85 9a 00 00 00 jne 109a44 <vprintk+0x138>
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
1099aa: 8d 48 04 lea 0x4(%eax),%ecx
1099ad: 89 4d c4 mov %ecx,-0x3c(%ebp)
1099b0: 8b 00 mov (%eax),%eax
if ( str == NULL ) {
1099b2: 85 c0 test %eax,%eax
1099b4: 75 05 jne 1099bb <vprintk+0xaf>
str = "";
1099b6: b8 05 e9 11 00 mov $0x11e905,%eax
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
1099bb: 31 f6 xor %esi,%esi
1099bd: eb 01 jmp 1099c0 <vprintk+0xb4>
1099bf: 46 inc %esi
1099c0: 80 3c 30 00 cmpb $0x0,(%eax,%esi,1)
1099c4: 75 f9 jne 1099bf <vprintk+0xb3>
;
/* leading spaces */
if ( !minus )
1099c6: 89 f1 mov %esi,%ecx
1099c8: 84 d2 test %dl,%dl
1099ca: 74 23 je 1099ef <vprintk+0xe3>
1099cc: eb 25 jmp 1099f3 <vprintk+0xe7>
for ( i=len ; i<width ; i++ )
BSP_output_char(' ');
1099ce: 83 ec 0c sub $0xc,%esp
1099d1: 6a 20 push $0x20
1099d3: 89 45 b0 mov %eax,-0x50(%ebp)
1099d6: 88 55 a8 mov %dl,-0x58(%ebp)
1099d9: 89 4d ac mov %ecx,-0x54(%ebp)
1099dc: ff 15 5c 02 12 00 call *0x12025c
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
1099e2: 8b 4d ac mov -0x54(%ebp),%ecx
1099e5: 41 inc %ecx
1099e6: 83 c4 10 add $0x10,%esp
1099e9: 8a 55 a8 mov -0x58(%ebp),%dl
1099ec: 8b 45 b0 mov -0x50(%ebp),%eax
1099ef: 39 f9 cmp %edi,%ecx
1099f1: 72 db jb 1099ce <vprintk+0xc2>
BSP_output_char(' ');
/* no width option */
if (width == 0) {
1099f3: 85 ff test %edi,%edi
1099f5: 75 25 jne 109a1c <vprintk+0x110>
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
1099f7: 85 f6 test %esi,%esi
1099f9: 74 27 je 109a22 <vprintk+0x116>
1099fb: 89 f7 mov %esi,%edi
1099fd: eb 1d jmp 109a1c <vprintk+0x110>
BSP_output_char(*str);
1099ff: 83 ec 0c sub $0xc,%esp
109a02: 0f be c9 movsbl %cl,%ecx
109a05: 51 push %ecx
109a06: 89 45 b0 mov %eax,-0x50(%ebp)
109a09: 88 55 a8 mov %dl,-0x58(%ebp)
109a0c: ff 15 5c 02 12 00 call *0x12025c
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
109a12: 8b 45 b0 mov -0x50(%ebp),%eax
109a15: 40 inc %eax
109a16: 83 c4 10 add $0x10,%esp
109a19: 8a 55 a8 mov -0x58(%ebp),%dl
109a1c: 8a 08 mov (%eax),%cl
109a1e: 84 c9 test %cl,%cl
109a20: 75 dd jne 1099ff <vprintk+0xf3>
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
109a22: 84 d2 test %dl,%dl
109a24: 0f 84 45 01 00 00 je 109b6f <vprintk+0x263>
109a2a: eb 0f jmp 109a3b <vprintk+0x12f>
for ( i=len ; i<width ; i++ )
BSP_output_char(' ');
109a2c: 83 ec 0c sub $0xc,%esp
109a2f: 6a 20 push $0x20
109a31: ff 15 5c 02 12 00 call *0x12025c
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
109a37: 46 inc %esi
109a38: 83 c4 10 add $0x10,%esp
109a3b: 39 fe cmp %edi,%esi
109a3d: 72 ed jb 109a2c <vprintk+0x120>
109a3f: e9 2b 01 00 00 jmp 109b6f <vprintk+0x263>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
109a44: 80 7d c4 4f cmpb $0x4f,-0x3c(%ebp)
109a48: 74 5b je 109aa5 <vprintk+0x199>
109a4a: 80 7d c4 6f cmpb $0x6f,-0x3c(%ebp)
109a4e: 74 55 je 109aa5 <vprintk+0x199> <== NEVER TAKEN
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
109a50: 80 7d c4 49 cmpb $0x49,-0x3c(%ebp)
109a54: 74 58 je 109aae <vprintk+0x1a2>
109a56: 80 7d c4 69 cmpb $0x69,-0x3c(%ebp)
109a5a: 74 52 je 109aae <vprintk+0x1a2>
c == 'd' || c == 'D' ) {
109a5c: 80 7d c4 44 cmpb $0x44,-0x3c(%ebp)
109a60: 74 4c je 109aae <vprintk+0x1a2>
109a62: 80 7d c4 64 cmpb $0x64,-0x3c(%ebp)
109a66: 74 46 je 109aae <vprintk+0x1a2>
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
109a68: 80 7d c4 55 cmpb $0x55,-0x3c(%ebp)
109a6c: 74 44 je 109ab2 <vprintk+0x1a6>
109a6e: 80 7d c4 75 cmpb $0x75,-0x3c(%ebp)
109a72: 74 3e je 109ab2 <vprintk+0x1a6>
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
109a74: 80 7d c4 58 cmpb $0x58,-0x3c(%ebp)
109a78: 74 41 je 109abb <vprintk+0x1af>
109a7a: 80 7d c4 78 cmpb $0x78,-0x3c(%ebp)
109a7e: 74 3b je 109abb <vprintk+0x1af>
base = 16; sign = false;
} else if ( c == 'p' ) {
109a80: 80 7d c4 70 cmpb $0x70,-0x3c(%ebp)
109a84: 74 39 je 109abf <vprintk+0x1b3>
base = 16; sign = false; lflag = true;
} else {
BSP_output_char(c);
109a86: 83 ec 0c sub $0xc,%esp
109a89: 0f be 55 c4 movsbl -0x3c(%ebp),%edx
109a8d: 52 push %edx
109a8e: 89 45 b0 mov %eax,-0x50(%ebp)
109a91: ff 15 5c 02 12 00 call *0x12025c
continue;
109a97: 83 c4 10 add $0x10,%esp
109a9a: 8b 45 b0 mov -0x50(%ebp),%eax
109a9d: 89 45 c4 mov %eax,-0x3c(%ebp)
109aa0: e9 ca 00 00 00 jmp 109b6f <vprintk+0x263>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
109aa5: 31 d2 xor %edx,%edx
109aa7: be 08 00 00 00 mov $0x8,%esi
109aac: eb 1c jmp 109aca <vprintk+0x1be>
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
109aae: b2 01 mov $0x1,%dl
109ab0: eb 02 jmp 109ab4 <vprintk+0x1a8>
} else if ( c == 'u' || c == 'U' ) {
base = 10; sign = false;
109ab2: 31 d2 xor %edx,%edx
109ab4: be 0a 00 00 00 mov $0xa,%esi
109ab9: eb 0f jmp 109aca <vprintk+0x1be>
} else if ( c == 'x' || c == 'X' ) {
base = 16; sign = false;
109abb: 31 d2 xor %edx,%edx
109abd: eb 06 jmp 109ac5 <vprintk+0x1b9>
} else if ( c == 'p' ) {
base = 16; sign = false; lflag = true;
109abf: 31 d2 xor %edx,%edx
109ac1: c6 45 b8 01 movb $0x1,-0x48(%ebp)
109ac5: be 10 00 00 00 mov $0x10,%esi
} else {
BSP_output_char(c);
continue;
}
printNum(
109aca: 0f be 4d c0 movsbl -0x40(%ebp),%ecx
109ace: 89 4d b4 mov %ecx,-0x4c(%ebp)
109ad1: 8d 48 04 lea 0x4(%eax),%ecx
lflag ? va_arg(ap, long) : (long) va_arg(ap, int),
109ad4: 89 4d c4 mov %ecx,-0x3c(%ebp)
} else {
BSP_output_char(c);
continue;
}
printNum(
109ad7: 8b 08 mov (%eax),%ecx
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
109ad9: 84 d2 test %dl,%dl
109adb: 74 1f je 109afc <vprintk+0x1f0>
109add: 85 c9 test %ecx,%ecx
109adf: 79 1b jns 109afc <vprintk+0x1f0>
BSP_output_char('-');
109ae1: 83 ec 0c sub $0xc,%esp
109ae4: 6a 2d push $0x2d
109ae6: 89 4d ac mov %ecx,-0x54(%ebp)
109ae9: ff 15 5c 02 12 00 call *0x12025c
unsigned_num = (unsigned long) -num;
109aef: 8b 4d ac mov -0x54(%ebp),%ecx
109af2: f7 d9 neg %ecx
if (maxwidth) maxwidth--;
109af4: 83 c4 10 add $0x10,%esp
109af7: 85 ff test %edi,%edi
109af9: 74 04 je 109aff <vprintk+0x1f3>
109afb: 4f dec %edi
} else {
unsigned_num = (unsigned long) num;
109afc: 89 7d bc mov %edi,-0x44(%ebp)
}
count = 0;
109aff: 31 ff xor %edi,%edi
109b01: eb 11 jmp 109b14 <vprintk+0x208>
while ((n = unsigned_num / base) > 0) {
toPrint[count++] = (char) (unsigned_num - (n * base));
109b03: 89 f0 mov %esi,%eax
109b05: f6 65 c0 mulb -0x40(%ebp)
109b08: 28 c1 sub %al,%cl
109b0a: 88 4c 3d d4 mov %cl,-0x2c(%ebp,%edi,1)
109b0e: 8b 7d b8 mov -0x48(%ebp),%edi
109b11: 8b 4d c0 mov -0x40(%ebp),%ecx
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
109b14: 89 c8 mov %ecx,%eax
109b16: 31 d2 xor %edx,%edx
109b18: f7 f6 div %esi
109b1a: 89 45 c0 mov %eax,-0x40(%ebp)
109b1d: 85 c0 test %eax,%eax
109b1f: 8d 57 01 lea 0x1(%edi),%edx
109b22: 89 55 b8 mov %edx,-0x48(%ebp)
109b25: 75 dc jne 109b03 <vprintk+0x1f7>
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
109b27: 88 4c 3d d4 mov %cl,-0x2c(%ebp,%edi,1)
109b2b: eb 12 jmp 109b3f <vprintk+0x233>
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
109b2d: 83 ec 0c sub $0xc,%esp
109b30: ff 75 b4 pushl -0x4c(%ebp)
109b33: ff 15 5c 02 12 00 call *0x12025c
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
109b39: ff 4d bc decl -0x44(%ebp)
109b3c: 83 c4 10 add $0x10,%esp
109b3f: 8b 4d b8 mov -0x48(%ebp),%ecx
109b42: 39 4d bc cmp %ecx,-0x44(%ebp)
109b45: 77 e6 ja 109b2d <vprintk+0x221>
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
109b47: 8d 45 d4 lea -0x2c(%ebp),%eax
109b4a: 8d 3c 38 lea (%eax,%edi,1),%edi
109b4d: 31 f6 xor %esi,%esi
109b4f: eb 19 jmp 109b6a <vprintk+0x25e>
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
109b51: 83 ec 0c sub $0xc,%esp
109b54: 0f be 07 movsbl (%edi),%eax
109b57: 0f be 80 06 e9 11 00 movsbl 0x11e906(%eax),%eax
109b5e: 50 push %eax
109b5f: ff 15 5c 02 12 00 call *0x12025c
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
109b65: 46 inc %esi
109b66: 4f dec %edi
109b67: 83 c4 10 add $0x10,%esp
109b6a: 3b 75 b8 cmp -0x48(%ebp),%esi
109b6d: 72 e2 jb 109b51 <vprintk+0x245>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
109b6f: 43 inc %ebx
109b70: 8b 45 c4 mov -0x3c(%ebp),%eax
109b73: 8a 13 mov (%ebx),%dl
109b75: 84 d2 test %dl,%dl
109b77: 0f 85 a5 fd ff ff jne 109922 <vprintk+0x16>
sign,
width,
lead
);
}
}
109b7d: 8d 65 f4 lea -0xc(%ebp),%esp
109b80: 5b pop %ebx
109b81: 5e pop %esi
109b82: 5f pop %edi
109b83: c9 leave
109b84: c3 ret
0011cc68 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
11cc68: 55 push %ebp
11cc69: 89 e5 mov %esp,%ebp
11cc6b: 56 push %esi
11cc6c: 53 push %ebx
11cc6d: 8b 5d 08 mov 0x8(%ebp),%ebx
11cc70: 8b 55 0c mov 0xc(%ebp),%edx
11cc73: 8b 4d 10 mov 0x10(%ebp),%ecx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11cc76: 3b 1d 44 01 12 00 cmp 0x120144,%ebx
11cc7c: 73 14 jae 11cc92 <write+0x2a>
iop = rtems_libio_iop( fd );
11cc7e: 6b db 38 imul $0x38,%ebx,%ebx
11cc81: 03 1d 98 40 12 00 add 0x124098,%ebx
rtems_libio_check_is_open( iop );
11cc87: 8b 73 14 mov 0x14(%ebx),%esi
11cc8a: f7 c6 00 01 00 00 test $0x100,%esi
11cc90: 75 0d jne 11cc9f <write+0x37>
11cc92: e8 bd 44 ff ff call 111154 <__errno>
11cc97: c7 00 09 00 00 00 movl $0x9,(%eax)
11cc9d: eb 1a jmp 11ccb9 <write+0x51>
rtems_libio_check_buffer( buffer );
11cc9f: 85 d2 test %edx,%edx
11cca1: 74 0b je 11ccae <write+0x46> <== NEVER TAKEN
rtems_libio_check_count( count );
11cca3: 31 c0 xor %eax,%eax
11cca5: 85 c9 test %ecx,%ecx
11cca7: 74 31 je 11ccda <write+0x72>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
11cca9: 83 e6 04 and $0x4,%esi
11ccac: 75 10 jne 11ccbe <write+0x56> <== ALWAYS TAKEN
11ccae: e8 a1 44 ff ff call 111154 <__errno> <== NOT EXECUTED
11ccb3: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
11ccb9: 83 c8 ff or $0xffffffff,%eax
11ccbc: eb 1c jmp 11ccda <write+0x72>
return 0;
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
11ccbe: 50 push %eax
11ccbf: 8b 43 20 mov 0x20(%ebx),%eax
11ccc2: 51 push %ecx
11ccc3: 52 push %edx
11ccc4: 53 push %ebx
11ccc5: ff 50 0c call *0xc(%eax)
if ( rc > 0 )
11ccc8: 83 c4 10 add $0x10,%esp
11cccb: 85 c0 test %eax,%eax
11cccd: 7e 0b jle 11ccda <write+0x72>
iop->offset += rc;
11cccf: 89 c1 mov %eax,%ecx
11ccd1: c1 f9 1f sar $0x1f,%ecx
11ccd4: 01 43 0c add %eax,0xc(%ebx)
11ccd7: 11 4b 10 adc %ecx,0x10(%ebx)
return rc;
}
11ccda: 8d 65 f8 lea -0x8(%ebp),%esp
11ccdd: 5b pop %ebx
11ccde: 5e pop %esi
11ccdf: c9 leave
11cce0: c3 ret
0010a99c <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
10a99c: 55 push %ebp
10a99d: 89 e5 mov %esp,%ebp
10a99f: 57 push %edi
10a9a0: 56 push %esi
10a9a1: 53 push %ebx
10a9a2: 83 ec 1c sub $0x1c,%esp
10a9a5: 8b 75 08 mov 0x8(%ebp),%esi
10a9a8: 8b 7d 0c mov 0xc(%ebp),%edi
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
10a9ab: 3b 35 c4 22 12 00 cmp 0x1222c4,%esi
10a9b1: 73 11 jae 10a9c4 <writev+0x28>
iop = rtems_libio_iop( fd );
10a9b3: 6b f6 38 imul $0x38,%esi,%esi
10a9b6: 03 35 18 62 12 00 add 0x126218,%esi
rtems_libio_check_is_open( iop );
10a9bc: 8b 46 14 mov 0x14(%esi),%eax
10a9bf: f6 c4 01 test $0x1,%ah
10a9c2: 75 10 jne 10a9d4 <writev+0x38>
10a9c4: e8 5b 73 00 00 call 111d24 <__errno>
10a9c9: c7 00 09 00 00 00 movl $0x9,(%eax)
10a9cf: e9 ad 00 00 00 jmp 10aa81 <writev+0xe5>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10a9d4: a8 04 test $0x4,%al
10a9d6: 74 42 je 10aa1a <writev+0x7e> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
10a9d8: 85 ff test %edi,%edi
10a9da: 74 3e je 10aa1a <writev+0x7e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
10a9dc: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a9e0: 7e 38 jle 10aa1a <writev+0x7e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
10a9e2: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp)
10a9e9: 7f 2f jg 10aa1a <writev+0x7e> <== NEVER TAKEN
10a9eb: b2 01 mov $0x1,%dl
10a9ed: 31 c0 xor %eax,%eax
10a9ef: 31 c9 xor %ecx,%ecx
10a9f1: eb 02 jmp 10a9f5 <writev+0x59>
if ( iov[v].iov_len )
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
10a9f3: 89 d9 mov %ebx,%ecx
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
if ( !iov[v].iov_base )
10a9f5: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8)
10a9f9: 74 1f je 10aa1a <writev+0x7e>
if ( iov[v].iov_len < 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
10a9fb: 83 7c c7 04 00 cmpl $0x0,0x4(%edi,%eax,8)
10aa00: 0f 94 c3 sete %bl
10aa03: f7 db neg %ebx
10aa05: 21 da and %ebx,%edx
/* check for wrap */
old = total;
total += iov[v].iov_len;
10aa07: 8b 5c c7 04 mov 0x4(%edi,%eax,8),%ebx
10aa0b: 8d 1c 19 lea (%ecx,%ebx,1),%ebx
if ( total < old || total > SSIZE_MAX )
10aa0e: 81 fb ff 7f 00 00 cmp $0x7fff,%ebx
10aa14: 7f 04 jg 10aa1a <writev+0x7e> <== NEVER TAKEN
10aa16: 39 cb cmp %ecx,%ebx
10aa18: 7d 0d jge 10aa27 <writev+0x8b>
rtems_set_errno_and_return_minus_one( EINVAL );
10aa1a: e8 05 73 00 00 call 111d24 <__errno>
10aa1f: c7 00 16 00 00 00 movl $0x16,(%eax)
10aa25: eb 5a jmp 10aa81 <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++ ) {
10aa27: 40 inc %eax
10aa28: 3b 45 10 cmp 0x10(%ebp),%eax
10aa2b: 7c c6 jl 10a9f3 <writev+0x57>
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
return 0;
10aa2d: 31 db xor %ebx,%ebx
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
10aa2f: 84 d2 test %dl,%dl
10aa31: 75 51 jne 10aa84 <writev+0xe8>
10aa33: 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 )
10aa3a: 8b 55 e4 mov -0x1c(%ebp),%edx
10aa3d: 8b 44 d7 04 mov 0x4(%edi,%edx,8),%eax
10aa41: 85 c0 test %eax,%eax
10aa43: 74 2f je 10aa74 <writev+0xd8> <== NEVER TAKEN
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
10aa45: 52 push %edx
10aa46: 8b 56 20 mov 0x20(%esi),%edx
10aa49: 50 push %eax
10aa4a: 8b 45 e4 mov -0x1c(%ebp),%eax
10aa4d: ff 34 c7 pushl (%edi,%eax,8)
10aa50: 56 push %esi
10aa51: ff 52 0c call *0xc(%edx)
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
10aa54: 83 c4 10 add $0x10,%esp
10aa57: 83 f8 00 cmp $0x0,%eax
10aa5a: 7c 25 jl 10aa81 <writev+0xe5> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
10aa5c: 74 0d je 10aa6b <writev+0xcf> <== NEVER TAKEN
iop->offset += bytes;
10aa5e: 89 c1 mov %eax,%ecx
10aa60: c1 f9 1f sar $0x1f,%ecx
10aa63: 01 46 0c add %eax,0xc(%esi)
10aa66: 11 4e 10 adc %ecx,0x10(%esi)
total += bytes;
10aa69: 01 c3 add %eax,%ebx
}
if (bytes != iov[ v ].iov_len)
10aa6b: 8b 55 e4 mov -0x1c(%ebp),%edx
10aa6e: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax
10aa72: 75 10 jne 10aa84 <writev+0xe8> <== NEVER TAKEN
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
10aa74: ff 45 e4 incl -0x1c(%ebp)
10aa77: 8b 45 10 mov 0x10(%ebp),%eax
10aa7a: 39 45 e4 cmp %eax,-0x1c(%ebp)
10aa7d: 7c bb jl 10aa3a <writev+0x9e>
10aa7f: eb 03 jmp 10aa84 <writev+0xe8>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
10aa81: 83 cb ff or $0xffffffff,%ebx
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
10aa84: 89 d8 mov %ebx,%eax
10aa86: 8d 65 f4 lea -0xc(%ebp),%esp
10aa89: 5b pop %ebx
10aa8a: 5e pop %esi
10aa8b: 5f pop %edi
10aa8c: c9 leave
10aa8d: c3 ret