000098b4 <IMFS_Set_handlers>:
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
switch( node->type ) {
98b4: e5903000 ldr r3, [r0]
98b8: e593304c ldr r3, [r3, #76] ; 0x4c
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
98bc: e5902010 ldr r2, [r0, #16]
switch( node->type ) {
98c0: e2433001 sub r3, r3, #1
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
98c4: e5922034 ldr r2, [r2, #52] ; 0x34
switch( node->type ) {
98c8: e3530006 cmp r3, #6
98cc: 979ff103 ldrls pc, [pc, r3, lsl #2]
98d0: ea000008 b 98f8 <IMFS_Set_handlers+0x44> <== NOT EXECUTED
98d4: 00009920 .word 0x00009920 <== NOT EXECUTED
98d8: 00009930 .word 0x00009930 <== NOT EXECUTED
98dc: 00009910 .word 0x00009910 <== NOT EXECUTED
98e0: 00009910 .word 0x00009910 <== NOT EXECUTED
98e4: 00009900 .word 0x00009900 <== NOT EXECUTED
98e8: 00009900 .word 0x00009900 <== NOT EXECUTED
98ec: 000098f0 .word 0x000098f0 <== NOT EXECUTED
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
98f0: e5923010 ldr r3, [r2, #16]
98f4: e5803008 str r3, [r0, #8]
break;
}
return 0;
}
98f8: e3a00000 mov r0, #0
98fc: e12fff1e bx lr
break;
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
9900: e5923008 ldr r3, [r2, #8]
9904: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
9908: e3a00000 mov r0, #0
990c: e12fff1e bx lr
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
9910: e59f3028 ldr r3, [pc, #40] ; 9940 <IMFS_Set_handlers+0x8c>
9914: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
9918: e3a00000 mov r0, #0
991c: e12fff1e bx lr
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
switch( node->type ) {
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
9920: e592300c ldr r3, [r2, #12]
9924: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
9928: e3a00000 mov r0, #0
992c: e12fff1e bx lr
switch( node->type ) {
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
9930: e59f300c ldr r3, [pc, #12] ; 9944 <IMFS_Set_handlers+0x90>
9934: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
9938: e3a00000 mov r0, #0
993c: e12fff1e bx lr
000099fc <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
99fc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
char token[ IMFS_NAME_MAX + 1 ];
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
9a00: e3d25007 bics r5, r2, #7
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
9a04: e24dd040 sub sp, sp, #64 ; 0x40
9a08: e58d2000 str r2, [sp]
9a0c: e1a0a000 mov sl, r0
9a10: e1a04001 mov r4, r1
9a14: e1a07003 mov r7, r3
char token[ IMFS_NAME_MAX + 1 ];
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
9a18: 1a000081 bne 9c24 <IMFS_eval_path+0x228>
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
9a1c: e5936000 ldr r6, [r3]
9a20: e28d8004 add r8, sp, #4
9a24: e28d903c add r9, sp, #60 ; 0x3c
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
9a28: e1a02008 mov r2, r8
9a2c: e1a03009 mov r3, r9
9a30: e08a0005 add r0, sl, r5
9a34: e1a01004 mov r1, r4
9a38: eb0001df bl a1bc <IMFS_get_token>
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
9a3c: e5973000 ldr r3, [r7]
9a40: e3530000 cmp r3, #0
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
9a44: e1a0b000 mov fp, r0
pathnamelen -= len;
9a48: e59d203c ldr r2, [sp, #60] ; 0x3c
i += len;
if ( !pathloc->node_access )
9a4c: 0a00004e beq 9b8c <IMFS_eval_path+0x190>
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
9a50: e3500000 cmp r0, #0
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
9a54: e0624004 rsb r4, r2, r4
i += len;
9a58: e0855002 add r5, r5, r2
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
9a5c: 1a00000f bne 9aa0 <IMFS_eval_path+0xa4>
* 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 ) {
9a60: e593204c ldr r2, [r3, #76] ; 0x4c
9a64: e3520001 cmp r2, #1
9a68: 0a000068 beq 9c10 <IMFS_eval_path+0x214>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
9a6c: e1a00007 mov r0, r7
9a70: ebffff8f bl 98b4 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
9a74: e59d1000 ldr r1, [sp]
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
9a78: e1a06000 mov r6, r0
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
9a7c: e1a00007 mov r0, r7
9a80: ebffffb0 bl 9948 <IMFS_evaluate_permission>
9a84: e3500000 cmp r0, #0
9a88: 1a000036 bne 9b68 <IMFS_eval_path+0x16c>
rtems_set_errno_and_return_minus_one( EACCES );
9a8c: eb001124 bl df24 <__errno>
9a90: e3a0300d mov r3, #13
9a94: e5803000 str r3, [r0]
9a98: e3e06000 mvn r6, #0
9a9c: ea000031 b 9b68 <IMFS_eval_path+0x16c>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
9aa0: e596104c ldr r1, [r6, #76] ; 0x4c
9aa4: e3510001 cmp r1, #1
9aa8: 0a000031 beq 9b74 <IMFS_eval_path+0x178>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
9aac: e35b0003 cmp fp, #3
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;
9ab0: e1a06003 mov r6, r3
switch( type ) {
9ab4: 0a000006 beq 9ad4 <IMFS_eval_path+0xd8>
9ab8: e35b0004 cmp fp, #4
9abc: 0a000025 beq 9b58 <IMFS_eval_path+0x15c>
9ac0: e35b0002 cmp fp, #2
9ac4: 0a000013 beq 9b18 <IMFS_eval_path+0x11c>
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
9ac8: e35b0004 cmp fp, #4
9acc: 1affffd5 bne 9a28 <IMFS_eval_path+0x2c>
9ad0: eaffffe2 b 9a60 <IMFS_eval_path+0x64> <== NOT EXECUTED
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
9ad4: e593304c ldr r3, [r3, #76] ; 0x4c
9ad8: e3530003 cmp r3, #3
9adc: 0a00002f beq 9ba0 <IMFS_eval_path+0x1a4>
* It would be a design error if we evaluated the link and
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
9ae0: e3530004 cmp r3, #4
9ae4: 0a000058 beq 9c4c <IMFS_eval_path+0x250>
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
9ae8: e3530001 cmp r3, #1
9aec: 1a000051 bne 9c38 <IMFS_eval_path+0x23c>
/*
* 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 ) {
9af0: e596e05c ldr lr, [r6, #92] ; 0x5c
9af4: e35e0000 cmp lr, #0
9af8: 1a000047 bne 9c1c <IMFS_eval_path+0x220>
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
9afc: e1a00006 mov r0, r6
9b00: e1a01008 mov r1, r8
9b04: eb00018b bl a138 <IMFS_find_match_in_dir>
if ( !node )
9b08: e2506000 subs r6, r0, #0
9b0c: 0a00001e beq 9b8c <IMFS_eval_path+0x190>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
9b10: e5876000 str r6, [r7]
9b14: eaffffc3 b 9a28 <IMFS_eval_path+0x2c>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
9b18: e59f1154 ldr r1, [pc, #340] ; 9c74 <IMFS_eval_path+0x278>
9b1c: e5912000 ldr r2, [r1]
9b20: e5922018 ldr r2, [r2, #24]
9b24: e1520003 cmp r2, r3
9b28: 0affffbe beq 9a28 <IMFS_eval_path+0x2c>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access) {
9b2c: e597e010 ldr lr, [r7, #16]
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
9b30: e59e201c ldr r2, [lr, #28]
9b34: e1520003 cmp r2, r3
9b38: 0a00001e beq 9bb8 <IMFS_eval_path+0x1bc>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
9b3c: e5936008 ldr r6, [r3, #8]
9b40: e3560000 cmp r6, #0
9b44: 1afffff1 bne 9b10 <IMFS_eval_path+0x114>
rtems_set_errno_and_return_minus_one( ENOENT );
9b48: eb0010f5 bl df24 <__errno>
9b4c: e3e06000 mvn r6, #0
9b50: e580b000 str fp, [r0]
9b54: ea000003 b 9b68 <IMFS_eval_path+0x16c>
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
9b58: eb0010f1 bl df24 <__errno>
9b5c: e3a0305b mov r3, #91 ; 0x5b
9b60: e5803000 str r3, [r0]
9b64: e3e06000 mvn r6, #0
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
9b68: e1a00006 mov r0, r6
9b6c: e28dd040 add sp, sp, #64 ; 0x40
9b70: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
9b74: e1a00007 mov r0, r7
9b78: ebffff72 bl 9948 <IMFS_evaluate_permission>
9b7c: e3500000 cmp r0, #0
9b80: 0affffc1 beq 9a8c <IMFS_eval_path+0x90>
9b84: e5973000 ldr r3, [r7]
9b88: eaffffc7 b 9aac <IMFS_eval_path+0xb0>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
if ( !node )
rtems_set_errno_and_return_minus_one( ENOENT );
9b8c: eb0010e4 bl df24 <__errno>
9b90: e3a03002 mov r3, #2
9b94: e5803000 str r3, [r0]
9b98: e3e06000 mvn r6, #0
9b9c: eafffff1 b 9b68 <IMFS_eval_path+0x16c>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
IMFS_evaluate_hard_link( pathloc, 0 );
9ba0: e1a00007 mov r0, r7
9ba4: e3a01000 mov r1, #0
9ba8: ebffff80 bl 99b0 <IMFS_evaluate_hard_link>
node = pathloc->node_access;
9bac: e5976000 ldr r6, [r7]
9bb0: e596304c ldr r3, [r6, #76] ; 0x4c
9bb4: eaffffcb b 9ae8 <IMFS_eval_path+0xec>
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
newloc = pathloc->mt_entry->mt_point_node;
9bb8: e28ee008 add lr, lr, #8
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
9bbc: e8be000f ldm lr!, {r0, r1, r2, r3}
9bc0: e28d6028 add r6, sp, #40 ; 0x28
9bc4: e8a6000f stmia r6!, {r0, r1, r2, r3}
*pathloc = newloc;
9bc8: e28dc028 add ip, sp, #40 ; 0x28
9bcc: e8bc000f ldm ip!, {r0, r1, r2, r3}
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
9bd0: e59ec000 ldr ip, [lr]
*pathloc = newloc;
9bd4: e1a0e007 mov lr, r7
9bd8: e8ae000f stmia lr!, {r0, r1, r2, r3}
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
9bdc: e59d103c ldr r1, [sp, #60] ; 0x3c
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
*pathloc = newloc;
9be0: e58ec000 str ip, [lr]
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
9be4: e0610005 rsb r0, r1, r5
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
9be8: e586c000 str ip, [r6]
*pathloc = newloc;
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
9bec: e08a0000 add r0, sl, r0
9bf0: e597c00c ldr ip, [r7, #12]
9bf4: e0841001 add r1, r4, r1
9bf8: e59d2000 ldr r2, [sp]
9bfc: e1a03007 mov r3, r7
9c00: e1a0e00f mov lr, pc
9c04: e59cf000 ldr pc, [ip]
9c08: e1a06000 mov r6, r0
9c0c: eaffffd5 b 9b68 <IMFS_eval_path+0x16c>
*
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
9c10: e593e05c ldr lr, [r3, #92] ; 0x5c
9c14: e35e0000 cmp lr, #0
9c18: 0affff93 beq 9a6c <IMFS_eval_path+0x70>
newloc = node->info.directory.mt_fs->mt_fs_root;
9c1c: e28ee01c add lr, lr, #28
9c20: eaffffe5 b 9bbc <IMFS_eval_path+0x1c0>
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
rtems_set_errno_and_return_minus_one( EIO );
9c24: eb0010be bl df24 <__errno> <== NOT EXECUTED
9c28: e3a03005 mov r3, #5 <== NOT EXECUTED
9c2c: e5803000 str r3, [r0] <== NOT EXECUTED
9c30: e3e06000 mvn r6, #0 <== NOT EXECUTED
9c34: eaffffcb b 9b68 <IMFS_eval_path+0x16c> <== NOT EXECUTED
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
9c38: eb0010b9 bl df24 <__errno>
9c3c: e3a03014 mov r3, #20
9c40: e5803000 str r3, [r0]
9c44: e3e06000 mvn r6, #0
9c48: eaffffc6 b 9b68 <IMFS_eval_path+0x16c>
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
9c4c: e1a00007 mov r0, r7
9c50: e3a01000 mov r1, #0
9c54: eb000007 bl 9c78 <IMFS_evaluate_sym_link>
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
if ( result == -1 )
9c58: e3700001 cmn r0, #1
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
9c5c: e1a06000 mov r6, r0
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
9c60: e5973000 ldr r3, [r7]
if ( result == -1 )
9c64: 0affffbf beq 9b68 <IMFS_eval_path+0x16c>
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
9c68: e1a06003 mov r6, r3
9c6c: e593304c ldr r3, [r3, #76] ; 0x4c
9c70: eaffff9c b 9ae8 <IMFS_eval_path+0xec>
00009de0 <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 */
)
{
9de0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
9de4: e24dd040 sub sp, sp, #64 ; 0x40
9de8: e1a06001 mov r6, r1
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
9dec: e5915000 ldr r5, [r1]
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
9df0: e1a0a000 mov sl, r0
9df4: e58d2000 str r2, [sp]
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
9df8: eb001433 bl eecc <strlen>
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
int i = 0;
9dfc: e3a07000 mov r7, #0
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
9e00: e1a04000 mov r4, r0
9e04: e28d8004 add r8, sp, #4
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
9e08: e1a01004 mov r1, r4
9e0c: e28d303c add r3, sp, #60 ; 0x3c
9e10: e08a0007 add r0, sl, r7
9e14: e1a02008 mov r2, r8
9e18: eb0000e7 bl a1bc <IMFS_get_token>
pathlen -= len;
i += len;
if ( !pathloc->node_access )
9e1c: e5963000 ldr r3, [r6]
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
9e20: e59db03c ldr fp, [sp, #60] ; 0x3c
i += len;
if ( !pathloc->node_access )
9e24: e3530000 cmp r3, #0
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
9e28: e1a09000 mov r9, r0
pathlen -= len;
9e2c: e06b4004 rsb r4, fp, r4
i += len;
if ( !pathloc->node_access )
9e30: 0a000035 beq 9f0c <IMFS_evaluate_for_make+0x12c>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
9e34: e3500000 cmp r0, #0
9e38: 1a000006 bne 9e58 <IMFS_evaluate_for_make+0x78>
pathloc->node_access = node;
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
9e3c: eb001038 bl df24 <__errno>
9e40: e3a03011 mov r3, #17
9e44: e5803000 str r3, [r0]
9e48: e3e05000 mvn r5, #0
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
9e4c: e1a00005 mov r0, r5
9e50: e28dd040 add sp, sp, #64 ; 0x40
9e54: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
9e58: e595104c ldr r1, [r5, #76] ; 0x4c
9e5c: e3510001 cmp r1, #1
9e60: 0a000044 beq 9f78 <IMFS_evaluate_for_make+0x198>
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
9e64: e087700b add r7, r7, fp
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;
9e68: e1a05003 mov r5, r3
switch( type ) {
9e6c: e3590004 cmp r9, #4
9e70: 979ff109 ldrls pc, [pc, r9, lsl #2]
9e74: eaffffe3 b 9e08 <IMFS_evaluate_for_make+0x28> <== NOT EXECUTED
9e78: 00009e3c .word 0x00009e3c <== NOT EXECUTED
9e7c: 00009e08 .word 0x00009e08 <== NOT EXECUTED
9e80: 00009edc .word 0x00009edc <== NOT EXECUTED
9e84: 00009e8c .word 0x00009e8c <== NOT EXECUTED
9e88: 00009f20 .word 0x00009f20 <== NOT EXECUTED
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
9e8c: e593304c ldr r3, [r3, #76] ; 0x4c
9e90: e3530003 cmp r3, #3
9e94: 0a00006a beq a044 <IMFS_evaluate_for_make+0x264>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
9e98: e3530004 cmp r3, #4
9e9c: 0a000068 beq a044 <IMFS_evaluate_for_make+0x264>
if ( result == -1 )
return -1;
}
node = pathloc->node_access;
if ( !node )
9ea0: e3550000 cmp r5, #0
9ea4: 0a00005f beq a028 <IMFS_evaluate_for_make+0x248>
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
9ea8: e595304c ldr r3, [r5, #76] ; 0x4c
9eac: e3530001 cmp r3, #1
9eb0: 1a00005c bne a028 <IMFS_evaluate_for_make+0x248>
/*
* 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 ) {
9eb4: e595c05c ldr ip, [r5, #92] ; 0x5c
9eb8: e35c0000 cmp ip, #0
9ebc: 1a00005e bne a03c <IMFS_evaluate_for_make+0x25c>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
9ec0: e1a00005 mov r0, r5
9ec4: e1a01008 mov r1, r8
9ec8: eb00009a bl a138 <IMFS_find_match_in_dir>
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
9ecc: e2505000 subs r5, r0, #0
9ed0: 0a000017 beq 9f34 <IMFS_evaluate_for_make+0x154>
done = true;
else
pathloc->node_access = node;
9ed4: e5865000 str r5, [r6]
9ed8: eaffffca b 9e08 <IMFS_evaluate_for_make+0x28>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
9edc: e59f1180 ldr r1, [pc, #384] ; a064 <IMFS_evaluate_for_make+0x284>
9ee0: e5912000 ldr r2, [r1]
9ee4: e5922018 ldr r2, [r2, #24]
9ee8: e1530002 cmp r3, r2
9eec: 0affffc5 beq 9e08 <IMFS_evaluate_for_make+0x28>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
9ef0: e596c010 ldr ip, [r6, #16]
9ef4: e59c201c ldr r2, [ip, #28]
9ef8: e1530002 cmp r3, r2
9efc: 0a000023 beq 9f90 <IMFS_evaluate_for_make+0x1b0>
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
9f00: e5935008 ldr r5, [r3, #8]
9f04: e3550000 cmp r5, #0
9f08: 1afffff1 bne 9ed4 <IMFS_evaluate_for_make+0xf4>
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
if ( !IMFS_is_separator( path[ i ] ) )
rtems_set_errno_and_return_minus_one( ENOENT );
9f0c: eb001004 bl df24 <__errno>
9f10: e3a03002 mov r3, #2
9f14: e5803000 str r3, [r0]
9f18: e3e05000 mvn r5, #0
9f1c: eaffffca b 9e4c <IMFS_evaluate_for_make+0x6c>
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
9f20: eb000fff bl df24 <__errno>
9f24: e3a0305b mov r3, #91 ; 0x5b
9f28: e5803000 str r3, [r0]
9f2c: e3e05000 mvn r5, #0
9f30: eaffffc5 b 9e4c <IMFS_evaluate_for_make+0x6c>
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
9f34: e59d303c ldr r3, [sp, #60] ; 0x3c
9f38: e59d1000 ldr r1, [sp]
9f3c: e0633007 rsb r3, r3, r7
9f40: e08a3003 add r3, sl, r3
9f44: e5813000 str r3, [r1]
/*
* 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++) {
9f48: e7da0007 ldrb r0, [sl, r7]
9f4c: e3500000 cmp r0, #0
9f50: e08a7007 add r7, sl, r7
9f54: 1a000003 bne 9f68 <IMFS_evaluate_for_make+0x188>
9f58: ea000021 b 9fe4 <IMFS_evaluate_for_make+0x204>
9f5c: e5f70001 ldrb r0, [r7, #1]!
9f60: e3500000 cmp r0, #0
9f64: 0a00001e beq 9fe4 <IMFS_evaluate_for_make+0x204>
if ( !IMFS_is_separator( path[ i ] ) )
9f68: ebffe4a0 bl 31f0 <rtems_filesystem_is_separator>
9f6c: e3500000 cmp r0, #0
9f70: 1afffff9 bne 9f5c <IMFS_evaluate_for_make+0x17c>
9f74: eaffffe4 b 9f0c <IMFS_evaluate_for_make+0x12c>
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
9f78: e1a00006 mov r0, r6
9f7c: ebfffe71 bl 9948 <IMFS_evaluate_permission>
9f80: e3500000 cmp r0, #0
9f84: 0a000022 beq a014 <IMFS_evaluate_for_make+0x234>
9f88: e5963000 ldr r3, [r6]
9f8c: eaffffb4 b 9e64 <IMFS_evaluate_for_make+0x84>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
9f90: e28cc008 add ip, ip, #8
* 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 ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
9f94: e8bc000f ldm ip!, {r0, r1, r2, r3}
9f98: e28d4028 add r4, sp, #40 ; 0x28
9f9c: e8a4000f stmia r4!, {r0, r1, r2, r3}
*pathloc = newloc;
9fa0: e28de028 add lr, sp, #40 ; 0x28
9fa4: e8be000f ldm lr!, {r0, r1, r2, r3}
9fa8: e1a0e006 mov lr, r6
* 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 ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
9fac: e59cc000 ldr ip, [ip]
*pathloc = newloc;
9fb0: e8ae000f stmia lr!, {r0, r1, r2, r3}
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
9fb4: e59d003c ldr r0, [sp, #60] ; 0x3c
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
*pathloc = newloc;
9fb8: e58ec000 str ip, [lr]
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
9fbc: e0600007 rsb r0, r0, r7
* 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 ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
9fc0: e584c000 str ip, [r4]
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
9fc4: e596300c ldr r3, [r6, #12]
9fc8: e08a0000 add r0, sl, r0
9fcc: e1a01006 mov r1, r6
9fd0: e59d2000 ldr r2, [sp]
9fd4: e1a0e00f mov lr, pc
9fd8: e593f004 ldr pc, [r3, #4]
9fdc: e1a05000 mov r5, r0
9fe0: eaffff99 b 9e4c <IMFS_evaluate_for_make+0x6c>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
9fe4: e1a00006 mov r0, r6
9fe8: ebfffe31 bl 98b4 <IMFS_Set_handlers>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
9fec: e5963000 ldr r3, [r6]
9ff0: e593304c ldr r3, [r3, #76] ; 0x4c
9ff4: e3530001 cmp r3, #1
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
9ff8: e1a05000 mov r5, r0
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
9ffc: 1a000009 bne a028 <IMFS_evaluate_for_make+0x248>
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
a000: e1a00006 mov r0, r6
a004: e3a01003 mov r1, #3
a008: ebfffe4e bl 9948 <IMFS_evaluate_permission>
a00c: e3500000 cmp r0, #0
a010: 1affff8d bne 9e4c <IMFS_evaluate_for_make+0x6c>
rtems_set_errno_and_return_minus_one( EACCES );
a014: eb000fc2 bl df24 <__errno>
a018: e3a0300d mov r3, #13
a01c: e5803000 str r3, [r0]
a020: e3e05000 mvn r5, #0
a024: eaffff88 b 9e4c <IMFS_evaluate_for_make+0x6c>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
a028: eb000fbd bl df24 <__errno>
a02c: e3a03014 mov r3, #20
a030: e5803000 str r3, [r0]
a034: e3e05000 mvn r5, #0
a038: eaffff83 b 9e4c <IMFS_evaluate_for_make+0x6c>
* 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 ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
a03c: e28cc01c add ip, ip, #28
a040: eaffffd3 b 9f94 <IMFS_evaluate_for_make+0x1b4>
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
a044: e1a00006 mov r0, r6
a048: e3a01000 mov r1, #0
a04c: ebffff2e bl 9d0c <IMFS_evaluate_link>
if ( result == -1 )
a050: e3700001 cmn r0, #1
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
a054: e1a05000 mov r5, r0
if ( result == -1 )
a058: 0affff7b beq 9e4c <IMFS_evaluate_for_make+0x6c>
a05c: e5965000 ldr r5, [r6]
a060: eaffff8e b 9ea0 <IMFS_evaluate_for_make+0xc0>
00009948 <IMFS_evaluate_permission>:
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
9948: e3d13007 bics r3, r1, #7
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
994c: e92d4070 push {r4, r5, r6, lr}
9950: e1a05001 mov r5, r1
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
9954: 1a000010 bne 999c <IMFS_evaluate_permission+0x54>
rtems_set_errno_and_return_minus_one( EPERM );
jnode = node->node_access;
9958: e5904000 ldr r4, [r0]
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
995c: eb000316 bl a5bc <geteuid>
9960: e1a06000 mov r6, r0
st_gid = getegid();
9964: eb00030f bl a5a8 <getegid>
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
9968: e1d433bc ldrh r3, [r4, #60] ; 0x3c
996c: e1530006 cmp r3, r6
flags_to_test <<= 6;
9970: 01a05305 lsleq r5, r5, #6
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
9974: 0a000002 beq 9984 <IMFS_evaluate_permission+0x3c>
flags_to_test <<= 6;
else if ( st_gid == jnode->st_gid )
9978: e1d433be ldrh r3, [r4, #62] ; 0x3e
997c: e1530000 cmp r3, r0
flags_to_test <<= 3;
9980: 01a05185 lsleq r5, r5, #3
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
9984: e5940030 ldr r0, [r4, #48] ; 0x30
9988: e0050000 and r0, r5, r0
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
998c: e1550000 cmp r5, r0
9990: 13a00000 movne r0, #0
9994: 03a00001 moveq r0, #1
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
9998: e8bd8070 pop {r4, r5, r6, pc}
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
999c: eb001160 bl df24 <__errno> <== NOT EXECUTED
99a0: e3a03001 mov r3, #1 <== NOT EXECUTED
99a4: e5803000 str r3, [r0] <== NOT EXECUTED
99a8: e3e00000 mvn r0, #0 <== NOT EXECUTED
99ac: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0000a068 <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
)
{
a068: e92d4070 push {r4, r5, r6, lr}
/*
* 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;
a06c: e1a0c000 mov ip, r0
a070: e5bc401c ldr r4, [ip, #28]!
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
a074: e24dd014 sub sp, sp, #20
a078: e1a0e000 mov lr, r0
* 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;
loc = temp_mt_entry->mt_fs_root;
a07c: e8bc000f ldm ip!, {r0, r1, r2, r3}
a080: e1a0600d mov r6, sp
a084: e8a6000f stmia r6!, {r0, r1, r2, r3}
a088: e59c2000 ldr r2, [ip]
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
a08c: e3a03000 mov r3, #0
* 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;
loc = temp_mt_entry->mt_fs_root;
a090: e5862000 str r2, [r6]
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
a094: e58e301c str r3, [lr, #28]
* 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;
loc = temp_mt_entry->mt_fs_root;
a098: e1a0500d mov r5, sp
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
a09c: e1a0000d mov r0, sp
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
a0a0: e5946008 ldr r6, [r4, #8]
loc.node_access = (void *)jnode;
a0a4: e58d4000 str r4, [sp]
IMFS_Set_handlers( &loc );
a0a8: ebfffe01 bl 98b4 <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
a0ac: e594304c ldr r3, [r4, #76] ; 0x4c
a0b0: e3530001 cmp r3, #1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
a0b4: e2842054 add r2, r4, #84 ; 0x54
a0b8: 1a000010 bne a100 <IMFS_fsunmount+0x98>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
a0bc: e5943050 ldr r3, [r4, #80] ; 0x50
a0c0: e1530002 cmp r3, r2
a0c4: 0a000014 beq a11c <IMFS_fsunmount+0xb4>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
}
if ( jnode != NULL ) {
a0c8: e3540000 cmp r4, #0
a0cc: 0a000008 beq a0f4 <IMFS_fsunmount+0x8c>
if ( jnode->type == IMFS_DIRECTORY ) {
a0d0: e594304c ldr r3, [r4, #76] ; 0x4c
a0d4: e3530001 cmp r3, #1
a0d8: 1affffef bne a09c <IMFS_fsunmount+0x34>
}
}
} while (jnode != NULL);
return 0;
}
a0dc: e5943050 ldr r3, [r4, #80] ; 0x50
a0e0: e2842054 add r2, r4, #84 ; 0x54
return -1;
jnode = next;
}
if ( jnode != NULL ) {
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
a0e4: e1530002 cmp r3, r2
a0e8: 0affffeb beq a09c <IMFS_fsunmount+0x34>
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
a0ec: e2534000 subs r4, r3, #0
a0f0: 1affffe9 bne a09c <IMFS_fsunmount+0x34>
return 0;
a0f4: e1a00004 mov r0, r4
}
a0f8: e28dd014 add sp, sp, #20
a0fc: e8bd8070 pop {r4, r5, r6, pc}
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
if ( jnode->type != IMFS_DIRECTORY ) {
result = IMFS_unlink( NULL, &loc );
a100: e1a0100d mov r1, sp
a104: e3a00000 mov r0, #0
a108: ebffdf38 bl 1df0 <IMFS_unlink>
if (result != 0)
a10c: e3500000 cmp r0, #0
a110: 1a000006 bne a130 <IMFS_fsunmount+0xc8>
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
a114: e1a04006 mov r4, r6
a118: eaffffea b a0c8 <IMFS_fsunmount+0x60>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
a11c: e3a00000 mov r0, #0
a120: e1a0100d mov r1, sp
a124: ebffdf31 bl 1df0 <IMFS_unlink>
if (result != 0)
a128: e3500000 cmp r0, #0
a12c: 0afffff8 beq a114 <IMFS_fsunmount+0xac>
return -1;
a130: e3e00000 mvn r0, #0 <== NOT EXECUTED
a134: eaffffef b a0f8 <IMFS_fsunmount+0x90> <== NOT EXECUTED
0000c454 <IMFS_memfile_get_block_pointer>:
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
c454: e59f3200 ldr r3, [pc, #512] ; c65c <IMFS_memfile_get_block_pointer+0x208>
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
c458: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
c45c: e5934000 ldr r4, [r3]
c460: e1a04124 lsr r4, r4, #2
c464: e2443001 sub r3, r4, #1
c468: e1510003 cmp r1, r3
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
c46c: e24dd004 sub sp, sp, #4
c470: e1a05000 mov r5, r0
c474: e1a06002 mov r6, r2
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
c478: 8a000007 bhi c49c <IMFS_memfile_get_block_pointer+0x48>
p = info->indirect;
if ( malloc_it ) {
c47c: e3520000 cmp r2, #0
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
p = info->indirect;
c480: e5900058 ldr r0, [r0, #88] ; 0x58
if ( malloc_it ) {
c484: 0a00001c beq c4fc <IMFS_memfile_get_block_pointer+0xa8>
if ( !p ) {
c488: e3500000 cmp r0, #0
c48c: 0a000041 beq c598 <IMFS_memfile_get_block_pointer+0x144>
}
if ( !p )
return 0;
return &info->indirect[ my_block ];
c490: e0800101 add r0, r0, r1, lsl #2
/*
* This means the requested block number is out of range.
*/
return 0;
}
c494: e28dd004 add sp, sp, #4
c498: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
c49c: e0274494 mla r7, r4, r4, r4
c4a0: e2473001 sub r3, r7, #1
c4a4: e1510003 cmp r1, r3
c4a8: 8a000016 bhi c508 <IMFS_memfile_get_block_pointer+0xb4>
my_block -= FIRST_DOUBLY_INDIRECT;
c4ac: e0647001 rsb r7, r4, r1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
c4b0: e1a00007 mov r0, r7
c4b4: e1a01004 mov r1, r4
c4b8: eb0014a2 bl 11748 <__umodsi3>
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c4bc: e1a01004 mov r1, r4
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
c4c0: e1a08000 mov r8, r0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c4c4: e1a00007 mov r0, r7
c4c8: eb001458 bl 11630 <__aeabi_uidiv>
p = info->doubly_indirect;
if ( malloc_it ) {
c4cc: e3560000 cmp r6, #0
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c4d0: e1a04000 mov r4, r0
p = info->doubly_indirect;
c4d4: e595305c ldr r3, [r5, #92] ; 0x5c
if ( malloc_it ) {
c4d8: 0a00003f beq c5dc <IMFS_memfile_get_block_pointer+0x188>
if ( !p ) {
c4dc: e3530000 cmp r3, #0
c4e0: 0a000045 beq c5fc <IMFS_memfile_get_block_pointer+0x1a8>
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
c4e4: e7930104 ldr r0, [r3, r4, lsl #2]
if ( !p1 ) {
c4e8: e3500000 cmp r0, #0
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
c4ec: e0834104 add r4, r3, r4, lsl #2
if ( !p1 ) {
c4f0: 0a00002f beq c5b4 <IMFS_memfile_get_block_pointer+0x160>
p = (block_p *)p[ doubly ];
if ( !p )
return 0;
return (block_p *)&p[ singly ];
c4f4: e0800108 add r0, r0, r8, lsl #2
c4f8: eaffffe5 b c494 <IMFS_memfile_get_block_pointer+0x40>
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
c4fc: e3500000 cmp r0, #0
c500: 1affffe2 bne c490 <IMFS_memfile_get_block_pointer+0x3c>
c504: eaffffe2 b c494 <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
c508: e0234497 mla r3, r7, r4, r4
c50c: e2433001 sub r3, r3, #1
c510: e1510003 cmp r1, r3
}
/*
* This means the requested block number is out of range.
*/
return 0;
c514: 83a00000 movhi r0, #0
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
c518: 8affffdd bhi c494 <IMFS_memfile_get_block_pointer+0x40>
my_block -= FIRST_TRIPLY_INDIRECT;
c51c: e0677001 rsb r7, r7, r1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
c520: e1a00007 mov r0, r7
c524: e1a01004 mov r1, r4
c528: eb001486 bl 11748 <__umodsi3>
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c52c: e1a01004 mov r1, r4
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
c530: e1a0a000 mov sl, r0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c534: e1a00007 mov r0, r7
c538: eb00143c bl 11630 <__aeabi_uidiv>
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
c53c: e1a01004 mov r1, r4
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c540: e1a08000 mov r8, r0
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
c544: eb001439 bl 11630 <__aeabi_uidiv>
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
c548: e1a01004 mov r1, r4
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
c54c: e1a07000 mov r7, r0
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
c550: e1a00008 mov r0, r8
c554: eb00147b bl 11748 <__umodsi3>
p = info->triply_indirect;
if ( malloc_it ) {
c558: e3560000 cmp r6, #0
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
c55c: e1a04000 mov r4, r0
p = info->triply_indirect;
c560: e5950060 ldr r0, [r5, #96] ; 0x60
if ( malloc_it ) {
c564: 0a000029 beq c610 <IMFS_memfile_get_block_pointer+0x1bc>
if ( !p ) {
c568: e3500000 cmp r0, #0
c56c: 0a000035 beq c648 <IMFS_memfile_get_block_pointer+0x1f4>
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
c570: e7903107 ldr r3, [r0, r7, lsl #2]
if ( !p1 ) {
c574: e3530000 cmp r3, #0
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
c578: e0807107 add r7, r0, r7, lsl #2
if ( !p1 ) {
c57c: 0a00002c beq c634 <IMFS_memfile_get_block_pointer+0x1e0>
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
c580: e7930104 ldr r0, [r3, r4, lsl #2]
if ( !p2 ) {
c584: e3500000 cmp r0, #0
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
c588: e0834104 add r4, r3, r4, lsl #2
if ( !p2 ) {
c58c: 0a00000d beq c5c8 <IMFS_memfile_get_block_pointer+0x174>
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
c590: e080010a add r0, r0, sl, lsl #2
c594: eaffffbe b c494 <IMFS_memfile_get_block_pointer+0x40>
p = info->indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
c598: e58d1000 str r1, [sp]
c59c: ebffff9f bl c420 <memfile_alloc_block>
if ( !p )
c5a0: e3500000 cmp r0, #0
c5a4: e59d1000 ldr r1, [sp]
return 0;
info->indirect = p;
c5a8: 15850058 strne r0, [r5, #88] ; 0x58
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
c5ac: 1affffb7 bne c490 <IMFS_memfile_get_block_pointer+0x3c>
c5b0: eaffffb7 b c494 <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
c5b4: ebffff99 bl c420 <memfile_alloc_block>
if ( !p1 )
c5b8: e3500000 cmp r0, #0
return 0;
p[ doubly ] = (block_p) p1;
c5bc: 15840000 strne r0, [r4]
p = (block_p *)p[ doubly ];
if ( !p )
return 0;
return (block_p *)&p[ singly ];
c5c0: 10800108 addne r0, r0, r8, lsl #2
c5c4: eaffffb2 b c494 <IMFS_memfile_get_block_pointer+0x40>
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
c5c8: ebffff94 bl c420 <memfile_alloc_block>
if ( !p2 )
c5cc: e3500000 cmp r0, #0
return 0;
p1[ doubly ] = (block_p) p2;
c5d0: 15840000 strne r0, [r4]
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
c5d4: 1080010a addne r0, r0, sl, lsl #2
c5d8: eaffffad b c494 <IMFS_memfile_get_block_pointer+0x40>
}
return (block_p *)&p1[ singly ];
}
if ( !p )
c5dc: e3530000 cmp r3, #0
c5e0: 1a000001 bne c5ec <IMFS_memfile_get_block_pointer+0x198>
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
return 0;
c5e4: e1a00003 mov r0, r3 <== NOT EXECUTED
c5e8: eaffffa9 b c494 <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
}
if ( !p )
return 0;
p = (block_p *)p[ doubly ];
c5ec: e7930100 ldr r0, [r3, r0, lsl #2]
if ( !p )
c5f0: e3500000 cmp r0, #0
return 0;
return (block_p *)&p[ singly ];
c5f4: 10800108 addne r0, r0, r8, lsl #2
c5f8: eaffffa5 b c494 <IMFS_memfile_get_block_pointer+0x40>
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
c5fc: ebffff87 bl c420 <memfile_alloc_block>
if ( !p )
c600: e2503000 subs r3, r0, #0
c604: 0afffff6 beq c5e4 <IMFS_memfile_get_block_pointer+0x190>
return 0;
info->doubly_indirect = p;
c608: e585305c str r3, [r5, #92] ; 0x5c
c60c: eaffffb4 b c4e4 <IMFS_memfile_get_block_pointer+0x90>
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
c610: e3500000 cmp r0, #0
c614: 0affff9e beq c494 <IMFS_memfile_get_block_pointer+0x40>
return 0;
p1 = (block_p *) p[ triply ];
c618: e7900107 ldr r0, [r0, r7, lsl #2]
if ( !p1 )
c61c: e3500000 cmp r0, #0
c620: 0affff9b beq c494 <IMFS_memfile_get_block_pointer+0x40>
return 0;
p2 = (block_p *)p1[ doubly ];
c624: e7900104 ldr r0, [r0, r4, lsl #2]
if ( !p2 )
c628: e3500000 cmp r0, #0
return 0;
return (block_p *)&p2[ singly ];
c62c: 1080010a addne r0, r0, sl, lsl #2
c630: eaffff97 b c494 <IMFS_memfile_get_block_pointer+0x40>
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
c634: ebffff79 bl c420 <memfile_alloc_block>
if ( !p1 )
c638: e2503000 subs r3, r0, #0
c63c: 0affffe8 beq c5e4 <IMFS_memfile_get_block_pointer+0x190>
return 0;
p[ triply ] = (block_p) p1;
c640: e5873000 str r3, [r7]
c644: eaffffcd b c580 <IMFS_memfile_get_block_pointer+0x12c>
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
c648: ebffff74 bl c420 <memfile_alloc_block>
if ( !p )
c64c: e3500000 cmp r0, #0
c650: 0affff8f beq c494 <IMFS_memfile_get_block_pointer+0x40>
return 0;
info->triply_indirect = p;
c654: e5850060 str r0, [r5, #96] ; 0x60
c658: eaffffc4 b c570 <IMFS_memfile_get_block_pointer+0x11c>
0000c660 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
c660: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
c664: e1a09000 mov r9, r0
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
c668: e590004c ldr r0, [r0, #76] ; 0x4c
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
c66c: e24dd014 sub sp, sp, #20
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
c670: e3500006 cmp r0, #6
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
c674: e1a07001 mov r7, r1
c678: e1a08002 mov r8, r2
c67c: e1a0b003 mov fp, r3
c680: e59d5038 ldr r5, [sp, #56] ; 0x38
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
c684: 0a00005c beq c7fc <IMFS_memfile_read+0x19c>
/*
* 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 )
c688: e5992054 ldr r2, [r9, #84] ; 0x54
/*
* 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;
c68c: e1a03001 mov r3, r1
if ( last_byte > the_jnode->info.file.size )
c690: e3a01000 mov r1, #0
c694: e1510002 cmp r1, r2
c698: e5992050 ldr r2, [r9, #80] ; 0x50
/*
* 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;
c69c: e0851007 add r1, r5, r7
if ( last_byte > the_jnode->info.file.size )
c6a0: da00003d ble c79c <IMFS_memfile_read+0x13c>
my_length = the_jnode->info.file.size - start;
c6a4: e0635002 rsb r5, r3, r2
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
c6a8: e59f61b8 ldr r6, [pc, #440] ; c868 <IMFS_memfile_read+0x208>
c6ac: e5964000 ldr r4, [r6]
c6b0: e1a00007 mov r0, r7
c6b4: e1a02004 mov r2, r4
c6b8: e1a03fc2 asr r3, r2, #31
c6bc: e1a01008 mov r1, r8
c6c0: e98d000c stmib sp, {r2, r3}
c6c4: eb001580 bl 11ccc <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
c6c8: e1a01008 mov r1, r8
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
c6cc: e1a0a000 mov sl, r0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
c6d0: e99d000c ldmib sp, {r2, r3}
c6d4: e1a00007 mov r0, r7
c6d8: eb00144e bl 11818 <__divdi3>
if ( start_offset ) {
c6dc: e35a0000 cmp sl, #0
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
c6e0: e1a07000 mov r7, r0
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
c6e4: 01a0800b moveq r8, fp
/*
* 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 ) {
c6e8: 0a000014 beq c740 <IMFS_memfile_read+0xe0>
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 );
c6ec: e1a00009 mov r0, r9
c6f0: e1a01007 mov r1, r7
c6f4: e3a02000 mov r2, #0
c6f8: ebffff55 bl c454 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
c6fc: e3500000 cmp r0, #0
c700: 0a000023 beq c794 <IMFS_memfile_read+0x134>
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
c704: e5901000 ldr r1, [r0]
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
c708: e06a3004 rsb r3, sl, r4
c70c: e1550003 cmp r5, r3
c710: 31a03005 movcc r3, r5
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 );
c714: e081100a add r1, r1, sl
c718: e1a02003 mov r2, r3
c71c: e1a0000b mov r0, fp
c720: e58d3000 str r3, [sp]
c724: eb00082c bl e7dc <memcpy>
dest += to_copy;
c728: e59d3000 ldr r3, [sp]
block++;
my_length -= to_copy;
c72c: e5964000 ldr r4, [r6]
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 );
dest += to_copy;
c730: e08b8003 add r8, fp, r3
block++;
c734: e2877001 add r7, r7, #1
my_length -= to_copy;
c738: e0635005 rsb r5, r3, r5
copied += to_copy;
c73c: e1a0a003 mov sl, r3
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
c740: e1550004 cmp r5, r4
c744: 2a000008 bcs c76c <IMFS_memfile_read+0x10c>
c748: ea000017 b c7ac <IMFS_memfile_read+0x14c>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
c74c: e5931000 ldr r1, [r3]
c750: eb000821 bl e7dc <memcpy>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
c754: e5963000 ldr r3, [r6]
c758: e1530005 cmp r3, r5
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
dest += to_copy;
c75c: e0888004 add r8, r8, r4
block++;
c760: e2877001 add r7, r7, #1
my_length -= to_copy;
copied += to_copy;
c764: e08aa004 add sl, sl, r4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
c768: 8a00000f bhi c7ac <IMFS_memfile_read+0x14c>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
c76c: e3a02000 mov r2, #0
c770: e1a01007 mov r1, r7
c774: e1a00009 mov r0, r9
c778: ebffff35 bl c454 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
c77c: e2503000 subs r3, r0, #0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
c780: e1a02004 mov r2, r4
dest += to_copy;
block++;
my_length -= to_copy;
c784: e0645005 rsb r5, r4, r5
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
c788: e1a00008 mov r0, r8
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
c78c: 1affffee bne c74c <IMFS_memfile_read+0xec>
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
c790: e1a0000a mov r0, sl <== NOT EXECUTED
}
IMFS_update_atime( the_jnode );
return copied;
}
c794: e28dd014 add sp, sp, #20
c798: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* 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 )
c79c: 1affffc1 bne c6a8 <IMFS_memfile_read+0x48>
c7a0: e1510002 cmp r1, r2
c7a4: 9affffbf bls c6a8 <IMFS_memfile_read+0x48>
c7a8: eaffffbd b c6a4 <IMFS_memfile_read+0x44>
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
c7ac: e3550000 cmp r5, #0
c7b0: 0a00000a beq c7e0 <IMFS_memfile_read+0x180>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
c7b4: e1a00009 mov r0, r9
c7b8: e1a01007 mov r1, r7
c7bc: e3a02000 mov r2, #0
c7c0: ebffff23 bl c454 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
c7c4: e2503000 subs r3, r0, #0
c7c8: 0afffff0 beq c790 <IMFS_memfile_read+0x130>
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
c7cc: e1a00008 mov r0, r8
c7d0: e5931000 ldr r1, [r3]
c7d4: e1a02005 mov r2, r5
c7d8: eb0007ff bl e7dc <memcpy>
copied += my_length;
c7dc: e08aa005 add sl, sl, r5
}
IMFS_update_atime( the_jnode );
c7e0: e28d000c add r0, sp, #12
c7e4: e3a01000 mov r1, #0
c7e8: ebffd6e8 bl 2390 <gettimeofday>
c7ec: e59d300c ldr r3, [sp, #12]
return copied;
c7f0: e1a0000a mov r0, sl
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
c7f4: e5893040 str r3, [r9, #64] ; 0x40
return copied;
c7f8: eaffffe5 b c794 <IMFS_memfile_read+0x134>
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))
c7fc: e2894050 add r4, r9, #80 ; 0x50
c800: e8940018 ldm r4, {r3, r4}
c804: e1a00003 mov r0, r3
c808: e1a01004 mov r1, r4
c80c: e3a02000 mov r2, #0
c810: e0500007 subs r0, r0, r7
c814: e0c11008 sbc r1, r1, r8
c818: e1520001 cmp r2, r1
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
c81c: e5992058 ldr r2, [r9, #88] ; 0x58
if (my_length > (the_jnode->info.linearfile.size - start))
c820: da00000b ble c854 <IMFS_memfile_read+0x1f4>
my_length = the_jnode->info.linearfile.size - start;
c824: e067a003 rsb sl, r7, r3
memcpy(dest, &file_ptr[start], my_length);
c828: e0821007 add r1, r2, r7
c82c: e1a0000b mov r0, fp
c830: e1a0200a mov r2, sl
c834: eb0007e8 bl e7dc <memcpy>
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
c838: e28d000c add r0, sp, #12
c83c: e3a01000 mov r1, #0
c840: ebffd6d2 bl 2390 <gettimeofday>
c844: e59d300c ldr r3, [sp, #12]
return copied;
c848: e1a0000a mov r0, sl
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
c84c: e5893040 str r3, [r9, #64] ; 0x40
c850: eaffffcf b c794 <IMFS_memfile_read+0x134>
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))
c854: 1a000001 bne c860 <IMFS_memfile_read+0x200>
c858: e1550000 cmp r5, r0
c85c: 8afffff0 bhi c824 <IMFS_memfile_read+0x1c4>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
c860: e1a0a005 mov sl, r5 <== NOT EXECUTED
c864: eaffffef b c828 <IMFS_memfile_read+0x1c8> <== NOT EXECUTED
0000cbe8 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
cbe8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
cbec: e1a09000 mov r9, r0
cbf0: e24dd010 sub sp, sp, #16
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
cbf4: e5900054 ldr r0, [r0, #84] ; 0x54
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
cbf8: e59db034 ldr fp, [sp, #52] ; 0x34
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
cbfc: e3500000 cmp r0, #0
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
cc00: e1a06001 mov r6, r1
cc04: e1a07002 mov r7, r2
cc08: e1a08003 mov r8, r3
/*
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
cc0c: e08b1001 add r1, fp, r1
if ( last_byte > the_jnode->info.file.size ) {
cc10: ba000054 blt cd68 <IMFS_memfile_write+0x180>
cc14: 0a000050 beq cd5c <IMFS_memfile_write+0x174>
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
cc18: e59f5170 ldr r5, [pc, #368] ; cd90 <IMFS_memfile_write+0x1a8>
cc1c: e5954000 ldr r4, [r5]
cc20: e1a00006 mov r0, r6
cc24: e1a02004 mov r2, r4
cc28: e1a03fc2 asr r3, r2, #31
cc2c: e1a01007 mov r1, r7
cc30: e88d000c stm sp, {r2, r3}
cc34: eb001424 bl 11ccc <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
cc38: e1a01007 mov r1, r7
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
cc3c: e1a0a000 mov sl, r0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
cc40: e89d000c ldm sp, {r2, r3}
cc44: e1a00006 mov r0, r6
cc48: eb0012f2 bl 11818 <__divdi3>
if ( start_offset ) {
cc4c: e35a0000 cmp sl, #0
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
cc50: e1a07000 mov r7, r0
if ( start_offset ) {
cc54: 01a0600b moveq r6, fp
cc58: 1a000016 bne ccb8 <IMFS_memfile_write+0xd0>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
cc5c: e1560004 cmp r6, r4
cc60: 2a000008 bcs cc88 <IMFS_memfile_write+0xa0>
cc64: ea000027 b cd08 <IMFS_memfile_write+0x120>
if ( !block_ptr )
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 );
cc68: e5900000 ldr r0, [r0]
cc6c: eb0006da bl e7dc <memcpy>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
cc70: e5953000 ldr r3, [r5]
cc74: e1530006 cmp r3, r6
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 );
src += to_copy;
cc78: e0888004 add r8, r8, r4
block++;
cc7c: e2877001 add r7, r7, #1
* IMFS_memfile_write * * This routine writes the specified data buffer into the in memory * file pointed to by the_jnode. The file is extended as needed. */ MEMFILE_STATIC ssize_t IMFS_memfile_write(
cc80: e08aa004 add sl, sl, r4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
cc84: 8a00001f bhi cd08 <IMFS_memfile_write+0x120>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
cc88: e1a01007 mov r1, r7
cc8c: e3a02000 mov r2, #0
cc90: e1a00009 mov r0, r9
cc94: ebfffdee bl c454 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
cc98: e3500000 cmp r0, #0
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 );
cc9c: e1a01008 mov r1, r8
cca0: e1a02004 mov r2, r4
src += to_copy;
block++;
my_length -= to_copy;
cca4: e0646006 rsb r6, r4, r6
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
cca8: 1affffee bne cc68 <IMFS_memfile_write+0x80>
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
ccac: e1a0000a mov r0, sl <== NOT EXECUTED
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
ccb0: e28dd010 add sp, sp, #16
ccb4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
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 );
ccb8: e1a00009 mov r0, r9
ccbc: e1a01007 mov r1, r7
ccc0: e3a02000 mov r2, #0
ccc4: ebfffde2 bl c454 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
ccc8: e3500000 cmp r0, #0
cccc: 0afffff7 beq ccb0 <IMFS_memfile_write+0xc8>
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
ccd0: e06a4004 rsb r4, sl, r4
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
ccd4: e5900000 ldr r0, [r0]
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
ccd8: e154000b cmp r4, fp
ccdc: 21a0400b movcs r4, fp
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
cce0: e080000a add r0, r0, sl
cce4: e1a01008 mov r1, r8
cce8: e1a02004 mov r2, r4
ccec: eb0006ba bl e7dc <memcpy>
src += to_copy;
ccf0: e0888004 add r8, r8, r4
block++;
my_length -= to_copy;
ccf4: e064600b rsb r6, r4, fp
copied += to_copy;
ccf8: e1a0a004 mov sl, r4
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
src += to_copy;
block++;
ccfc: e2877001 add r7, r7, #1
my_length -= to_copy;
copied += to_copy;
cd00: e5954000 ldr r4, [r5]
cd04: eaffffd4 b cc5c <IMFS_memfile_write+0x74>
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
cd08: e3560000 cmp r6, #0
cd0c: 0a00000a beq cd3c <IMFS_memfile_write+0x154>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
cd10: e1a00009 mov r0, r9
cd14: e1a01007 mov r1, r7
cd18: e3a02000 mov r2, #0
cd1c: ebfffdcc bl c454 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
cd20: e3500000 cmp r0, #0
cd24: 0affffe0 beq ccac <IMFS_memfile_write+0xc4>
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 );
cd28: e5900000 ldr r0, [r0]
cd2c: e1a01008 mov r1, r8
cd30: e1a02006 mov r2, r6
cd34: eb0006a8 bl e7dc <memcpy>
my_length = 0;
copied += to_copy;
cd38: e08aa006 add sl, sl, r6
}
IMFS_mtime_ctime_update( the_jnode );
cd3c: e28d0008 add r0, sp, #8
cd40: e3a01000 mov r1, #0
cd44: ebffd591 bl 2390 <gettimeofday>
cd48: e59d3008 ldr r3, [sp, #8]
return copied;
cd4c: e1a0000a mov r0, sl
memcpy( &(*block_ptr)[ 0 ], src, my_length );
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
cd50: e5893044 str r3, [r9, #68] ; 0x44
cd54: e5893048 str r3, [r9, #72] ; 0x48
return copied;
cd58: eaffffd4 b ccb0 <IMFS_memfile_write+0xc8>
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
cd5c: e5993050 ldr r3, [r9, #80] ; 0x50
cd60: e1530001 cmp r3, r1
cd64: 2affffab bcs cc18 <IMFS_memfile_write+0x30>
status = IMFS_memfile_extend( the_jnode, last_byte );
cd68: e1a00009 mov r0, r9
cd6c: e3a02000 mov r2, #0
cd70: ebffff4f bl cab4 <IMFS_memfile_extend>
if ( status )
cd74: e3500000 cmp r0, #0
cd78: 0affffa6 beq cc18 <IMFS_memfile_write+0x30>
rtems_set_errno_and_return_minus_one( ENOSPC );
cd7c: eb000468 bl df24 <__errno>
cd80: e3a0301c mov r3, #28
cd84: e5803000 str r3, [r0]
cd88: e3e00000 mvn r0, #0
cd8c: eaffffc7 b ccb0 <IMFS_memfile_write+0xc8>
00001c54 <IMFS_mount>:
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
1c54: e5903008 ldr r3, [r0, #8]
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
1c58: e593204c ldr r2, [r3, #76] ; 0x4c
1c5c: e3520001 cmp r2, #1
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
1c60: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
1c64: 1a000002 bne 1c74 <IMFS_mount+0x20>
/*
* Set mt_fs pointer to point to the mount table entry for
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
1c68: e583005c str r0, [r3, #92] ; 0x5c
return 0;
1c6c: e3a00000 mov r0, #0
}
1c70: e49df004 pop {pc} ; (ldr pc, [sp], #4)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
1c74: eb0030aa bl df24 <__errno> <== NOT EXECUTED
1c78: e3a03014 mov r3, #20 <== NOT EXECUTED
1c7c: e5803000 str r3, [r0] <== NOT EXECUTED
1c80: e3e00000 mvn r0, #0 <== NOT EXECUTED
1c84: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00004650 <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
4650: e92d4030 push {r4, r5, lr}
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
4654: e59f50f8 ldr r5, [pc, #248] ; 4754 <IMFS_print_jnode+0x104>
4658: e5953000 ldr r3, [r5]
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
465c: e1a04000 mov r4, r0
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
4660: e5931008 ldr r1, [r3, #8]
4664: e280000c add r0, r0, #12
4668: eb003881 bl 12874 <fputs>
switch( the_jnode->type ) {
466c: e594204c ldr r2, [r4, #76] ; 0x4c
4670: e2423001 sub r3, r2, #1
4674: e3530006 cmp r3, #6
4678: 979ff103 ldrls pc, [pc, r3, lsl #2]
467c: ea000023 b 4710 <IMFS_print_jnode+0xc0> <== NOT EXECUTED
4680: 00004724 .word 0x00004724 <== NOT EXECUTED
4684: 00004738 .word 0x00004738 <== NOT EXECUTED
4688: 0000469c .word 0x0000469c <== NOT EXECUTED
468c: 0000469c .word 0x0000469c <== NOT EXECUTED
4690: 000046d4 .word 0x000046d4 <== NOT EXECUTED
4694: 000046f4 .word 0x000046f4 <== NOT EXECUTED
4698: 000046b8 .word 0x000046b8 <== NOT EXECUTED
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
469c: e5953000 ldr r3, [r5]
46a0: e59f00b0 ldr r0, [pc, #176] ; 4758 <IMFS_print_jnode+0x108>
46a4: e5933008 ldr r3, [r3, #8]
46a8: e3a01001 mov r1, #1
46ac: e3a02013 mov r2, #19
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
}
46b0: e8bd4030 pop {r4, r5, lr}
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
46b4: ea003b9e b 13534 <fwrite>
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
46b8: e5953000 ldr r3, [r5]
46bc: e59f0098 ldr r0, [pc, #152] ; 475c <IMFS_print_jnode+0x10c>
46c0: e5933008 ldr r3, [r3, #8]
46c4: e3a01001 mov r1, #1
46c8: e3a02012 mov r2, #18
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
}
46cc: e8bd4030 pop {r4, r5, lr}
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
46d0: ea003b97 b 13534 <fwrite>
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
46d4: e5953000 ldr r3, [r5]
46d8: e59f1080 ldr r1, [pc, #128] ; 4760 <IMFS_print_jnode+0x110>
46dc: e5930008 ldr r0, [r3, #8]
46e0: e5942050 ldr r2, [r4, #80] ; 0x50
46e4: eb00380d bl 12720 <fprintf>
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
46e8: e59f0074 ldr r0, [pc, #116] ; 4764 <IMFS_print_jnode+0x114>
}
46ec: e8bd4030 pop {r4, r5, lr}
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
46f0: ea003f71 b 144bc <puts>
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
46f4: e5953000 ldr r3, [r5]
46f8: e59f1068 ldr r1, [pc, #104] ; 4768 <IMFS_print_jnode+0x118>
46fc: e5930008 ldr r0, [r3, #8]
4700: e5942050 ldr r2, [r4, #80] ; 0x50
4704: e5943058 ldr r3, [r4, #88] ; 0x58
4708: eb003804 bl 12720 <fprintf>
(uint32_t)the_jnode->info.linearfile.size,
the_jnode->info.linearfile.direct
);
break;
470c: eafffff5 b 46e8 <IMFS_print_jnode+0x98>
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
4710: e5953000 ldr r3, [r5] <== NOT EXECUTED
4714: e59f1050 ldr r1, [pc, #80] ; 476c <IMFS_print_jnode+0x11c> <== NOT EXECUTED
4718: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
return;
}
puts("");
}
471c: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
4720: ea0037fe b 12720 <fprintf> <== NOT EXECUTED
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( the_jnode->type ) {
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
4724: e5953000 ldr r3, [r5]
4728: e3a0002f mov r0, #47 ; 0x2f
472c: e5931008 ldr r1, [r3, #8]
4730: eb00381a bl 127a0 <fputc>
break;
4734: eaffffeb b 46e8 <IMFS_print_jnode+0x98>
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
4738: e5953000 ldr r3, [r5]
473c: e59f102c ldr r1, [pc, #44] ; 4770 <IMFS_print_jnode+0x120>
4740: e5930008 ldr r0, [r3, #8]
4744: e2842050 add r2, r4, #80 ; 0x50
4748: e892000c ldm r2, {r2, r3}
474c: eb0037f3 bl 12720 <fprintf>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
4750: eaffffe4 b 46e8 <IMFS_print_jnode+0x98>
0000a368 <IMFS_stat>:
{
IMFS_fs_info_t *fs_info;
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
a368: e5903000 ldr r3, [r0]
switch ( the_jnode->type ) {
a36c: e593204c ldr r2, [r3, #76] ; 0x4c
a370: e2422002 sub r2, r2, #2
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
a374: e92d41f0 push {r4, r5, r6, r7, r8, lr}
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
a378: e3520005 cmp r2, #5
a37c: 979ff102 ldrls pc, [pc, r2, lsl #2]
a380: ea000027 b a424 <IMFS_stat+0xbc> <== NOT EXECUTED
a384: 0000a410 .word 0x0000a410 <== NOT EXECUTED
a388: 0000a424 .word 0x0000a424 <== NOT EXECUTED
a38c: 0000a39c .word 0x0000a39c <== NOT EXECUTED
a390: 0000a438 .word 0x0000a438 <== NOT EXECUTED
a394: 0000a438 .word 0x0000a438 <== NOT EXECUTED
a398: 0000a39c .word 0x0000a39c <== NOT EXECUTED
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
a39c: e3a04000 mov r4, #0
a3a0: e3a05000 mov r5, #0
a3a4: e5814020 str r4, [r1, #32]
a3a8: e5815024 str r5, [r1, #36] ; 0x24
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
a3ac: e5902010 ldr r2, [r0, #16]
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
a3b0: e5922034 ldr r2, [r2, #52] ; 0x34
a3b4: e5927000 ldr r7, [r2]
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
a3b8: e3a02cff mov r2, #65280 ; 0xff00
a3bc: e28220fe add r2, r2, #254 ; 0xfe
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
a3c0: e5930048 ldr r0, [r3, #72] ; 0x48
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
a3c4: e5936030 ldr r6, [r3, #48] ; 0x30
buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino;
a3c8: e5935038 ldr r5, [r3, #56] ; 0x38
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
a3cc: e2834040 add r4, r3, #64 ; 0x40
a3d0: e8941010 ldm r4, {r4, ip}
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
a3d4: e1d383b4 ldrh r8, [r3, #52] ; 0x34
/* * 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 =
a3d8: e5812000 str r2, [r1]
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
a3dc: e1d323bc ldrh r2, [r3, #60] ; 0x3c
buf->st_gid = the_jnode->st_gid;
a3e0: e1d333be ldrh r3, [r3, #62] ; 0x3e
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
a3e4: e1c181b0 strh r8, [r1, #16]
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
a3e8: e5810038 str r0, [r1, #56] ; 0x38
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
a3ec: e1c121b2 strh r2, [r1, #18]
/* * 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 =
a3f0: e5817004 str r7, [r1, #4]
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
a3f4: e1c131b4 strh r3, [r1, #20]
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
a3f8: e581600c str r6, [r1, #12]
buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino;
a3fc: e5815008 str r5, [r1, #8]
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
a400: e5814028 str r4, [r1, #40] ; 0x28
buf->st_mtime = the_jnode->stat_mtime;
a404: e581c030 str ip, [r1, #48] ; 0x30
buf->st_ctime = the_jnode->stat_ctime;
return 0;
a408: e3a00000 mov r0, #0
}
a40c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
switch ( the_jnode->type ) {
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
a410: e2832050 add r2, r3, #80 ; 0x50
a414: e8921004 ldm r2, {r2, ip}
a418: e581c01c str ip, [r1, #28]
a41c: e5812018 str r2, [r1, #24]
break;
a420: eaffffe1 b a3ac <IMFS_stat+0x44>
case IMFS_FIFO:
buf->st_size = 0;
break;
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
a424: eb000ebe bl df24 <__errno>
a428: e3a03086 mov r3, #134 ; 0x86
a42c: e5803000 str r3, [r0]
a430: e3e00000 mvn r0, #0
a434: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
break;
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
a438: e2835050 add r5, r3, #80 ; 0x50
a43c: e8950030 ldm r5, {r4, r5}
a440: e5814020 str r4, [r1, #32]
a444: e5815024 str r5, [r1, #36] ; 0x24
break;
a448: eaffffd7 b a3ac <IMFS_stat+0x44>
00001df0 <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
1df0: e92d41f0 push {r4, r5, r6, r7, r8, lr}
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
1df4: e5915000 ldr r5, [r1]
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
1df8: e595304c ldr r3, [r5, #76] ; 0x4c
1dfc: e3530003 cmp r3, #3
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
1e00: e24dd01c sub sp, sp, #28
1e04: e1a04001 mov r4, r1
1e08: e1a06000 mov r6, r0
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
1e0c: 0a000006 beq 1e2c <IMFS_unlink+0x3c>
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
1e10: e5943008 ldr r3, [r4, #8]
1e14: e1a00006 mov r0, r6
1e18: e1a01004 mov r1, r4
1e1c: e1a0e00f mov lr, pc
1e20: e593f034 ldr pc, [r3, #52] ; 0x34
return result;
}
1e24: e28dd01c add sp, sp, #28
1e28: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
1e2c: e595e050 ldr lr, [r5, #80] ; 0x50
1e30: e35e0000 cmp lr, #0
1e34: 0a00001f beq 1eb8 <IMFS_unlink+0xc8>
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
1e38: e1a07001 mov r7, r1
1e3c: e8b7000f ldm r7!, {r0, r1, r2, r3}
1e40: e1a0c00d mov ip, sp
1e44: e8ac000f stmia ip!, {r0, r1, r2, r3}
the_link.node_access = node->info.hard_link.link_node;
1e48: e28d801c add r8, sp, #28
1e4c: e528e01c str lr, [r8, #-28]!
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
1e50: e5973000 ldr r3, [r7]
the_link.node_access = node->info.hard_link.link_node;
IMFS_Set_handlers( &the_link );
1e54: e1a0000d mov r0, sp
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
1e58: e58c3000 str r3, [ip]
the_link.node_access = node->info.hard_link.link_node;
IMFS_Set_handlers( &the_link );
1e5c: eb001e94 bl 98b4 <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)
1e60: e5953050 ldr r3, [r5, #80] ; 0x50
1e64: e1d323b4 ldrh r2, [r3, #52] ; 0x34
1e68: e3520001 cmp r2, #1
1e6c: 0a000008 beq 1e94 <IMFS_unlink+0xa4>
if ( result != 0 )
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
1e70: e2422001 sub r2, r2, #1
1e74: e1c323b4 strh r2, [r3, #52] ; 0x34
IMFS_update_ctime( node->info.hard_link.link_node );
1e78: e28d0014 add r0, sp, #20
1e7c: e3a01000 mov r1, #0
1e80: eb000142 bl 2390 <gettimeofday>
1e84: e5953050 ldr r3, [r5, #80] ; 0x50
1e88: e59d2014 ldr r2, [sp, #20]
1e8c: e5832048 str r2, [r3, #72] ; 0x48
1e90: eaffffde b 1e10 <IMFS_unlink+0x20>
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
1e94: e1a00006 mov r0, r6
1e98: e1a0100d mov r1, sp
1e9c: e59d3008 ldr r3, [sp, #8]
1ea0: e1a0e00f mov lr, pc
1ea4: e593f034 ldr pc, [r3, #52] ; 0x34
if ( result != 0 )
1ea8: e3500000 cmp r0, #0
1eac: 0affffd7 beq 1e10 <IMFS_unlink+0x20>
return -1;
1eb0: e3e00000 mvn r0, #0
1eb4: eaffffda b 1e24 <IMFS_unlink+0x34>
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
1eb8: eb003019 bl df24 <__errno> <== NOT EXECUTED
1ebc: e3a03016 mov r3, #22 <== NOT EXECUTED
1ec0: e5803000 str r3, [r0] <== NOT EXECUTED
1ec4: e3e00000 mvn r0, #0 <== NOT EXECUTED
1ec8: eaffffd5 b 1e24 <IMFS_unlink+0x34> <== NOT EXECUTED
00001ecc <IMFS_unmount>:
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
1ecc: e5903008 ldr r3, [r0, #8]
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
1ed0: e593204c ldr r2, [r3, #76] ; 0x4c
1ed4: e3520001 cmp r2, #1
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
1ed8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
1edc: 1a000005 bne 1ef8 <IMFS_unmount+0x2c>
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
1ee0: e593205c ldr r2, [r3, #92] ; 0x5c
1ee4: e3520000 cmp r2, #0
1ee8: 0a000007 beq 1f0c <IMFS_unmount+0x40>
/*
* 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;
1eec: e3a00000 mov r0, #0
1ef0: e583005c str r0, [r3, #92] ; 0x5c
return 0;
}
1ef4: e49df004 pop {pc} ; (ldr pc, [sp], #4)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
1ef8: eb003009 bl df24 <__errno> <== NOT EXECUTED
1efc: e3a03014 mov r3, #20 <== NOT EXECUTED
1f00: e5803000 str r3, [r0] <== NOT EXECUTED
1f04: e3e00000 mvn r0, #0 <== NOT EXECUTED
1f08: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
1f0c: eb003004 bl df24 <__errno> <== NOT EXECUTED
1f10: e3a03016 mov r3, #22 <== NOT EXECUTED
1f14: e5803000 str r3, [r0] <== NOT EXECUTED
1f18: e3e00000 mvn r0, #0 <== NOT EXECUTED
1f1c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00002268 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
2268: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
226c: e59030bc ldr r3, [r0, #188] ; 0xbc
size = Stack_check_usable_stack_size(stack);
2270: e59060b8 ldr r6, [r0, #184] ; 0xb8
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
2274: e283c010 add ip, r3, #16
size = Stack_check_usable_stack_size(stack);
2278: e2466010 sub r6, r6, #16
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
227c: e28cb010 add fp, ip, #16
for (ebase = base + length; base < ebase; base++)
2280: e3c61003 bic r1, r6, #3
2284: e08b1001 add r1, fp, r1
2288: e15b0001 cmp fp, r1
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
228c: e24dd010 sub sp, sp, #16
2290: e1a05000 mov r5, r0
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
2294: e59090e8 ldr r9, [r0, #232] ; 0xe8
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
2298: 2a00000d bcs 22d4 <Stack_check_Dump_threads_usage+0x6c>
if (*base != U32_PATTERN)
229c: e3a02ca6 mov r2, #42496 ; 0xa600
22a0: e242205b sub r2, r2, #91 ; 0x5b
22a4: e59c0010 ldr r0, [ip, #16]
22a8: e1822802 orr r2, r2, r2, lsl #16
22ac: e1500002 cmp r0, r2
* Try to print out how much stack was actually used by the task.
*/
static void *print_context;
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
22b0: 02833024 addeq r3, r3, #36 ; 0x24
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
if (*base != U32_PATTERN)
22b4: 0a000003 beq 22c8 <Stack_check_Dump_threads_usage+0x60>
22b8: ea000027 b 235c <Stack_check_Dump_threads_usage+0xf4> <== NOT EXECUTED
22bc: e4932004 ldr r2, [r3], #4
22c0: e1520000 cmp r2, r0
22c4: 1a000024 bne 235c <Stack_check_Dump_threads_usage+0xf4>
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
22c8: e1510003 cmp r1, r3
if (*base != U32_PATTERN)
22cc: e1a0b003 mov fp, r3
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
22d0: 8afffff9 bhi 22bc <Stack_check_Dump_threads_usage+0x54>
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
used = Stack_check_Calculate_used( low, size, high_water_mark );
else
used = 0;
22d4: e3a0b000 mov fp, #0 <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
#endif
{
(*print_handler)(
22d8: e5958008 ldr r8, [r5, #8]
22dc: e59f409c ldr r4, [pc, #156] ; 2380 <Stack_check_Dump_threads_usage+0x118>
22e0: e3a01005 mov r1, #5
22e4: e28d2008 add r2, sp, #8
22e8: e1a00008 mov r0, r8
22ec: e8940480 ldm r4, {r7, sl}
22f0: eb001860 bl 8478 <rtems_object_get_name>
22f4: e1a02008 mov r2, r8
22f8: e1a03000 mov r3, r0
22fc: e59f1080 ldr r1, [pc, #128] ; 2384 <Stack_check_Dump_threads_usage+0x11c>
2300: e1a0000a mov r0, sl
2304: e1a0e00f mov lr, pc
2308: e12fff17 bx r7
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
230c: e59530b8 ldr r3, [r5, #184] ; 0xb8
2310: e59520bc ldr r2, [r5, #188] ; 0xbc
2314: e2433001 sub r3, r3, #1
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
2318: e0823003 add r3, r2, r3
231c: e5940004 ldr r0, [r4, #4]
2320: e58d9000 str r9, [sp]
2324: e58d6004 str r6, [sp, #4]
2328: e59f1058 ldr r1, [pc, #88] ; 2388 <Stack_check_Dump_threads_usage+0x120>
232c: e1a0e00f mov lr, pc
2330: e594f000 ldr pc, [r4]
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
2334: e5943008 ldr r3, [r4, #8]
2338: e3530000 cmp r3, #0
233c: 0a00000a beq 236c <Stack_check_Dump_threads_usage+0x104>
(*print_handler)( print_context, "Unavailable\n" );
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
2340: e5940004 ldr r0, [r4, #4]
2344: e59f1040 ldr r1, [pc, #64] ; 238c <Stack_check_Dump_threads_usage+0x124>
2348: e1a0200b mov r2, fp
234c: e1a0e00f mov lr, pc
2350: e594f000 ldr pc, [r4]
}
}
2354: e28dd010 add sp, sp, #16
2358: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
235c: e35b0000 cmp fp, #0
used = Stack_check_Calculate_used( low, size, high_water_mark );
2360: 108cc006 addne ip, ip, r6
2364: 106bb00c rsbne fp, fp, ip
2368: eaffffda b 22d8 <Stack_check_Dump_threads_usage+0x70>
current,
size
);
if (Stack_check_Initialized == 0) {
(*print_handler)( print_context, "Unavailable\n" );
236c: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED
2370: e59f1018 ldr r1, [pc, #24] ; 2390 <Stack_check_Dump_threads_usage+0x128><== NOT EXECUTED
2374: e1a0e00f mov lr, pc <== NOT EXECUTED
2378: e594f000 ldr pc, [r4] <== NOT EXECUTED
237c: eafffff4 b 2354 <Stack_check_Dump_threads_usage+0xec> <== NOT EXECUTED
0000bc6c <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
bc6c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
bc70: e1a08002 mov r8, r2
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
bc74: e5902010 ldr r2, [r0, #16]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
bc78: e24dd01c sub sp, sp, #28
bc7c: e1a05001 mov r5, r1
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
bc80: e2911004 adds r1, r1, #4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
bc84: e1a07000 mov r7, r0
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
bc88: e58d1000 str r1, [sp]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
bc8c: e1a0b003 mov fp, r3
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
bc90: e58d200c str r2, [sp, #12]
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
bc94: 2a00007a bcs be84 <_Heap_Allocate_aligned_with_boundary+0x218>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
bc98: e3530000 cmp r3, #0
bc9c: 1a000076 bne be7c <_Heap_Allocate_aligned_with_boundary+0x210>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
bca0: e5979008 ldr r9, [r7, #8]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
bca4: e1570009 cmp r7, r9
bca8: 0a000075 beq be84 <_Heap_Allocate_aligned_with_boundary+0x218>
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
bcac: e59d300c ldr r3, [sp, #12]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
bcb0: e2651004 rsb r1, r5, #4
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
bcb4: e2833007 add r3, r3, #7
bcb8: e58d3010 str r3, [sp, #16]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
bcbc: e58d1014 str r1, [sp, #20]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
bcc0: e3a06001 mov r6, #1
/*
* 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 ) {
bcc4: e599a004 ldr sl, [r9, #4]
bcc8: e59d2000 ldr r2, [sp]
bccc: e152000a cmp r2, sl
bcd0: 2a000050 bcs be18 <_Heap_Allocate_aligned_with_boundary+0x1ac>
if ( alignment == 0 ) {
bcd4: e3580000 cmp r8, #0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
bcd8: 02894008 addeq r4, r9, #8
bcdc: 0a000053 beq be30 <_Heap_Allocate_aligned_with_boundary+0x1c4>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
bce0: e5973014 ldr r3, [r7, #20]
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;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
bce4: e59d1014 ldr r1, [sp, #20]
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
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
bce8: e59d2010 ldr r2, [sp, #16]
- 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;
bcec: e3caa001 bic sl, sl, #1
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
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;
bcf0: e089a00a add sl, r9, sl
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;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
bcf4: e081400a add r4, r1, sl
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
bcf8: e58d3004 str r3, [sp, #4]
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
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
bcfc: e0633002 rsb r3, r3, r2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
bd00: e1a00004 mov r0, r4
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
bd04: e083a00a add sl, r3, sl
bd08: e1a01008 mov r1, r8
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
bd0c: e2893008 add r3, r9, #8
bd10: e58d3008 str r3, [sp, #8]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
bd14: eb00168b bl 11748 <__umodsi3>
bd18: e0604004 rsb r4, r0, r4
uintptr_t alloc_begin = alloc_end - alloc_size;
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 ) {
bd1c: e15a0004 cmp sl, r4
bd20: 2a000003 bcs bd34 <_Heap_Allocate_aligned_with_boundary+0xc8>
bd24: e1a0000a mov r0, sl
bd28: e1a01008 mov r1, r8
bd2c: eb001685 bl 11748 <__umodsi3>
bd30: e060400a rsb r4, r0, sl
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
bd34: e35b0000 cmp fp, #0
bd38: 0a000026 beq bdd8 <_Heap_Allocate_aligned_with_boundary+0x16c>
/* 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;
bd3c: e084a005 add sl, r4, r5
bd40: e1a0000a mov r0, sl
bd44: e1a0100b mov r1, fp
bd48: eb00167e bl 11748 <__umodsi3>
bd4c: e060000a rsb r0, r0, sl
/* 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 ) {
bd50: e15a0000 cmp sl, r0
bd54: 93a0a000 movls sl, #0
bd58: 83a0a001 movhi sl, #1
bd5c: e1540000 cmp r4, r0
bd60: 23a0a000 movcs sl, #0
bd64: e35a0000 cmp sl, #0
bd68: 0a00001a beq bdd8 <_Heap_Allocate_aligned_with_boundary+0x16c>
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
bd6c: e59d1008 ldr r1, [sp, #8]
bd70: e0813005 add r3, r1, r5
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
bd74: e1530000 cmp r3, r0
bd78: 958d9018 strls r9, [sp, #24]
bd7c: 91a09003 movls r9, r3
bd80: 9a000002 bls bd90 <_Heap_Allocate_aligned_with_boundary+0x124>
bd84: ea000023 b be18 <_Heap_Allocate_aligned_with_boundary+0x1ac>
bd88: e1590000 cmp r9, r0
bd8c: 8a00003e bhi be8c <_Heap_Allocate_aligned_with_boundary+0x220>
return 0;
}
alloc_begin = boundary_line - alloc_size;
bd90: e0654000 rsb r4, r5, r0
bd94: e1a01008 mov r1, r8
bd98: e1a00004 mov r0, r4
bd9c: eb001669 bl 11748 <__umodsi3>
bda0: e0604004 rsb r4, r0, r4
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
bda4: e084a005 add sl, r4, r5
bda8: e1a0000a mov r0, sl
bdac: e1a0100b mov r1, fp
bdb0: eb001664 bl 11748 <__umodsi3>
bdb4: e060000a rsb r0, r0, sl
/* 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 ) {
bdb8: e15a0000 cmp sl, r0
bdbc: 93a0a000 movls sl, #0
bdc0: 83a0a001 movhi sl, #1
bdc4: e1540000 cmp r4, r0
bdc8: 23a0a000 movcs sl, #0
bdcc: e35a0000 cmp sl, #0
bdd0: 1affffec bne bd88 <_Heap_Allocate_aligned_with_boundary+0x11c>
bdd4: e59d9018 ldr r9, [sp, #24]
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 ) {
bdd8: e59d2008 ldr r2, [sp, #8]
bddc: e1520004 cmp r2, r4
bde0: 8a00000c bhi be18 <_Heap_Allocate_aligned_with_boundary+0x1ac>
bde4: e59d100c ldr r1, [sp, #12]
bde8: e1a00004 mov r0, r4
bdec: eb001655 bl 11748 <__umodsi3>
bdf0: e269a4ff rsb sl, r9, #-16777216 ; 0xff000000
bdf4: e28aa8ff add sl, sl, #16711680 ; 0xff0000
bdf8: e28aacff add sl, sl, #65280 ; 0xff00
bdfc: e28aa0f8 add sl, sl, #248 ; 0xf8
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
be00: e08aa004 add sl, sl, r4
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 ) {
be04: e59d1004 ldr r1, [sp, #4]
be08: e060300a rsb r3, r0, sl
be0c: e15a0000 cmp sl, r0
be10: 11510003 cmpne r1, r3
be14: 9a000005 bls be30 <_Heap_Allocate_aligned_with_boundary+0x1c4>
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
be18: e5999008 ldr r9, [r9, #8]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
be1c: e1570009 cmp r7, r9
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
be20: e2863001 add r3, r6, #1
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
be24: 0a00001d beq bea0 <_Heap_Allocate_aligned_with_boundary+0x234>
be28: e1a06003 mov r6, r3
be2c: eaffffa4 b bcc4 <_Heap_Allocate_aligned_with_boundary+0x58>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
be30: e3540000 cmp r4, #0
be34: 0afffff7 beq be18 <_Heap_Allocate_aligned_with_boundary+0x1ac>
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
be38: e2872048 add r2, r7, #72 ; 0x48
be3c: e892000c ldm r2, {r2, r3}
be40: e2822001 add r2, r2, #1
stats->searches += search_count;
be44: e0833006 add r3, r3, r6
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
be48: e5872048 str r2, [r7, #72] ; 0x48
stats->searches += search_count;
be4c: e587304c str r3, [r7, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
be50: e1a00007 mov r0, r7
be54: e1a01009 mov r1, r9
be58: e1a02004 mov r2, r4
be5c: e1a03005 mov r3, r5
be60: ebffeb5e bl 6be0 <_Heap_Block_allocate>
be64: e1a00004 mov r0, r4
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
be68: e5973044 ldr r3, [r7, #68] ; 0x44
be6c: e1530006 cmp r3, r6
stats->max_search = search_count;
be70: 35876044 strcc r6, [r7, #68] ; 0x44
}
return (void *) alloc_begin;
}
be74: e28dd01c add sp, sp, #28
be78: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
be7c: e1550003 cmp r5, r3
be80: 9a000008 bls bea8 <_Heap_Allocate_aligned_with_boundary+0x23c>
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
be84: e3a00000 mov r0, #0
be88: eafffff9 b be74 <_Heap_Allocate_aligned_with_boundary+0x208>
be8c: e59d9018 ldr r9, [sp, #24] <== NOT EXECUTED
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
be90: e5999008 ldr r9, [r9, #8] <== NOT EXECUTED
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
be94: e1570009 cmp r7, r9 <== NOT EXECUTED
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
be98: e2863001 add r3, r6, #1 <== NOT EXECUTED
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
be9c: 1affffe1 bne be28 <_Heap_Allocate_aligned_with_boundary+0x1bc><== NOT EXECUTED
bea0: e3a00000 mov r0, #0
bea4: eaffffef b be68 <_Heap_Allocate_aligned_with_boundary+0x1fc>
if ( boundary < alloc_size ) {
return NULL;
}
if ( alignment == 0 ) {
alignment = page_size;
bea8: e3580000 cmp r8, #0
beac: 01a08002 moveq r8, r2
beb0: eaffff7a b bca0 <_Heap_Allocate_aligned_with_boundary+0x34>
0000beb4 <_Heap_Free>:
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
beb4: e2513000 subs r3, r1, #0
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
beb8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
bebc: e1a04000 mov r4, r0
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
return true;
bec0: 03a00001 moveq r0, #1
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
bec4: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
bec8: e1a00003 mov r0, r3
becc: e5941010 ldr r1, [r4, #16]
bed0: e2435008 sub r5, r3, #8
bed4: eb00161b bl 11748 <__umodsi3>
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
bed8: e5942020 ldr r2, [r4, #32]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
bedc: e0605005 rsb r5, r0, r5
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;
bee0: e1550002 cmp r5, r2
bee4: 3a00002f bcc bfa8 <_Heap_Free+0xf4>
bee8: e5941024 ldr r1, [r4, #36] ; 0x24
beec: e1550001 cmp r5, r1
bef0: 8a00002c bhi bfa8 <_Heap_Free+0xf4>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
bef4: e595c004 ldr ip, [r5, #4]
- 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;
bef8: e3cc6001 bic r6, ip, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
befc: e0853006 add r3, r5, r6
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;
bf00: e1520003 cmp r2, r3
bf04: 8a000027 bhi bfa8 <_Heap_Free+0xf4>
bf08: e1510003 cmp r1, r3
bf0c: 3a000027 bcc bfb0 <_Heap_Free+0xfc>
bf10: e5937004 ldr r7, [r3, #4]
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
bf14: e2170001 ands r0, r7, #1
bf18: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
bf1c: e1510003 cmp r1, r3
- 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;
bf20: e3c77001 bic r7, r7, #1
bf24: 03a08000 moveq r8, #0
bf28: 0a000004 beq bf40 <_Heap_Free+0x8c>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
bf2c: e0830007 add r0, r3, r7
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;
bf30: e5900004 ldr r0, [r0, #4]
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
bf34: e3100001 tst r0, #1
bf38: 13a08000 movne r8, #0
bf3c: 03a08001 moveq r8, #1
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
bf40: e21c0001 ands r0, ip, #1
bf44: 1a00001b bne bfb8 <_Heap_Free+0x104>
uintptr_t const prev_size = block->prev_size;
bf48: e595c000 ldr ip, [r5]
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
bf4c: e06ca005 rsb sl, ip, r5
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;
bf50: e152000a cmp r2, sl
bf54: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
bf58: e151000a cmp r1, sl
bf5c: 38bd85f0 popcc {r4, r5, r6, r7, r8, sl, pc}
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;
bf60: e59a0004 ldr r0, [sl, #4]
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) ) {
bf64: e2100001 ands r0, r0, #1
bf68: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
bf6c: e3580000 cmp r8, #0
bf70: 0a000039 beq c05c <_Heap_Free+0x1a8>
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
bf74: e5940038 ldr r0, [r4, #56] ; 0x38
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
bf78: e0867007 add r7, r6, r7
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
bf7c: e5932008 ldr r2, [r3, #8]
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
bf80: e087c00c add ip, r7, ip
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
bf84: e593300c ldr r3, [r3, #12]
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
bf88: e2400001 sub r0, r0, #1
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
bf8c: e38c1001 orr r1, ip, #1
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
bf90: e5832008 str r2, [r3, #8]
next->prev = prev;
bf94: e582300c str r3, [r2, #12]
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
bf98: e5840038 str r0, [r4, #56] ; 0x38
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
bf9c: e58a1004 str r1, [sl, #4]
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
bfa0: e78ac00c str ip, [sl, ip]
bfa4: ea00000f b bfe8 <_Heap_Free+0x134>
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
return false;
bfa8: e3a00000 mov r0, #0
bfac: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
bfb0: e3a00000 mov r0, #0 <== NOT EXECUTED
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
bfb4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
bfb8: e3580000 cmp r8, #0
bfbc: 0a000014 beq c014 <_Heap_Free+0x160>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
bfc0: e5932008 ldr r2, [r3, #8]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
bfc4: e0877006 add r7, r7, r6
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
bfc8: e593300c ldr r3, [r3, #12]
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
bfcc: e3871001 orr r1, r7, #1
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
bfd0: e5852008 str r2, [r5, #8]
new_block->prev = prev;
bfd4: e585300c str r3, [r5, #12]
next->prev = new_block;
prev->next = new_block;
bfd8: e5835008 str r5, [r3, #8]
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
bfdc: e582500c str r5, [r2, #12]
bfe0: e5851004 str r1, [r5, #4]
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
bfe4: e7857007 str r7, [r5, r7]
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
bfe8: e5942040 ldr r2, [r4, #64] ; 0x40
++stats->frees;
bfec: e5943050 ldr r3, [r4, #80] ; 0x50
stats->free_size += block_size;
bff0: e5941030 ldr r1, [r4, #48] ; 0x30
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
bff4: e2422001 sub r2, r2, #1
++stats->frees;
bff8: e2833001 add r3, r3, #1
stats->free_size += block_size;
bffc: e0816006 add r6, r1, r6
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
c000: e5842040 str r2, [r4, #64] ; 0x40
++stats->frees;
c004: e5843050 str r3, [r4, #80] ; 0x50
stats->free_size += block_size;
c008: e5846030 str r6, [r4, #48] ; 0x30
return( true );
c00c: e3a00001 mov r0, #1
c010: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
next_block->prev_size = size;
} 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;
c014: e3862001 orr r2, r6, #1
c018: e5852004 str r2, [r5, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
c01c: e2842038 add r2, r4, #56 ; 0x38
c020: e8921004 ldm r2, {r2, ip}
} 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;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
c024: e5930004 ldr r0, [r3, #4]
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
c028: e5941008 ldr r1, [r4, #8]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
c02c: e2822001 add r2, r2, #1
} 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;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
c030: e3c00001 bic r0, r0, #1
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
if ( stats->max_free_blocks < stats->free_blocks ) {
c034: e152000c cmp r2, ip
new_block->next = next;
c038: e5851008 str r1, [r5, #8]
new_block->prev = block_before;
c03c: e585400c str r4, [r5, #12]
} 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;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
c040: e5830004 str r0, [r3, #4]
block_before->next = new_block; next->prev = new_block;
c044: e581500c str r5, [r1, #12]
next_block->prev_size = block_size;
c048: e7856006 str r6, [r5, r6]
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
c04c: e5845008 str r5, [r4, #8]
/* Statistics */
++stats->free_blocks;
c050: e5842038 str r2, [r4, #56] ; 0x38
if ( stats->max_free_blocks < stats->free_blocks ) {
stats->max_free_blocks = stats->free_blocks;
c054: 8584203c strhi r2, [r4, #60] ; 0x3c
c058: eaffffe2 b bfe8 <_Heap_Free+0x134>
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;
c05c: e086c00c add ip, r6, ip
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
c060: e38c2001 orr r2, ip, #1
c064: e58a2004 str r2, [sl, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
c068: e5932004 ldr r2, [r3, #4]
c06c: e3c22001 bic r2, r2, #1
c070: e5832004 str r2, [r3, #4]
next_block->prev_size = size;
c074: e785c006 str ip, [r5, r6]
c078: eaffffda b bfe8 <_Heap_Free+0x134>
00013578 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
13578: e92d40f0 push {r4, r5, r6, r7, lr}
1357c: e1a04000 mov r4, r0
13580: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
13584: e1a00001 mov r0, r1 13588: e5941010 ldr r1, [r4, #16] 1358c: e1a07002 mov r7, r2 13590: ebfff86c bl 11748 <__umodsi3> 13594: e2456008 sub r6, r5, #8
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
13598: e5943020 ldr r3, [r4, #32]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
1359c: e0600006 rsb r0, r0, r6
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;
135a0: e1500003 cmp r0, r3
135a4: 3a000010 bcc 135ec <_Heap_Size_of_alloc_area+0x74>
135a8: e5942024 ldr r2, [r4, #36] ; 0x24 135ac: e1500002 cmp r0, r2
135b0: 8a00000d bhi 135ec <_Heap_Size_of_alloc_area+0x74>
- 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;
135b4: e5906004 ldr r6, [r0, #4] 135b8: e3c66001 bic r6, r6, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
135bc: e0806006 add r6, r0, r6
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;
135c0: e1530006 cmp r3, r6
135c4: 8a000008 bhi 135ec <_Heap_Size_of_alloc_area+0x74>
135c8: e1520006 cmp r2, r6
135cc: 3a000008 bcc 135f4 <_Heap_Size_of_alloc_area+0x7c>
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;
135d0: e5960004 ldr r0, [r6, #4]
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
135d4: e2100001 ands r0, r0, #1
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
135d8: 12655004 rsbne r5, r5, #4 135dc: 10856006 addne r6, r5, r6 135e0: 15876000 strne r6, [r7]
return true;
135e4: 13a00001 movne r0, #1
135e8: e8bd80f0 pop {r4, r5, r6, r7, pc}
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
135ec: e3a00000 mov r0, #0
135f0: e8bd80f0 pop {r4, r5, r6, r7, pc}
135f4: e3a00000 mov r0, #0 <== NOT EXECUTED
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
135f8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00007988 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
7988: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
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() ) ) {
798c: e59f35d8 ldr r3, [pc, #1496] ; 7f6c <_Heap_Walk+0x5e4>
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
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;
7990: e31200ff tst r2, #255 ; 0xff
if ( !_System_state_Is_up( _System_state_Get() ) ) {
7994: e5933000 ldr r3, [r3]
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
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;
7998: e59f25d0 ldr r2, [pc, #1488] ; 7f70 <_Heap_Walk+0x5e8>
799c: e59f95d0 ldr r9, [pc, #1488] ; 7f74 <_Heap_Walk+0x5ec>
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
79a0: e1a0a001 mov sl, r1
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
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;
79a4: 11a09002 movne r9, r2
Heap_Control *heap,
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
79a8: e5901010 ldr r1, [r0, #16]
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() ) ) {
79ac: e3530003 cmp r3, #3
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
79b0: e5902014 ldr r2, [r0, #20]
Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block;
79b4: e5903024 ldr r3, [r0, #36] ; 0x24
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
79b8: e24dd038 sub sp, sp, #56 ; 0x38
79bc: e1a04000 mov r4, r0
uintptr_t const page_size = heap->page_size;
79c0: e58d1024 str r1, [sp, #36] ; 0x24
uintptr_t const min_block_size = heap->min_block_size;
79c4: e58d2028 str r2, [sp, #40] ; 0x28
Heap_Block *const first_block = heap->first_block;
79c8: e5908020 ldr r8, [r0, #32]
Heap_Block *const last_block = heap->last_block;
79cc: e58d302c str r3, [sp, #44] ; 0x2c
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() ) ) {
79d0: 0a000002 beq 79e0 <_Heap_Walk+0x58>
}
block = next_block;
} while ( block != first_block );
return true;
79d4: e3a00001 mov r0, #1
}
79d8: e28dd038 add sp, sp, #56 ; 0x38
79dc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
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)(
79e0: e594101c ldr r1, [r4, #28]
79e4: e5900018 ldr r0, [r0, #24]
79e8: e2842008 add r2, r4, #8
79ec: e892000c ldm r2, {r2, r3}
79f0: e59dc028 ldr ip, [sp, #40] ; 0x28
79f4: e58d1008 str r1, [sp, #8]
79f8: e59d102c ldr r1, [sp, #44] ; 0x2c
79fc: e58d0004 str r0, [sp, #4]
7a00: e58d1010 str r1, [sp, #16]
7a04: e58d2014 str r2, [sp, #20]
7a08: e58d3018 str r3, [sp, #24]
7a0c: e59f2564 ldr r2, [pc, #1380] ; 7f78 <_Heap_Walk+0x5f0>
7a10: e58dc000 str ip, [sp]
7a14: e58d800c str r8, [sp, #12]
7a18: e1a0000a mov r0, sl
7a1c: e3a01000 mov r1, #0
7a20: e59d3024 ldr r3, [sp, #36] ; 0x24
7a24: e1a0e00f mov lr, pc
7a28: e12fff19 bx r9
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
7a2c: e59d2024 ldr r2, [sp, #36] ; 0x24
7a30: e3520000 cmp r2, #0
7a34: 0a000026 beq 7ad4 <_Heap_Walk+0x14c>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
7a38: e59d3024 ldr r3, [sp, #36] ; 0x24
7a3c: e2135007 ands r5, r3, #7
7a40: 1a00002a bne 7af0 <_Heap_Walk+0x168>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
7a44: e59d0028 ldr r0, [sp, #40] ; 0x28
7a48: e59d1024 ldr r1, [sp, #36] ; 0x24
7a4c: ebffe56c bl 1004 <__umodsi3>
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
7a50: e250b000 subs fp, r0, #0
7a54: 1a00002c bne 7b0c <_Heap_Walk+0x184>
7a58: e2880008 add r0, r8, #8
7a5c: e59d1024 ldr r1, [sp, #36] ; 0x24
7a60: ebffe567 bl 1004 <__umodsi3>
);
return false;
}
if (
7a64: e2506000 subs r6, r0, #0
7a68: 1a00002f bne 7b2c <_Heap_Walk+0x1a4>
block = next_block;
} while ( block != first_block );
return true;
}
7a6c: e598b004 ldr fp, [r8, #4]
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
7a70: e21b5001 ands r5, fp, #1
7a74: 0a0000fc beq 7e6c <_Heap_Walk+0x4e4>
- 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;
7a78: e59dc02c ldr ip, [sp, #44] ; 0x2c
7a7c: e59c3004 ldr r3, [ip, #4]
7a80: e3c33001 bic r3, r3, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
7a84: e08c3003 add r3, ip, r3
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;
7a88: e5935004 ldr r5, [r3, #4]
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
7a8c: e2155001 ands r5, r5, #1
7a90: 0a000008 beq 7ab8 <_Heap_Walk+0x130>
);
return false;
}
if (
7a94: e1580003 cmp r8, r3
7a98: 0a00002b beq 7b4c <_Heap_Walk+0x1c4>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
7a9c: e1a0000a mov r0, sl
7aa0: e3a01001 mov r1, #1
7aa4: e59f24d0 ldr r2, [pc, #1232] ; 7f7c <_Heap_Walk+0x5f4>
7aa8: e1a0e00f mov lr, pc
7aac: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7ab0: e1a00006 mov r0, r6
7ab4: eaffffc7 b 79d8 <_Heap_Walk+0x50>
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
7ab8: e1a0000a mov r0, sl
7abc: e3a01001 mov r1, #1
7ac0: e59f24b8 ldr r2, [pc, #1208] ; 7f80 <_Heap_Walk+0x5f8>
7ac4: e1a0e00f mov lr, pc
7ac8: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7acc: e1a00005 mov r0, r5
7ad0: eaffffc0 b 79d8 <_Heap_Walk+0x50>
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
(*printer)( source, true, "page size is zero\n" );
7ad4: e1a0000a mov r0, sl
7ad8: e3a01001 mov r1, #1
7adc: e59f24a0 ldr r2, [pc, #1184] ; 7f84 <_Heap_Walk+0x5fc>
7ae0: e1a0e00f mov lr, pc
7ae4: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7ae8: e59d0024 ldr r0, [sp, #36] ; 0x24
7aec: eaffffb9 b 79d8 <_Heap_Walk+0x50>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
7af0: e1a0000a mov r0, sl
7af4: e3a01001 mov r1, #1
7af8: e59f2488 ldr r2, [pc, #1160] ; 7f88 <_Heap_Walk+0x600>
7afc: e1a0e00f mov lr, pc
7b00: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7b04: e3a00000 mov r0, #0
7b08: eaffffb2 b 79d8 <_Heap_Walk+0x50>
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
7b0c: e1a0000a mov r0, sl
7b10: e3a01001 mov r1, #1
7b14: e59f2470 ldr r2, [pc, #1136] ; 7f8c <_Heap_Walk+0x604>
7b18: e59d3028 ldr r3, [sp, #40] ; 0x28
7b1c: e1a0e00f mov lr, pc
7b20: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7b24: e1a00005 mov r0, r5
7b28: eaffffaa b 79d8 <_Heap_Walk+0x50>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
7b2c: e1a0000a mov r0, sl
7b30: e3a01001 mov r1, #1
7b34: e59f2454 ldr r2, [pc, #1108] ; 7f90 <_Heap_Walk+0x608>
7b38: e1a03008 mov r3, r8
7b3c: e1a0e00f mov lr, pc
7b40: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7b44: e1a0000b mov r0, fp
7b48: eaffffa2 b 79d8 <_Heap_Walk+0x50>
block = next_block;
} while ( block != first_block );
return true;
}
7b4c: e5946008 ldr r6, [r4, #8]
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 ) {
7b50: e1540006 cmp r4, r6
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
7b54: e5947010 ldr r7, [r4, #16]
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 ) {
7b58: 05943020 ldreq r3, [r4, #32]
7b5c: 0a00002c beq 7c14 <_Heap_Walk+0x28c>
block = next_block;
} while ( block != first_block );
return true;
}
7b60: e5943020 ldr r3, [r4, #32]
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;
7b64: e1530006 cmp r3, r6
7b68: 8a0000c6 bhi 7e88 <_Heap_Walk+0x500>
7b6c: e594c024 ldr ip, [r4, #36] ; 0x24
7b70: e15c0006 cmp ip, r6
7b74: 3a0000c3 bcc 7e88 <_Heap_Walk+0x500>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
7b78: e2860008 add r0, r6, #8
7b7c: e1a01007 mov r1, r7
7b80: e58d3020 str r3, [sp, #32]
7b84: e58dc01c str ip, [sp, #28]
7b88: ebffe51d bl 1004 <__umodsi3>
);
return false;
}
if (
7b8c: e3500000 cmp r0, #0
7b90: e59d3020 ldr r3, [sp, #32]
7b94: e59dc01c ldr ip, [sp, #28]
7b98: 1a0000d8 bne 7f00 <_Heap_Walk+0x578>
- 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;
7b9c: e5962004 ldr r2, [r6, #4]
7ba0: e3c22001 bic r2, r2, #1
block = next_block;
} while ( block != first_block );
return true;
}
7ba4: e0862002 add r2, r6, r2
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;
7ba8: e5922004 ldr r2, [r2, #4]
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
7bac: e3120001 tst r2, #1
7bb0: 1a0000db bne 7f24 <_Heap_Walk+0x59c>
7bb4: e58d8030 str r8, [sp, #48] ; 0x30
7bb8: e58db034 str fp, [sp, #52] ; 0x34
7bbc: e1a02004 mov r2, r4
7bc0: e1a08003 mov r8, r3
7bc4: e1a0b00c mov fp, ip
);
return false;
}
if ( free_block->prev != prev_block ) {
7bc8: e596100c ldr r1, [r6, #12]
7bcc: e1510002 cmp r1, r2
7bd0: 1a0000dc bne 7f48 <_Heap_Walk+0x5c0>
return false;
}
prev_block = free_block;
free_block = free_block->next;
7bd4: e5965008 ldr r5, [r6, #8]
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 ) {
7bd8: e1540005 cmp r4, r5
7bdc: 0a000009 beq 7c08 <_Heap_Walk+0x280>
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;
7be0: e1580005 cmp r8, r5
7be4: 9a00007d bls 7de0 <_Heap_Walk+0x458>
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
7be8: e1a0000a mov r0, sl
7bec: e3a01001 mov r1, #1
7bf0: e59f239c ldr r2, [pc, #924] ; 7f94 <_Heap_Walk+0x60c>
7bf4: e1a03005 mov r3, r5
7bf8: e1a0e00f mov lr, pc
7bfc: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7c00: e3a00000 mov r0, #0
7c04: eaffff73 b 79d8 <_Heap_Walk+0x50>
7c08: e1a03008 mov r3, r8
7c0c: e28d8030 add r8, sp, #48 ; 0x30
7c10: e8980900 ldm r8, {r8, fp}
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
7c14: e1a06008 mov r6, r8
- 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;
7c18: e3cb7001 bic r7, fp, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
7c1c: e0875006 add r5, r7, r6
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;
7c20: e1530005 cmp r3, r5
7c24: 9a000008 bls 7c4c <_Heap_Walk+0x2c4>
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 ) ) {
(*printer)(
7c28: e1a0000a mov r0, sl
7c2c: e58d5000 str r5, [sp]
7c30: e3a01001 mov r1, #1
7c34: e59f235c ldr r2, [pc, #860] ; 7f98 <_Heap_Walk+0x610>
7c38: e1a03006 mov r3, r6
7c3c: e1a0e00f mov lr, pc
7c40: e12fff19 bx r9
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
7c44: e3a00000 mov r0, #0
7c48: eaffff62 b 79d8 <_Heap_Walk+0x50>
7c4c: e5943024 ldr r3, [r4, #36] ; 0x24
7c50: e1530005 cmp r3, r5
7c54: 3afffff3 bcc 7c28 <_Heap_Walk+0x2a0>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
7c58: e59d1024 ldr r1, [sp, #36] ; 0x24
7c5c: e1a00007 mov r0, r7
7c60: ebffe4e7 bl 1004 <__umodsi3>
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;
7c64: e59d102c ldr r1, [sp, #44] ; 0x2c
7c68: e0563001 subs r3, r6, r1
7c6c: 13a03001 movne r3, #1
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
7c70: e3500000 cmp r0, #0
7c74: 0a000001 beq 7c80 <_Heap_Walk+0x2f8>
7c78: e3530000 cmp r3, #0
7c7c: 1a000083 bne 7e90 <_Heap_Walk+0x508>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
7c80: e59d2028 ldr r2, [sp, #40] ; 0x28
7c84: e1520007 cmp r2, r7
7c88: 9a000001 bls 7c94 <_Heap_Walk+0x30c>
7c8c: e3530000 cmp r3, #0
7c90: 1a000087 bne 7eb4 <_Heap_Walk+0x52c>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
7c94: e1560005 cmp r6, r5
7c98: 3a000001 bcc 7ca4 <_Heap_Walk+0x31c>
7c9c: e3530000 cmp r3, #0
7ca0: 1a00008d bne 7edc <_Heap_Walk+0x554>
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;
7ca4: e5953004 ldr r3, [r5, #4]
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
7ca8: e3130001 tst r3, #1
7cac: e20bb001 and fp, fp, #1
7cb0: 0a000018 beq 7d18 <_Heap_Walk+0x390>
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
7cb4: e35b0000 cmp fp, #0
7cb8: 0a00000c beq 7cf0 <_Heap_Walk+0x368>
(*printer)(
7cbc: e58d7000 str r7, [sp]
7cc0: e1a0000a mov r0, sl
7cc4: e3a01000 mov r1, #0
7cc8: e59f22cc ldr r2, [pc, #716] ; 7f9c <_Heap_Walk+0x614>
7ccc: e1a03006 mov r3, r6
7cd0: e1a0e00f mov lr, pc
7cd4: e12fff19 bx r9
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
7cd8: e1580005 cmp r8, r5
7cdc: 0affff3c beq 79d4 <_Heap_Walk+0x4c>
7ce0: e595b004 ldr fp, [r5, #4]
7ce4: e5943020 ldr r3, [r4, #32]
7ce8: e1a06005 mov r6, r5
7cec: eaffffc9 b 7c18 <_Heap_Walk+0x290>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
7cf0: e58d7000 str r7, [sp]
7cf4: e5963000 ldr r3, [r6]
7cf8: e1a0000a mov r0, sl
7cfc: e58d3004 str r3, [sp, #4]
7d00: e1a0100b mov r1, fp
7d04: e59f2294 ldr r2, [pc, #660] ; 7fa0 <_Heap_Walk+0x618>
7d08: e1a03006 mov r3, r6
7d0c: e1a0e00f mov lr, pc
7d10: e12fff19 bx r9
7d14: eaffffef b 7cd8 <_Heap_Walk+0x350>
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 ?
7d18: e596200c ldr r2, [r6, #12]
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)(
7d1c: e5943008 ldr r3, [r4, #8]
7d20: e1530002 cmp r3, r2
block = next_block;
} while ( block != first_block );
return true;
}
7d24: e594100c ldr r1, [r4, #12]
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)(
7d28: 059f0274 ldreq r0, [pc, #628] ; 7fa4 <_Heap_Walk+0x61c>
7d2c: 0a000003 beq 7d40 <_Heap_Walk+0x3b8>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
7d30: e59f3270 ldr r3, [pc, #624] ; 7fa8 <_Heap_Walk+0x620>
7d34: e1540002 cmp r4, r2
7d38: e59f026c ldr r0, [pc, #620] ; 7fac <_Heap_Walk+0x624>
7d3c: 01a00003 moveq r0, r3
block->next,
block->next == last_free_block ?
7d40: e5963008 ldr r3, [r6, #8]
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)(
7d44: e1510003 cmp r1, r3
7d48: 059f1260 ldreq r1, [pc, #608] ; 7fb0 <_Heap_Walk+0x628>
7d4c: 0a000003 beq 7d60 <_Heap_Walk+0x3d8>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
7d50: e59fc25c ldr ip, [pc, #604] ; 7fb4 <_Heap_Walk+0x62c>
7d54: e1540003 cmp r4, r3
7d58: e59f124c ldr r1, [pc, #588] ; 7fac <_Heap_Walk+0x624>
7d5c: 01a0100c moveq r1, ip
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)(
7d60: e58d2004 str r2, [sp, #4]
7d64: e58d0008 str r0, [sp, #8]
7d68: e58d300c str r3, [sp, #12]
7d6c: e58d1010 str r1, [sp, #16]
7d70: e1a03006 mov r3, r6
7d74: e58d7000 str r7, [sp]
7d78: e1a0000a mov r0, sl
7d7c: e3a01000 mov r1, #0
7d80: e59f2230 ldr r2, [pc, #560] ; 7fb8 <_Heap_Walk+0x630>
7d84: e1a0e00f mov lr, pc
7d88: e12fff19 bx r9
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
7d8c: e5953000 ldr r3, [r5]
7d90: e1570003 cmp r7, r3
7d94: 1a000021 bne 7e20 <_Heap_Walk+0x498>
);
return false;
}
if ( !prev_used ) {
7d98: e35b0000 cmp fp, #0
7d9c: 0a00002a beq 7e4c <_Heap_Walk+0x4c4>
block = next_block;
} while ( block != first_block );
return true;
}
7da0: e5943008 ldr r3, [r4, #8]
)
{
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 ) {
7da4: e1540003 cmp r4, r3
7da8: 0a000004 beq 7dc0 <_Heap_Walk+0x438>
if ( free_block == block ) {
7dac: e1560003 cmp r6, r3
7db0: 0affffc8 beq 7cd8 <_Heap_Walk+0x350>
return true;
}
free_block = free_block->next;
7db4: e5933008 ldr r3, [r3, #8]
)
{
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 ) {
7db8: e1540003 cmp r4, r3
7dbc: 1afffffa bne 7dac <_Heap_Walk+0x424>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
7dc0: e1a0000a mov r0, sl
7dc4: e3a01001 mov r1, #1
7dc8: e59f21ec ldr r2, [pc, #492] ; 7fbc <_Heap_Walk+0x634>
7dcc: e1a03006 mov r3, r6
7dd0: e1a0e00f mov lr, pc
7dd4: e12fff19 bx r9
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
7dd8: e3a00000 mov r0, #0
7ddc: eafffefd b 79d8 <_Heap_Walk+0x50>
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;
7de0: e155000b cmp r5, fp
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
7de4: e2850008 add r0, r5, #8
7de8: e1a01007 mov r1, r7
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;
7dec: 8affff7d bhi 7be8 <_Heap_Walk+0x260>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
7df0: ebffe483 bl 1004 <__umodsi3>
);
return false;
}
if (
7df4: e3500000 cmp r0, #0
7df8: 1a000041 bne 7f04 <_Heap_Walk+0x57c>
- 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;
7dfc: e5953004 ldr r3, [r5, #4]
7e00: e3c33001 bic r3, r3, #1
block = next_block;
} while ( block != first_block );
return true;
}
7e04: e0833005 add r3, r3, r5
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;
7e08: e5933004 ldr r3, [r3, #4]
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
7e0c: e3130001 tst r3, #1
7e10: 1a000044 bne 7f28 <_Heap_Walk+0x5a0>
7e14: e1a02006 mov r2, r6
7e18: e1a06005 mov r6, r5
7e1c: eaffff69 b 7bc8 <_Heap_Walk+0x240>
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
7e20: e58d3004 str r3, [sp, #4]
7e24: e1a0000a mov r0, sl
7e28: e58d7000 str r7, [sp]
7e2c: e58d5008 str r5, [sp, #8]
7e30: e3a01001 mov r1, #1
7e34: e59f2184 ldr r2, [pc, #388] ; 7fc0 <_Heap_Walk+0x638>
7e38: e1a03006 mov r3, r6
7e3c: e1a0e00f mov lr, pc
7e40: e12fff19 bx r9
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
7e44: e3a00000 mov r0, #0
7e48: eafffee2 b 79d8 <_Heap_Walk+0x50>
return false;
}
if ( !prev_used ) {
(*printer)(
7e4c: e1a0000a mov r0, sl
7e50: e3a01001 mov r1, #1
7e54: e59f2168 ldr r2, [pc, #360] ; 7fc4 <_Heap_Walk+0x63c>
7e58: e1a03006 mov r3, r6
7e5c: e1a0e00f mov lr, pc
7e60: e12fff19 bx r9
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
7e64: e1a0000b mov r0, fp
7e68: eafffeda b 79d8 <_Heap_Walk+0x50>
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
7e6c: e1a0000a mov r0, sl
7e70: e3a01001 mov r1, #1
7e74: e59f214c ldr r2, [pc, #332] ; 7fc8 <_Heap_Walk+0x640>
7e78: e1a0e00f mov lr, pc
7e7c: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7e80: e1a00005 mov r0, r5
7e84: eafffed3 b 79d8 <_Heap_Walk+0x50>
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;
7e88: e1a05006 mov r5, r6 <== NOT EXECUTED
7e8c: eaffff55 b 7be8 <_Heap_Walk+0x260> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
7e90: e1a0000a mov r0, sl
7e94: e58d7000 str r7, [sp]
7e98: e3a01001 mov r1, #1
7e9c: e59f2128 ldr r2, [pc, #296] ; 7fcc <_Heap_Walk+0x644>
7ea0: e1a03006 mov r3, r6
7ea4: e1a0e00f mov lr, pc
7ea8: e12fff19 bx r9
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
7eac: e3a00000 mov r0, #0
7eb0: eafffec8 b 79d8 <_Heap_Walk+0x50>
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
7eb4: e58d2004 str r2, [sp, #4]
7eb8: e1a0000a mov r0, sl
7ebc: e58d7000 str r7, [sp]
7ec0: e3a01001 mov r1, #1
7ec4: e59f2104 ldr r2, [pc, #260] ; 7fd0 <_Heap_Walk+0x648>
7ec8: e1a03006 mov r3, r6
7ecc: e1a0e00f mov lr, pc
7ed0: e12fff19 bx r9
block,
block_size,
min_block_size
);
return false;
7ed4: e3a00000 mov r0, #0
7ed8: eafffebe b 79d8 <_Heap_Walk+0x50>
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
7edc: e1a0000a mov r0, sl
7ee0: e58d5000 str r5, [sp]
7ee4: e3a01001 mov r1, #1
7ee8: e59f20e4 ldr r2, [pc, #228] ; 7fd4 <_Heap_Walk+0x64c>
7eec: e1a03006 mov r3, r6
7ef0: e1a0e00f mov lr, pc
7ef4: e12fff19 bx r9
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
7ef8: e3a00000 mov r0, #0
7efc: eafffeb5 b 79d8 <_Heap_Walk+0x50>
);
return false;
}
if (
7f00: e1a05006 mov r5, r6 <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
7f04: e1a0000a mov r0, sl
7f08: e3a01001 mov r1, #1
7f0c: e59f20c4 ldr r2, [pc, #196] ; 7fd8 <_Heap_Walk+0x650>
7f10: e1a03005 mov r3, r5
7f14: e1a0e00f mov lr, pc
7f18: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7f1c: e3a00000 mov r0, #0
7f20: eafffeac b 79d8 <_Heap_Walk+0x50>
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
7f24: e1a05006 mov r5, r6 <== NOT EXECUTED
(*printer)(
7f28: e1a0000a mov r0, sl
7f2c: e3a01001 mov r1, #1
7f30: e59f20a4 ldr r2, [pc, #164] ; 7fdc <_Heap_Walk+0x654>
7f34: e1a03005 mov r3, r5
7f38: e1a0e00f mov lr, pc
7f3c: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7f40: e3a00000 mov r0, #0
7f44: eafffea3 b 79d8 <_Heap_Walk+0x50>
return false;
}
if ( free_block->prev != prev_block ) {
(*printer)(
7f48: e58d1000 str r1, [sp]
7f4c: e1a0000a mov r0, sl
7f50: e3a01001 mov r1, #1
7f54: e59f2084 ldr r2, [pc, #132] ; 7fe0 <_Heap_Walk+0x658>
7f58: e1a03006 mov r3, r6
7f5c: e1a0e00f mov lr, pc
7f60: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7f64: e3a00000 mov r0, #0
7f68: eafffe9a b 79d8 <_Heap_Walk+0x50>
00006e2c <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
6e2c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
6e30: e5904034 ldr r4, [r0, #52] ; 0x34
6e34: e3540000 cmp r4, #0
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
6e38: e24dd014 sub sp, sp, #20
6e3c: e1a05000 mov r5, r0
/* * 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 );
6e40: e1d070b8 ldrh r7, [r0, #8]
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
6e44: 0a00009a beq 70b4 <_Objects_Extend_information+0x288>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
6e48: e1d081b4 ldrh r8, [r0, #20]
6e4c: e1d0a1b0 ldrh sl, [r0, #16]
6e50: e1a01008 mov r1, r8
6e54: e1a0000a mov r0, sl
6e58: eb0029f4 bl 11630 <__aeabi_uidiv>
6e5c: e1a03800 lsl r3, r0, #16
for ( ; block < block_count; block++ ) {
6e60: e1b03823 lsrs r3, r3, #16
6e64: 0a000098 beq 70cc <_Objects_Extend_information+0x2a0>
if ( information->object_blocks[ block ] == NULL ) {
6e68: e5949000 ldr r9, [r4]
6e6c: e3590000 cmp r9, #0
6e70: 01a01008 moveq r1, r8
/* * 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 );
6e74: 01a06007 moveq r6, r7
index_base = minimum_index; block = 0;
6e78: 01a04009 moveq r4, r9
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
6e7c: 0a00000c beq 6eb4 <_Objects_Extend_information+0x88>
6e80: e1a02004 mov r2, r4
6e84: e1a01008 mov r1, r8
/* * 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 );
6e88: e1a06007 mov r6, r7
index_base = minimum_index; block = 0;
6e8c: e3a04000 mov r4, #0
6e90: ea000002 b 6ea0 <_Objects_Extend_information+0x74>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
6e94: e5b29004 ldr r9, [r2, #4]!
6e98: e3590000 cmp r9, #0
6e9c: 0a000004 beq 6eb4 <_Objects_Extend_information+0x88>
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
6ea0: e2844001 add r4, r4, #1
6ea4: e1530004 cmp r3, r4
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
break;
} else
index_base += information->allocation_size;
6ea8: e0866008 add r6, r6, r8
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
6eac: 8afffff8 bhi 6e94 <_Objects_Extend_information+0x68>
/*
* 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;
6eb0: e3a09001 mov r9, #1
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
6eb4: e08aa001 add sl, sl, r1
/*
* 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 ) {
6eb8: e35a0801 cmp sl, #65536 ; 0x10000
6ebc: 2a000062 bcs 704c <_Objects_Extend_information+0x220>
/*
* 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;
if ( information->auto_extend ) {
6ec0: e5d52012 ldrb r2, [r5, #18]
/*
* 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;
6ec4: e5950018 ldr r0, [r5, #24]
if ( information->auto_extend ) {
6ec8: e3520000 cmp r2, #0
/*
* 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;
6ecc: e0000091 mul r0, r1, r0
if ( information->auto_extend ) {
6ed0: 1a00005f bne 7054 <_Objects_Extend_information+0x228>
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
6ed4: e58d3000 str r3, [sp]
6ed8: eb0008a9 bl 9184 <_Workspace_Allocate_or_fatal_error>
6edc: e59d3000 ldr r3, [sp]
6ee0: e1a08000 mov r8, r0
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
6ee4: e3590000 cmp r9, #0
6ee8: 0a000038 beq 6fd0 <_Objects_Extend_information+0x1a4>
*/
/*
* Up the block count and maximum
*/
block_count++;
6eec: e283b001 add fp, r3, #1
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
6ef0: e08b008b add r0, fp, fp, lsl #1
((maximum + minimum_index) * sizeof(Objects_Control *));
6ef4: e08a0000 add r0, sl, r0
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
6ef8: e0800007 add r0, r0, r7
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
6efc: e1a00100 lsl r0, r0, #2
6f00: e58d3000 str r3, [sp]
6f04: eb000894 bl 915c <_Workspace_Allocate>
if ( !object_blocks ) {
6f08: e2509000 subs r9, r0, #0
6f0c: e59d3000 ldr r3, [sp]
6f10: 0a000072 beq 70e0 <_Objects_Extend_information+0x2b4>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
6f14: e1d521b0 ldrh r2, [r5, #16]
6f18: e1570002 cmp r7, r2
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
6f1c: e089c10b add ip, r9, fp, lsl #2
6f20: e089b18b add fp, r9, fp, lsl #3
6f24: 3a000050 bcc 706c <_Objects_Extend_information+0x240>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
6f28: e3570000 cmp r7, #0
6f2c: 13a02000 movne r2, #0
6f30: 11a0100b movne r1, fp
local_table[ index ] = NULL;
6f34: 11a00002 movne r0, r2
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
6f38: 0a000003 beq 6f4c <_Objects_Extend_information+0x120>
6f3c: e2822001 add r2, r2, #1
6f40: e1570002 cmp r7, r2
local_table[ index ] = NULL;
6f44: e4810004 str r0, [r1], #4
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
6f48: 8afffffb bhi 6f3c <_Objects_Extend_information+0x110>
6f4c: e1a03103 lsl r3, r3, #2
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
6f50: e1d511b4 ldrh r1, [r5, #20]
6f54: e0861001 add r1, r6, r1
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
6f58: e3a00000 mov r0, #0
inactive_per_block[block_count] = 0;
for ( index=index_base ;
6f5c: e1560001 cmp r6, r1
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
6f60: e7890003 str r0, [r9, r3]
inactive_per_block[block_count] = 0;
6f64: e78c0003 str r0, [ip, r3]
for ( index=index_base ;
6f68: 2a000005 bcs 6f84 <_Objects_Extend_information+0x158>
6f6c: e08b2106 add r2, fp, r6, lsl #2
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
6f70: e1a03006 mov r3, r6
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
6f74: e2833001 add r3, r3, #1
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
6f78: e1530001 cmp r3, r1
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
6f7c: e4820004 str r0, [r2], #4
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
6f80: 3afffffb bcc 6f74 <_Objects_Extend_information+0x148>
6f84: e10f3000 mrs r3, CPSR
6f88: e3832080 orr r2, r3, #128 ; 0x80
6f8c: e129f002 msr CPSR_fc, r2
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
6f90: e5952000 ldr r2, [r5]
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
6f94: e1d510b4 ldrh r1, [r5, #4]
6f98: e1a02c02 lsl r2, r2, #24
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
6f9c: e1a0a80a lsl sl, sl, #16
6fa0: e3822801 orr r2, r2, #65536 ; 0x10000
6fa4: e1a0a82a lsr sl, sl, #16
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
6fa8: e1822d81 orr r2, r2, r1, lsl #27
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
6fac: e182200a orr r2, r2, sl
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
6fb0: e5950034 ldr r0, [r5, #52] ; 0x34
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
6fb4: e585c030 str ip, [r5, #48] ; 0x30
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
6fb8: e5859034 str r9, [r5, #52] ; 0x34
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
6fbc: e585b01c str fp, [r5, #28]
information->maximum = (Objects_Maximum) maximum;
6fc0: e1c5a1b0 strh sl, [r5, #16]
information->maximum_id = _Objects_Build_id(
6fc4: e585200c str r2, [r5, #12]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
6fc8: e129f003 msr CPSR_fc, r3
information->maximum
);
_ISR_Enable( level );
_Workspace_Free( old_tables );
6fcc: eb000868 bl 9174 <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
6fd0: e5953034 ldr r3, [r5, #52] ; 0x34
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
6fd4: e28d7008 add r7, sp, #8
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
6fd8: e7838104 str r8, [r3, r4, lsl #2]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
6fdc: e1a01008 mov r1, r8
6fe0: e1a00007 mov r0, r7
6fe4: e1d521b4 ldrh r2, [r5, #20]
6fe8: e5953018 ldr r3, [r5, #24]
6fec: eb001290 bl ba34 <_Chain_Initialize>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
6ff0: e1a04104 lsl r4, r4, #2
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
6ff4: e2858020 add r8, r5, #32
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
6ff8: ea000009 b 7024 <_Objects_Extend_information+0x1f8>
6ffc: e5953000 ldr r3, [r5]
the_object->id = _Objects_Build_id(
7000: e1d520b4 ldrh r2, [r5, #4]
7004: e1a03c03 lsl r3, r3, #24
7008: e3833801 orr r3, r3, #65536 ; 0x10000
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
700c: e1833d82 orr r3, r3, r2, lsl #27
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
7010: e1833006 orr r3, r3, r6
7014: e5813008 str r3, [r1, #8]
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
7018: e1a00008 mov r0, r8
701c: ebfffcea bl 63cc <_Chain_Append>
index++;
7020: e2866001 add r6, r6, #1
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
7024: e1a00007 mov r0, r7
7028: ebfffcfa bl 6418 <_Chain_Get>
702c: e2501000 subs r1, r0, #0
7030: 1afffff1 bne 6ffc <_Objects_Extend_information+0x1d0>
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
7034: e1d522bc ldrh r2, [r5, #44] ; 0x2c
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
7038: e1d531b4 ldrh r3, [r5, #20]
703c: e5951030 ldr r1, [r5, #48] ; 0x30
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
7040: e0832002 add r2, r3, r2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
7044: e7813004 str r3, [r1, r4]
information->inactive =
7048: e1c522bc strh r2, [r5, #44] ; 0x2c
(Objects_Maximum)(information->inactive + information->allocation_size);
}
704c: e28dd014 add sp, sp, #20
7050: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* 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;
if ( information->auto_extend ) {
new_object_block = _Workspace_Allocate( block_size );
7054: e58d3000 str r3, [sp]
7058: eb00083f bl 915c <_Workspace_Allocate>
if ( !new_object_block )
705c: e2508000 subs r8, r0, #0
7060: e59d3000 ldr r3, [sp]
7064: 1affff9e bne 6ee4 <_Objects_Extend_information+0xb8>
7068: eafffff7 b 704c <_Objects_Extend_information+0x220>
/*
* 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,
706c: e1a03103 lsl r3, r3, #2
7070: e5951034 ldr r1, [r5, #52] ; 0x34
7074: e1a02003 mov r2, r3
7078: e88d1008 stm sp, {r3, ip}
707c: eb001dd6 bl e7dc <memcpy>
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
7080: e89d1008 ldm sp, {r3, ip}
7084: e1a0000c mov r0, ip
7088: e1a02003 mov r2, r3
708c: e5951030 ldr r1, [r5, #48] ; 0x30
7090: eb001dd1 bl e7dc <memcpy>
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
7094: e1d521b0 ldrh r2, [r5, #16]
7098: e0872002 add r2, r7, r2
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
709c: e1a0000b mov r0, fp
70a0: e595101c ldr r1, [r5, #28]
70a4: e1a02102 lsl r2, r2, #2
70a8: eb001dcb bl e7dc <memcpy>
70ac: e89d1008 ldm sp, {r3, ip}
70b0: eaffffa6 b 6f50 <_Objects_Extend_information+0x124>
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
70b4: e1d0a1b0 ldrh sl, [r0, #16]
70b8: e1d011b4 ldrh r1, [r0, #20]
/* * 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 );
70bc: e1a06007 mov r6, r7
/*
* 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;
70c0: e3a09001 mov r9, #1
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
70c4: e1a03004 mov r3, r4
70c8: eaffff79 b 6eb4 <_Objects_Extend_information+0x88>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
70cc: e1a01008 mov r1, r8 <== NOT EXECUTED
/* * 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 );
70d0: e1a06007 mov r6, r7 <== NOT EXECUTED
/*
* 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;
70d4: e3a09001 mov r9, #1 <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
70d8: e1a04003 mov r4, r3 <== NOT EXECUTED
70dc: eaffff74 b 6eb4 <_Objects_Extend_information+0x88> <== NOT EXECUTED
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
70e0: e1a00008 mov r0, r8
70e4: eb000822 bl 9174 <_Workspace_Free>
return;
70e8: eaffffd7 b 704c <_Objects_Extend_information+0x220>
00007450 <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
7450: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
7454: e1d040b8 ldrh r4, [r0, #8]
block_count = (information->maximum - index_base) /
7458: e1d051b4 ldrh r5, [r0, #20]
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
745c: e1a06000 mov r6, r0
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
7460: e1d001b0 ldrh r0, [r0, #16]
7464: e1a01005 mov r1, r5
7468: e0640000 rsb r0, r4, r0
746c: eb00286f bl 11630 <__aeabi_uidiv>
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
7470: e3500000 cmp r0, #0
7474: 08bd80f0 popeq {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
7478: e5962030 ldr r2, [r6, #48] ; 0x30
747c: e5923000 ldr r3, [r2]
7480: e1550003 cmp r5, r3
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
7484: 13a03000 movne r3, #0
if ( information->inactive_per_block[ block ] ==
7488: 1a000005 bne 74a4 <_Objects_Shrink_information+0x54>
748c: ea000008 b 74b4 <_Objects_Shrink_information+0x64> <== NOT EXECUTED
7490: e5b21004 ldr r1, [r2, #4]!
7494: e1550001 cmp r5, r1
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
7498: e0844005 add r4, r4, r5
749c: e1a07103 lsl r7, r3, #2
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
74a0: 0a000004 beq 74b8 <_Objects_Shrink_information+0x68>
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
74a4: e2833001 add r3, r3, #1
74a8: e1500003 cmp r0, r3
74ac: 8afffff7 bhi 7490 <_Objects_Shrink_information+0x40>
74b0: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
74b4: e3a07000 mov r7, #0 <== NOT EXECUTED
information->allocation_size ) {
/*
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
74b8: e5960020 ldr r0, [r6, #32]
74bc: ea000002 b 74cc <_Objects_Shrink_information+0x7c>
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
74c0: e3550000 cmp r5, #0
74c4: 0a00000b beq 74f8 <_Objects_Shrink_information+0xa8>
index = _Objects_Get_index( the_object->id );
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
74c8: e1a00005 mov r0, r5
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
do {
index = _Objects_Get_index( the_object->id );
74cc: e1d030b8 ldrh r3, [r0, #8]
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
74d0: e1530004 cmp r3, r4
index = _Objects_Get_index( the_object->id );
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
74d4: e5905000 ldr r5, [r0]
if ((index >= index_base) &&
74d8: 3afffff8 bcc 74c0 <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
74dc: e1d621b4 ldrh r2, [r6, #20]
74e0: e0842002 add r2, r4, r2
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
74e4: e1530002 cmp r3, r2
74e8: 2afffff4 bcs 74c0 <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
74ec: ebfffbc1 bl 63f8 <_Chain_Extract>
}
}
while ( the_object );
74f0: e3550000 cmp r5, #0
74f4: 1afffff3 bne 74c8 <_Objects_Shrink_information+0x78>
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
74f8: e5963034 ldr r3, [r6, #52] ; 0x34
74fc: e7930007 ldr r0, [r3, r7]
7500: eb00071b bl 9174 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
7504: e1d602bc ldrh r0, [r6, #44] ; 0x2c
7508: e1d631b4 ldrh r3, [r6, #20]
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
750c: e5961034 ldr r1, [r6, #52] ; 0x34
information->inactive_per_block[ block ] = 0;
7510: e5962030 ldr r2, [r6, #48] ; 0x30
information->inactive -= information->allocation_size;
7514: e0633000 rsb r3, r3, r0
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
7518: e7815007 str r5, [r1, r7]
information->inactive_per_block[ block ] = 0;
751c: e7825007 str r5, [r2, r7]
information->inactive -= information->allocation_size;
7520: e1c632bc strh r3, [r6, #44] ; 0x2c
return;
7524: e8bd80f0 pop {r4, r5, r6, r7, pc}
0000dea0 <_POSIX_signals_Clear_process_signals>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
dea0: e10f2000 mrs r2, CPSR
dea4: e3823080 orr r3, r2, #128 ; 0x80
dea8: e129f003 msr CPSR_fc, r3
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
deac: e59f1050 ldr r1, [pc, #80] ; df04 <_POSIX_signals_Clear_process_signals+0x64>
deb0: e0803080 add r3, r0, r0, lsl #1
deb4: e1a03103 lsl r3, r3, #2
deb8: e7911003 ldr r1, [r1, r3]
debc: e3510002 cmp r1, #2
dec0: 0a000007 beq dee4 <_POSIX_signals_Clear_process_signals+0x44>
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
dec4: e59f303c ldr r3, [pc, #60] ; df08 <_POSIX_signals_Clear_process_signals+0x68>
dec8: e5931000 ldr r1, [r3]
decc: e3a0c001 mov ip, #1
ded0: e2400001 sub r0, r0, #1
ded4: e1c1001c bic r0, r1, ip, lsl r0
ded8: e5830000 str r0, [r3]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
dedc: e129f002 msr CPSR_fc, r2
}
_ISR_Enable( level );
}
dee0: e12fff1e bx lr
dee4: e59f1020 ldr r1, [pc, #32] ; df0c <_POSIX_signals_Clear_process_signals+0x6c>
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
dee8: e283c004 add ip, r3, #4
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
deec: e7913003 ldr r3, [r1, r3]
def0: e08c1001 add r1, ip, r1
def4: e1530001 cmp r3, r1
def8: 0afffff1 beq dec4 <_POSIX_signals_Clear_process_signals+0x24>
defc: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
}
df00: e12fff1e bx lr <== NOT EXECUTED
00023004 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
23004: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
23008: e5905010 ldr r5, [r0, #16] 2300c: e3c534ef bic r3, r5, #-285212672 ; 0xef000000 23010: e3c338ff bic r3, r3, #16711680 ; 0xff0000 23014: e3c33c7f bic r3, r3, #32512 ; 0x7f00 23018: e3a0c201 mov ip, #268435456 ; 0x10000000 2301c: e3c330ff bic r3, r3, #255 ; 0xff 23020: e28cc902 add ip, ip, #32768 ; 0x8000 23024: e2417001 sub r7, r1, #1 23028: e3a06001 mov r6, #1 2302c: e153000c cmp r3, ip
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
23030: e1a04000 mov r4, r0
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
23034: e59030fc ldr r3, [r0, #252] ; 0xfc 23038: e1a07716 lsl r7, r6, r7
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
2303c: 0a00001b beq 230b0 <_POSIX_signals_Unblock_thread+0xac>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
23040: e59330d0 ldr r3, [r3, #208] ; 0xd0 23044: e1d77003 bics r7, r7, r3
23048: 0a000016 beq 230a8 <_POSIX_signals_Unblock_thread+0xa4>
* it is not blocked, THEN
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
2304c: e2157201 ands r7, r5, #268435456 ; 0x10000000
23050: 0a000012 beq 230a0 <_POSIX_signals_Unblock_thread+0x9c>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
23054: e3c564ff bic r6, r5, #-16777216 ; 0xff000000 23058: e3c6673f bic r6, r6, #16515072 ; 0xfc0000 2305c: e3c66c41 bic r6, r6, #16640 ; 0x4100 23060: e3c6601f bic r6, r6, #31
the_thread->Wait.return_code = EINTR;
23064: e3a03004 mov r3, #4
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
23068: e3560000 cmp r6, #0
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
the_thread->Wait.return_code = EINTR;
2306c: e5803034 str r3, [r0, #52] ; 0x34
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
23070: 1a00002e bne 23130 <_POSIX_signals_Unblock_thread+0x12c>
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
23074: e2150008 ands r0, r5, #8
23078: 08bd80f0 popeq {r4, r5, r6, r7, pc}
(void) _Watchdog_Remove( &the_thread->Timer );
2307c: e2840048 add r0, r4, #72 ; 0x48 23080: ebffad5d bl e5fc <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
23084: e3a01201 mov r1, #268435456 ; 0x10000000 23088: e2811bff add r1, r1, #261120 ; 0x3fc00 2308c: e1a00004 mov r0, r4 23090: e2811ffe add r1, r1, #1016 ; 0x3f8 23094: ebffa879 bl d280 <_Thread_Clear_state>
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
23098: e1a00006 mov r0, r6
2309c: e8bd80f0 pop {r4, r5, r6, r7, pc}
else if ( _States_Is_delaying(the_thread->current_state) ) {
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
230a0: e3550000 cmp r5, #0
230a4: 0a000016 beq 23104 <_POSIX_signals_Unblock_thread+0x100>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
230a8: e1a00007 mov r0, r7
230ac: e8bd80f0 pop {r4, r5, r6, r7, pc}
* 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) ) {
230b0: e5900030 ldr r0, [r0, #48] ; 0x30 230b4: e1170000 tst r7, r0
230b8: 0a00000d beq 230f4 <_POSIX_signals_Unblock_thread+0xf0>
the_thread->Wait.return_code = EINTR;
230bc: e3a03004 mov r3, #4
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
230c0: e3520000 cmp r2, #0
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
the_thread->Wait.return_code = EINTR;
230c4: e5843034 str r3, [r4, #52] ; 0x34
the_info = (siginfo_t *) the_thread->Wait.return_argument;
230c8: e5943028 ldr r3, [r4, #40] ; 0x28
if ( !info ) {
the_info->si_signo = signo;
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
230cc: 18920007 ldmne r2, {r0, r1, r2}
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
230d0: 05831000 streq r1, [r3]
the_info->si_code = SI_USER;
230d4: 03a01001 moveq r1, #1
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
230d8: 18830007 stmne r3, {r0, r1, r2}
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
the_info->si_code = SI_USER;
230dc: 05831004 streq r1, [r3, #4]
the_info->si_value.sival_int = 0;
230e0: 05832008 streq r2, [r3, #8]
} else {
*the_info = *info;
}
_Thread_queue_Extract_with_proxy( the_thread );
230e4: e1a00004 mov r0, r4 230e8: ebffab05 bl dd04 <_Thread_queue_Extract_with_proxy>
return true;
230ec: e3a00001 mov r0, #1
230f0: e8bd80f0 pop {r4, r5, r6, r7, pc}
* 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) ) {
230f4: e59300d0 ldr r0, [r3, #208] ; 0xd0 230f8: e1d70000 bics r0, r7, r0
230fc: 1affffee bne 230bc <_POSIX_signals_Unblock_thread+0xb8>
23100: e8bd80f0 pop {r4, r5, r6, r7, pc}
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
23104: e59f2030 ldr r2, [pc, #48] ; 2313c <_POSIX_signals_Unblock_thread+0x138>
23108: e5920000 ldr r0, [r2]
2310c: e3500000 cmp r0, #0
23110: 08bd80f0 popeq {r4, r5, r6, r7, pc}
23114: e5923004 ldr r3, [r2, #4]
23118: e1540003 cmp r4, r3
_Thread_Dispatch_necessary = true;
2311c: 05c26010 strbeq r6, [r2, #16]
}
}
return false;
23120: 01a00005 moveq r0, r5
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
23124: 08bd80f0 popeq {r4, r5, r6, r7, pc}
_Thread_Dispatch_necessary = true;
}
}
return false;
23128: e1a00005 mov r0, r5 <== NOT EXECUTED
}
2312c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
_Thread_queue_Extract_with_proxy( the_thread );
23130: ebffaaf3 bl dd04 <_Thread_queue_Extract_with_proxy>
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
23134: e3a00000 mov r0, #0
23138: e8bd80f0 pop {r4, r5, r6, r7, pc}
00006a90 <_TOD_Validate>:
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
6a90: e59f30b8 ldr r3, [pc, #184] ; 6b50 <_TOD_Validate+0xc0>
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
6a94: e92d4010 push {r4, lr}
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) ||
6a98: e2504000 subs r4, r0, #0
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
6a9c: e593100c ldr r1, [r3, #12]
(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;
6aa0: 01a00004 moveq r0, r4
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) ||
6aa4: 08bd8010 popeq {r4, pc}
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
6aa8: e3a0093d mov r0, #999424 ; 0xf4000
6aac: e2800d09 add r0, r0, #576 ; 0x240
6ab0: eb004a34 bl 19388 <__aeabi_uidiv>
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
6ab4: e5943018 ldr r3, [r4, #24]
6ab8: e1500003 cmp r0, r3
6abc: 9a00001f bls 6b40 <_TOD_Validate+0xb0>
(the_tod->ticks >= ticks_per_second) ||
6ac0: e5943014 ldr r3, [r4, #20]
6ac4: e353003b cmp r3, #59 ; 0x3b
6ac8: 8a00001c bhi 6b40 <_TOD_Validate+0xb0>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
6acc: e5943010 ldr r3, [r4, #16]
6ad0: e353003b cmp r3, #59 ; 0x3b
6ad4: 8a000019 bhi 6b40 <_TOD_Validate+0xb0>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
6ad8: e594300c ldr r3, [r4, #12]
6adc: e3530017 cmp r3, #23
6ae0: 8a000016 bhi 6b40 <_TOD_Validate+0xb0>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
6ae4: e5940004 ldr r0, [r4, #4]
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) ||
6ae8: e3500000 cmp r0, #0
6aec: 08bd8010 popeq {r4, pc}
(the_tod->month == 0) ||
6af0: e350000c cmp r0, #12
6af4: 8a000011 bhi 6b40 <_TOD_Validate+0xb0>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
6af8: e5942000 ldr r2, [r4]
(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) ||
6afc: e3a03d1f mov r3, #1984 ; 0x7c0
6b00: e2833003 add r3, r3, #3
6b04: e1520003 cmp r2, r3
6b08: 9a00000c bls 6b40 <_TOD_Validate+0xb0>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
6b0c: e5944008 ldr r4, [r4, #8]
(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) ||
6b10: e3540000 cmp r4, #0
6b14: 0a00000b beq 6b48 <_TOD_Validate+0xb8>
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
6b18: e3120003 tst r2, #3
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
6b1c: 059f3030 ldreq r3, [pc, #48] ; 6b54 <_TOD_Validate+0xc4>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
6b20: 159f302c ldrne r3, [pc, #44] ; 6b54 <_TOD_Validate+0xc4>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
6b24: 0280000d addeq r0, r0, #13
6b28: 07930100 ldreq r0, [r3, r0, lsl #2]
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
6b2c: 17930100 ldrne r0, [r3, r0, lsl #2]
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
6b30: e1500004 cmp r0, r4
6b34: 33a00000 movcc r0, #0
6b38: 23a00001 movcs r0, #1
6b3c: e8bd8010 pop {r4, pc}
(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;
6b40: e3a00000 mov r0, #0
6b44: e8bd8010 pop {r4, pc}
6b48: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( the_tod->day > days_in_month )
return false;
return true;
}
6b4c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00008508 <_Thread_queue_Enqueue_priority>:
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
8508: e5913014 ldr r3, [r1, #20]
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
850c: e92d05f0 push {r4, r5, r6, r7, r8, sl}
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
8510: e281403c add r4, r1, #60 ; 0x3c
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
8514: e281c038 add ip, r1, #56 ; 0x38
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
8518: e5814038 str r4, [r1, #56] ; 0x38
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
851c: e3130020 tst r3, #32
head->previous = NULL;
8520: e3a04000 mov r4, #0
8524: e581403c str r4, [r1, #60] ; 0x3c
tail->previous = head;
8528: e581c040 str ip, [r1, #64] ; 0x40
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
852c: e1a07323 lsr r7, r3, #6
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
8530: e5905038 ldr r5, [r0, #56] ; 0x38
if ( _Thread_queue_Is_reverse_search( priority ) )
8534: 1a00001e bne 85b4 <_Thread_queue_Enqueue_priority+0xac>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
8538: e0877087 add r7, r7, r7, lsl #1
853c: e1a0c107 lsl ip, r7, #2
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
8540: e28c7004 add r7, ip, #4
8544: e080a00c add sl, r0, ip
8548: e0807007 add r7, r0, r7
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
854c: e10f8000 mrs r8, CPSR
8550: e388c080 orr ip, r8, #128 ; 0x80
8554: e129f00c msr CPSR_fc, ip
8558: e59ac000 ldr ip, [sl]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
855c: e15c0007 cmp ip, r7
8560: 1a000009 bne 858c <_Thread_queue_Enqueue_priority+0x84>
8564: ea000051 b 86b0 <_Thread_queue_Enqueue_priority+0x1a8>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
8568: e10f6000 mrs r6, CPSR
856c: e129f008 msr CPSR_fc, r8
8570: e129f006 msr CPSR_fc, r6
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
8574: e59c6010 ldr r6, [ip, #16]
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
8578: e1150006 tst r5, r6
857c: 0a000034 beq 8654 <_Thread_queue_Enqueue_priority+0x14c>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
8580: e59cc000 ldr ip, [ip]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
8584: e15c0007 cmp ip, r7
8588: 0a000002 beq 8598 <_Thread_queue_Enqueue_priority+0x90>
search_priority = search_thread->current_priority;
858c: e59c4014 ldr r4, [ip, #20]
if ( priority <= search_priority )
8590: e1530004 cmp r3, r4
8594: 8afffff3 bhi 8568 <_Thread_queue_Enqueue_priority+0x60>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
8598: e5905030 ldr r5, [r0, #48] ; 0x30
859c: e3550001 cmp r5, #1
85a0: 0a00002d beq 865c <_Thread_queue_Enqueue_priority+0x154>
* For example, the blocking thread could have been given
* the mutex by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
85a4: e5828000 str r8, [r2]
return the_thread_queue->sync_state; }
85a8: e1a00005 mov r0, r5
85ac: e8bd05f0 pop {r4, r5, r6, r7, r8, sl}
85b0: e12fff1e bx lr
85b4: e0877087 add r7, r7, r7, lsl #1
85b8: e59fa0f8 ldr sl, [pc, #248] ; 86b8 <_Thread_queue_Enqueue_priority+0x1b0>
85bc: e0807107 add r7, r0, r7, lsl #2
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
85c0: e5da4000 ldrb r4, [sl]
85c4: e2844001 add r4, r4, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
85c8: e10f8000 mrs r8, CPSR
85cc: e388c080 orr ip, r8, #128 ; 0x80
85d0: e129f00c msr CPSR_fc, ip
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
85d4: e597c008 ldr ip, [r7, #8]
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
85d8: e15c0007 cmp ip, r7
85dc: 1a000009 bne 8608 <_Thread_queue_Enqueue_priority+0x100>
85e0: ea00000b b 8614 <_Thread_queue_Enqueue_priority+0x10c>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
85e4: e10f6000 mrs r6, CPSR
85e8: e129f008 msr CPSR_fc, r8
85ec: e129f006 msr CPSR_fc, r6
85f0: e59c6010 ldr r6, [ip, #16]
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
85f4: e1150006 tst r5, r6
85f8: 0a000013 beq 864c <_Thread_queue_Enqueue_priority+0x144>
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
85fc: e59cc004 ldr ip, [ip, #4]
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
8600: e15c0007 cmp ip, r7
8604: 0a000002 beq 8614 <_Thread_queue_Enqueue_priority+0x10c>
search_priority = search_thread->current_priority;
8608: e59c4014 ldr r4, [ip, #20]
if ( priority >= search_priority )
860c: e1530004 cmp r3, r4
8610: 3afffff3 bcc 85e4 <_Thread_queue_Enqueue_priority+0xdc>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
8614: e5905030 ldr r5, [r0, #48] ; 0x30
8618: e3550001 cmp r5, #1
861c: 1affffe0 bne 85a4 <_Thread_queue_Enqueue_priority+0x9c>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
8620: e1530004 cmp r3, r4
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
8624: e3a03000 mov r3, #0
8628: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
862c: 0a000016 beq 868c <_Thread_queue_Enqueue_priority+0x184>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
8630: e59c3000 ldr r3, [ip]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
8634: e8811008 stm r1, {r3, ip}
search_node->next = the_node; next_node->previous = the_node;
8638: e5831004 str r1, [r3, #4]
next_node = search_node->next;
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
search_node->next = the_node;
863c: e58c1000 str r1, [ip]
next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
8640: e5810044 str r0, [r1, #68] ; 0x44
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
8644: e129f008 msr CPSR_fc, r8
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
8648: eaffffd6 b 85a8 <_Thread_queue_Enqueue_priority+0xa0>
864c: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
8650: eaffffda b 85c0 <_Thread_queue_Enqueue_priority+0xb8> <== NOT EXECUTED
8654: e129f008 msr CPSR_fc, r8
8658: eaffffbb b 854c <_Thread_queue_Enqueue_priority+0x44>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
865c: e1530004 cmp r3, r4
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
8660: e3a03000 mov r3, #0
8664: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
8668: 0a000007 beq 868c <_Thread_queue_Enqueue_priority+0x184>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
866c: e59c3004 ldr r3, [ip, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
8670: e581c000 str ip, [r1]
the_node->previous = previous_node;
8674: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
8678: e5831000 str r1, [r3]
search_node->previous = the_node;
867c: e58c1004 str r1, [ip, #4]
the_thread->Wait.queue = the_thread_queue;
8680: e5810044 str r0, [r1, #68] ; 0x44
8684: e129f008 msr CPSR_fc, r8
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
8688: eaffffc6 b 85a8 <_Thread_queue_Enqueue_priority+0xa0>
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
868c: e59c3040 ldr r3, [ip, #64] ; 0x40
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
8690: e28c203c add r2, ip, #60 ; 0x3c
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
8694: e881000c stm r1, {r2, r3}
the_node->previous = previous_node; previous_node->next = the_node;
8698: e5831000 str r1, [r3]
search_node->previous = the_node;
869c: e58c1040 str r1, [ip, #64] ; 0x40
the_thread->Wait.queue = the_thread_queue;
86a0: e5810044 str r0, [r1, #68] ; 0x44
86a4: e129f008 msr CPSR_fc, r8
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
86a8: e3a05001 mov r5, #1
86ac: eaffffbd b 85a8 <_Thread_queue_Enqueue_priority+0xa0>
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
86b0: e3e04000 mvn r4, #0
86b4: eaffffb7 b 8598 <_Thread_queue_Enqueue_priority+0x90>
00016358 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
16358: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1635c: e24dd024 sub sp, sp, #36 ; 0x24
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
16360: e28d1018 add r1, sp, #24 16364: e28d700c add r7, sp, #12 16368: e281b004 add fp, r1, #4
head->previous = NULL; tail->previous = head;
1636c: e58d1020 str r1, [sp, #32] 16370: e2801008 add r1, r0, #8
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
16374: e3a03000 mov r3, #0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
16378: e2872004 add r2, r7, #4 1637c: e58d1004 str r1, [sp, #4] 16380: e2801040 add r1, r0, #64 ; 0x40 16384: e58db018 str fp, [sp, #24]
head->previous = NULL;
16388: e58d301c str r3, [sp, #28]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
1638c: e58d200c str r2, [sp, #12]
head->previous = NULL;
16390: e58d3010 str r3, [sp, #16]
tail->previous = head;
16394: e58d7014 str r7, [sp, #20] 16398: e59fa1ac ldr sl, [pc, #428] ; 1654c <_Timer_server_Body+0x1f4> 1639c: e59f91ac ldr r9, [pc, #428] ; 16550 <_Timer_server_Body+0x1f8> 163a0: e58d1008 str r1, [sp, #8]
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
163a4: e58d2000 str r2, [sp] 163a8: e1a04000 mov r4, r0 163ac: e2806030 add r6, r0, #48 ; 0x30 163b0: e2808068 add r8, r0, #104 ; 0x68
{
/*
* 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;
163b4: e28d2018 add r2, sp, #24 163b8: e5842078 str r2, [r4, #120] ; 0x78
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
163bc: e59a3000 ldr r3, [sl]
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
163c0: e594103c ldr r1, [r4, #60] ; 0x3c
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
163c4: e1a02007 mov r2, r7 163c8: e1a00006 mov r0, r6
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
163cc: e584303c str r3, [r4, #60] ; 0x3c
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
163d0: e0611003 rsb r1, r1, r3 163d4: eb0011bd bl 1aad0 <_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();
163d8: e5995000 ldr r5, [r9]
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
163dc: e5942074 ldr r2, [r4, #116] ; 0x74
/*
* 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 ) {
163e0: e1550002 cmp r5, r2
163e4: 8a000022 bhi 16474 <_Timer_server_Body+0x11c>
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
163e8: 3a000018 bcc 16450 <_Timer_server_Body+0xf8>
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
163ec: e5845074 str r5, [r4, #116] ; 0x74
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
163f0: e5940078 ldr r0, [r4, #120] ; 0x78 163f4: eb0002d5 bl 16f50 <_Chain_Get>
if ( timer == NULL ) {
163f8: e2501000 subs r1, r0, #0
163fc: 0a00000b beq 16430 <_Timer_server_Body+0xd8>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
16400: e5913038 ldr r3, [r1, #56] ; 0x38 16404: e3530001 cmp r3, #1
16408: 0a000015 beq 16464 <_Timer_server_Body+0x10c>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
1640c: e3530003 cmp r3, #3
16410: 1afffff6 bne 163f0 <_Timer_server_Body+0x98>
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
16414: e2811010 add r1, r1, #16 16418: e1a00008 mov r0, r8 1641c: eb0011d6 bl 1ab7c <_Watchdog_Insert>
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
16420: e5940078 ldr r0, [r4, #120] ; 0x78 16424: eb0002c9 bl 16f50 <_Chain_Get>
if ( timer == NULL ) {
16428: e2501000 subs r1, r0, #0
1642c: 1afffff3 bne 16400 <_Timer_server_Body+0xa8>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
16430: e10f2000 mrs r2, CPSR 16434: e3823080 orr r3, r2, #128 ; 0x80 16438: e129f003 msr CPSR_fc, r3
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
1643c: e59d3018 ldr r3, [sp, #24] 16440: e153000b cmp r3, fp
16444: 0a00000f beq 16488 <_Timer_server_Body+0x130>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
16448: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 1644c: eaffffda b 163bc <_Timer_server_Body+0x64> <== NOT EXECUTED
/*
* 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 );
16450: e1a00008 mov r0, r8 16454: e3a01001 mov r1, #1 16458: e0652002 rsb r2, r5, r2 1645c: eb001169 bl 1aa08 <_Watchdog_Adjust> 16460: eaffffe1 b 163ec <_Timer_server_Body+0x94>
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
16464: e1a00006 mov r0, r6 16468: e2811010 add r1, r1, #16 1646c: eb0011c2 bl 1ab7c <_Watchdog_Insert> 16470: eaffffde b 163f0 <_Timer_server_Body+0x98>
/*
* 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 );
16474: e0621005 rsb r1, r2, r5 16478: e1a00008 mov r0, r8 1647c: e1a02007 mov r2, r7 16480: eb001192 bl 1aad0 <_Watchdog_Adjust_to_chain> 16484: eaffffd8 b 163ec <_Timer_server_Body+0x94>
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
16488: e5841078 str r1, [r4, #120] ; 0x78 1648c: e129f002 msr CPSR_fc, r2
_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 ) ) {
16490: e59d300c ldr r3, [sp, #12] 16494: e59d1000 ldr r1, [sp] 16498: e1530001 cmp r3, r1
1649c: 0a000015 beq 164f8 <_Timer_server_Body+0x1a0>
164a0: e1a05004 mov r5, r4 164a4: e59d4000 ldr r4, [sp] 164a8: ea000009 b 164d4 <_Timer_server_Body+0x17c>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
164ac: e5932000 ldr r2, [r3]
head->next = new_first;
new_first->previous = head;
164b0: e5827004 str r7, [r2, #4]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
164b4: e58d200c str r2, [sp, #12]
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
164b8: e3a02000 mov r2, #0 164bc: e5832008 str r2, [r3, #8] 164c0: e129f001 msr CPSR_fc, r1
/*
* 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 );
164c4: e2830020 add r0, r3, #32
164c8: e8900003 ldm r0, {r0, r1}
164cc: e1a0e00f mov lr, pc
164d0: e593f01c ldr pc, [r3, #28]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
164d4: e10f1000 mrs r1, CPSR 164d8: e3813080 orr r3, r1, #128 ; 0x80 164dc: e129f003 msr CPSR_fc, r3
initialized = false;
}
#endif
return status;
}
164e0: e59d300c ldr r3, [sp, #12]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
164e4: e1530004 cmp r3, r4
164e8: 1affffef bne 164ac <_Timer_server_Body+0x154>
164ec: e1a04005 mov r4, r5
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
164f0: e129f001 msr CPSR_fc, r1 164f4: eaffffae b 163b4 <_Timer_server_Body+0x5c>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
164f8: e3a03000 mov r3, #0 164fc: e5c4307c strb r3, [r4, #124] ; 0x7c 16500: e59f104c ldr r1, [pc, #76] ; 16554 <_Timer_server_Body+0x1fc> 16504: e5913000 ldr r3, [r1] 16508: e2833001 add r3, r3, #1 1650c: e5813000 str r3, [r1]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
16510: e3a01008 mov r1, #8 16514: e5940000 ldr r0, [r4] 16518: eb000f98 bl 1a380 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
1651c: e1a00004 mov r0, r4 16520: ebffff60 bl 162a8 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
16524: e1a00004 mov r0, r4 16528: ebffff74 bl 16300 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
1652c: eb000d4a bl 19a5c <_Thread_Enable_dispatch>
ts->active = true;
16530: e3a02001 mov r2, #1 16534: e5c4207c strb r2, [r4, #124] ; 0x7c
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
16538: e59d0004 ldr r0, [sp, #4] 1653c: eb0011f3 bl 1ad10 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
16540: e59d0008 ldr r0, [sp, #8] 16544: eb0011f1 bl 1ad10 <_Watchdog_Remove> 16548: eaffff99 b 163b4 <_Timer_server_Body+0x5c>
00008ce4 <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
8ce4: e92d40f0 push {r4, r5, r6, r7, lr}
return false;
}
}
return true;
}
8ce8: e59f5050 ldr r5, [pc, #80] ; 8d40 <_User_extensions_Thread_create+0x5c>
8cec: e4954004 ldr r4, [r5], #4
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
8cf0: e1540005 cmp r4, r5
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
8cf4: e1a06000 mov r6, r0
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
8cf8: 0a00000e beq 8d38 <_User_extensions_Thread_create+0x54>
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
status = (*the_extension->Callouts.thread_create)(
8cfc: e59f7040 ldr r7, [pc, #64] ; 8d44 <_User_extensions_Thread_create+0x60>
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
8d00: e5943014 ldr r3, [r4, #20]
8d04: e3530000 cmp r3, #0
status = (*the_extension->Callouts.thread_create)(
8d08: e1a01006 mov r1, r6
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
8d0c: 0a000004 beq 8d24 <_User_extensions_Thread_create+0x40>
status = (*the_extension->Callouts.thread_create)(
8d10: e5970004 ldr r0, [r7, #4]
8d14: e1a0e00f mov lr, pc
8d18: e12fff13 bx r3
_Thread_Executing,
the_thread
);
if ( !status )
8d1c: e3500000 cmp r0, #0
8d20: 08bd80f0 popeq {r4, r5, r6, r7, pc}
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
8d24: e5944000 ldr r4, [r4]
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
8d28: e1540005 cmp r4, r5
8d2c: 1afffff3 bne 8d00 <_User_extensions_Thread_create+0x1c>
if ( !status )
return false;
}
}
return true;
8d30: e3a00001 mov r0, #1
8d34: e8bd80f0 pop {r4, r5, r6, r7, pc}
8d38: e3a00001 mov r0, #1 <== NOT EXECUTED
}
8d3c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
0000aafc <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
aafc: e92d41f0 push {r4, r5, r6, r7, r8, lr}
ab00: e1a04000 mov r4, r0
ab04: e1a05002 mov r5, r2
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
ab08: e10f2000 mrs r2, CPSR
ab0c: e3823080 orr r3, r2, #128 ; 0x80
ab10: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
ab14: e1a07000 mov r7, r0
ab18: e4973004 ldr r3, [r7], #4
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
ab1c: e1530007 cmp r3, r7
ab20: 0a00001a beq ab90 <_Watchdog_Adjust+0x94>
switch ( direction ) {
ab24: e3510000 cmp r1, #0
ab28: 1a00001a bne ab98 <_Watchdog_Adjust+0x9c>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
ab2c: e3550000 cmp r5, #0
ab30: 0a000016 beq ab90 <_Watchdog_Adjust+0x94>
if ( units < _Watchdog_First( header )->delta_interval ) {
ab34: e5936010 ldr r6, [r3, #16]
ab38: e1550006 cmp r5, r6
ab3c: 21a01002 movcs r1, r2
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
ab40: 23a08001 movcs r8, #1
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
ab44: 2a000005 bcs ab60 <_Watchdog_Adjust+0x64>
ab48: ea00001a b abb8 <_Watchdog_Adjust+0xbc> <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
ab4c: e0555006 subs r5, r5, r6
ab50: 0a00000d beq ab8c <_Watchdog_Adjust+0x90>
if ( units < _Watchdog_First( header )->delta_interval ) {
ab54: e5936010 ldr r6, [r3, #16]
ab58: e1560005 cmp r6, r5
ab5c: 8a000014 bhi abb4 <_Watchdog_Adjust+0xb8>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
ab60: e5838010 str r8, [r3, #16]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
ab64: e129f001 msr CPSR_fc, r1
_ISR_Enable( level );
_Watchdog_Tickle( header );
ab68: e1a00004 mov r0, r4
ab6c: eb0000a4 bl ae04 <_Watchdog_Tickle>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
ab70: e10f1000 mrs r1, CPSR
ab74: e3813080 orr r3, r1, #128 ; 0x80
ab78: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
ab7c: e5942000 ldr r2, [r4]
_Watchdog_Tickle( header );
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
ab80: e1570002 cmp r7, r2
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
ab84: e1a03002 mov r3, r2
ab88: 1affffef bne ab4c <_Watchdog_Adjust+0x50>
ab8c: e1a02001 mov r2, r1
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
ab90: e129f002 msr CPSR_fc, r2
}
}
_ISR_Enable( level );
}
ab94: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
ab98: e3510001 cmp r1, #1
ab9c: 1afffffb bne ab90 <_Watchdog_Adjust+0x94>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
aba0: e5931010 ldr r1, [r3, #16]
aba4: e0815005 add r5, r1, r5
aba8: e5835010 str r5, [r3, #16]
abac: e129f002 msr CPSR_fc, r2
}
}
_ISR_Enable( level );
}
abb0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
abb4: e1a02001 mov r2, r1
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
abb8: e0655006 rsb r5, r5, r6
abbc: e5835010 str r5, [r3, #16]
break;
abc0: eafffff2 b ab90 <_Watchdog_Adjust+0x94>
000069c8 <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
69c8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
69cc: e1a00001 mov r0, r1
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
69d0: e24dd048 sub sp, sp, #72 ; 0x48
69d4: e1a05001 mov r5, r1
69d8: e1a06002 mov r6, r2
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
69dc: ebfffa29 bl 5288 <rtems_filesystem_dirname>
if ( old_parent_pathlen == 0 )
69e0: e2507000 subs r7, r0, #0
69e4: 1a000059 bne 6b50 <_rename_r+0x188>
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
69e8: e28d4018 add r4, sp, #24
69ec: e1a00005 mov r0, r5
69f0: e28d1044 add r1, sp, #68 ; 0x44
69f4: e1a02004 mov r2, r4
69f8: eb0000e8 bl 6da0 <rtems_filesystem_get_start_loc>
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;
69fc: e1a08007 mov r8, r7
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
6a00: e1a0e004 mov lr, r4
6a04: e8be000f ldm lr!, {r0, r1, r2, r3}
6a08: e28dc02c add ip, sp, #44 ; 0x2c
6a0c: e8ac000f stmia ip!, {r0, r1, r2, r3}
6a10: e59e3000 ldr r3, [lr]
name = old + old_parent_pathlen;
6a14: e0855007 add r5, r5, r7
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
6a18: e58c3000 str r3, [ip]
name = old + old_parent_pathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
6a1c: e1a00005 mov r0, r5
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
name = old + old_parent_pathlen;
6a20: e58d5040 str r5, [sp, #64] ; 0x40
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
6a24: eb0039b5 bl 15100 <strlen>
6a28: e1a01000 mov r1, r0
6a2c: e1a00005 mov r0, r5
6a30: ebfffa23 bl 52c4 <rtems_filesystem_prefix_separators>
6a34: e0855000 add r5, r5, r0
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
6a38: e1a00005 mov r0, r5
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
name = old + old_parent_pathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
6a3c: e58d5040 str r5, [sp, #64] ; 0x40
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
6a40: eb0039ae bl 15100 <strlen>
6a44: e28d702c add r7, sp, #44 ; 0x2c
6a48: e1a01000 mov r1, r0
6a4c: e3a02000 mov r2, #0
6a50: e1a00005 mov r0, r5
6a54: e1a03007 mov r3, r7
6a58: e58d2000 str r2, [sp]
6a5c: ebfff9d7 bl 51c0 <rtems_filesystem_evaluate_relative_path>
0, &old_loc, false );
if ( result != 0 ) {
6a60: e3500000 cmp r0, #0
6a64: 1a000031 bne 6b30 <_rename_r+0x168>
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
6a68: e28d5004 add r5, sp, #4
6a6c: e1a00006 mov r0, r6
6a70: e1a02005 mov r2, r5
6a74: e28d1044 add r1, sp, #68 ; 0x44
6a78: eb0000c8 bl 6da0 <rtems_filesystem_get_start_loc>
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
6a7c: e59d0044 ldr r0, [sp, #68] ; 0x44
6a80: e1a01005 mov r1, r5
6a84: e0860000 add r0, r6, r0
6a88: e28d2040 add r2, sp, #64 ; 0x40
6a8c: e59d3010 ldr r3, [sp, #16]
6a90: e1a0e00f mov lr, pc
6a94: e593f004 ldr pc, [r3, #4]
if ( result != 0 ) {
6a98: e3500000 cmp r0, #0
6a9c: 1a000037 bne 6b80 <_rename_r+0x1b8>
/*
* 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 ) {
6aa0: e59d3014 ldr r3, [sp, #20]
6aa4: e59d2028 ldr r2, [sp, #40] ; 0x28
6aa8: e1520003 cmp r2, r3
6aac: 1a000013 bne 6b00 <_rename_r+0x138>
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
rtems_set_errno_and_return_minus_one( EXDEV );
}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
6ab0: e1a01007 mov r1, r7
6ab4: e1a02005 mov r2, r5
6ab8: e59d3040 ldr r3, [sp, #64] ; 0x40
6abc: e59dc010 ldr ip, [sp, #16]
6ac0: e1a00004 mov r0, r4
6ac4: e1a0e00f mov lr, pc
6ac8: e59cf040 ldr pc, [ip, #64] ; 0x40
6acc: e1a06000 mov r6, r0
rtems_filesystem_freenode( &new_parent_loc );
6ad0: e1a00005 mov r0, r5
6ad4: ebfffa8d bl 5510 <rtems_filesystem_freenode>
if ( free_old_parentloc )
6ad8: e3580000 cmp r8, #0
6adc: 1a000004 bne 6af4 <_rename_r+0x12c>
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
6ae0: e1a00007 mov r0, r7
6ae4: ebfffa89 bl 5510 <rtems_filesystem_freenode>
return result;
}
6ae8: e1a00006 mov r0, r6
6aec: e28dd048 add sp, sp, #72 ; 0x48
6af0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
rtems_filesystem_freenode( &new_parent_loc );
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
6af4: e1a00004 mov r0, r4
6af8: ebfffa84 bl 5510 <rtems_filesystem_freenode>
6afc: eafffff7 b 6ae0 <_rename_r+0x118>
* 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 ) {
rtems_filesystem_freenode( &new_parent_loc );
6b00: e1a00005 mov r0, r5
6b04: ebfffa81 bl 5510 <rtems_filesystem_freenode>
if ( free_old_parentloc )
6b08: e3580000 cmp r8, #0
rtems_filesystem_freenode( &old_parent_loc );
6b0c: 11a00004 movne r0, r4
6b10: 1bfffa7e blne 5510 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &old_loc );
6b14: e1a00007 mov r0, r7
6b18: ebfffa7c bl 5510 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
6b1c: eb002c74 bl 11cf4 <__errno>
6b20: e3a03012 mov r3, #18
6b24: e5803000 str r3, [r0]
6b28: e3e06000 mvn r6, #0
6b2c: eaffffed b 6ae8 <_rename_r+0x120>
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 )
6b30: e3580000 cmp r8, #0
6b34: 1a000001 bne 6b40 <_rename_r+0x178>
rtems_filesystem_freenode( &old_parent_loc );
return -1;
6b38: e3e06000 mvn r6, #0 <== NOT EXECUTED
6b3c: eaffffe9 b 6ae8 <_rename_r+0x120> <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &old_loc, false );
if ( result != 0 ) {
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
6b40: e1a00004 mov r0, r4
6b44: ebfffa71 bl 5510 <rtems_filesystem_freenode>
return -1;
6b48: e3e06000 mvn r6, #0
6b4c: eaffffe5 b 6ae8 <_rename_r+0x120>
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,
6b50: e3a03000 mov r3, #0
6b54: e28d4018 add r4, sp, #24
6b58: e58d3000 str r3, [sp]
6b5c: e3a02002 mov r2, #2
6b60: e1a00005 mov r0, r5
6b64: e1a01007 mov r1, r7
6b68: e1a03004 mov r3, r4
6b6c: ebfff9af bl 5230 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
6b70: e3500000 cmp r0, #0
6b74: 1affffef bne 6b38 <_rename_r+0x170>
return -1;
free_old_parentloc = true;
6b78: e3a08001 mov r8, #1
6b7c: eaffff9f b 6a00 <_rename_r+0x38>
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
if ( result != 0 ) {
rtems_filesystem_freenode( &new_parent_loc );
6b80: e1a00005 mov r0, r5
6b84: ebfffa61 bl 5510 <rtems_filesystem_freenode>
if ( free_old_parentloc )
6b88: e3580000 cmp r8, #0
rtems_filesystem_freenode( &old_parent_loc );
6b8c: 11a00004 movne r0, r4
6b90: 1bfffa5e blne 5510 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &old_loc );
6b94: e1a00007 mov r0, r7
6b98: ebfffa5c bl 5510 <rtems_filesystem_freenode>
return -1;
6b9c: e3e06000 mvn r6, #0
6ba0: eaffffd0 b 6ae8 <_rename_r+0x120>
000066a4 <aio_fsync>:
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
66a4: e3500a02 cmp r0, #8192 ; 0x2000
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
66a8: e92d4030 push {r4, r5, lr}
66ac: e1a04001 mov r4, r1
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
66b0: 13a05016 movne r5, #22
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
66b4: 1a000011 bne 6700 <aio_fsync+0x5c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
66b8: e5910000 ldr r0, [r1]
66bc: e3a01003 mov r1, #3
66c0: eb001b60 bl d448 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
66c4: e2000003 and r0, r0, #3
66c8: e2400001 sub r0, r0, #1
66cc: e3500001 cmp r0, #1
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
66d0: 83a05009 movhi r5, #9
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
66d4: 8a000009 bhi 6700 <aio_fsync+0x5c>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
66d8: e3a00018 mov r0, #24
66dc: ebfff3f0 bl 36a4 <malloc>
if (req == NULL)
66e0: e2503000 subs r3, r0, #0
66e4: 0a000004 beq 66fc <aio_fsync+0x58>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
66e8: e5834014 str r4, [r3, #20]
req->aiocbp->aio_lio_opcode = LIO_SYNC;
66ec: e3a03003 mov r3, #3
66f0: e584302c str r3, [r4, #44] ; 0x2c
return rtems_aio_enqueue (req);
}
66f4: e8bd4030 pop {r4, r5, lr}
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
66f8: ea000172 b 6cc8 <rtems_aio_enqueue>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
66fc: e3a0500b mov r5, #11 <== NOT EXECUTED
6700: e3e03000 mvn r3, #0
6704: e5845030 str r5, [r4, #48] ; 0x30
6708: e5843034 str r3, [r4, #52] ; 0x34
670c: eb002925 bl 10ba8 <__errno>
6710: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
6714: e3e00000 mvn r0, #0
6718: e8bd8030 pop {r4, r5, pc}
00006eac <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
6eac: e92d4030 push {r4, r5, lr}
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
6eb0: e3a01003 mov r1, #3
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
6eb4: e1a04000 mov r4, r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
6eb8: e5900000 ldr r0, [r0]
6ebc: eb001961 bl d448 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
6ec0: e2000003 and r0, r0, #3
6ec4: e3500002 cmp r0, #2
6ec8: 13500000 cmpne r0, #0
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
6ecc: 13a05009 movne r5, #9
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
6ed0: 1a00000f bne 6f14 <aio_read+0x68>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
6ed4: e5943014 ldr r3, [r4, #20]
6ed8: e3530000 cmp r3, #0
6edc: 1a000013 bne 6f30 <aio_read+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
6ee0: e5943008 ldr r3, [r4, #8]
6ee4: e3530000 cmp r3, #0
6ee8: ba000010 blt 6f30 <aio_read+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
6eec: e3a00018 mov r0, #24
6ef0: ebfff1eb bl 36a4 <malloc>
if (req == NULL)
6ef4: e2503000 subs r3, r0, #0
6ef8: 0a000004 beq 6f10 <aio_read+0x64>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
6efc: e5834014 str r4, [r3, #20]
req->aiocbp->aio_lio_opcode = LIO_READ;
6f00: e3a03001 mov r3, #1
6f04: e584302c str r3, [r4, #44] ; 0x2c
return rtems_aio_enqueue (req);
}
6f08: e8bd4030 pop {r4, r5, lr}
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
6f0c: eaffff6d b 6cc8 <rtems_aio_enqueue>
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
6f10: e3a0500b mov r5, #11 <== NOT EXECUTED
6f14: e3e03000 mvn r3, #0
6f18: e5845030 str r5, [r4, #48] ; 0x30
6f1c: e5843034 str r3, [r4, #52] ; 0x34
6f20: eb002720 bl 10ba8 <__errno>
6f24: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
6f28: e3e00000 mvn r0, #0
6f2c: e8bd8030 pop {r4, r5, pc}
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
6f30: e3a05016 mov r5, #22
6f34: eafffff6 b 6f14 <aio_read+0x68>
00006f40 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
6f40: e92d4030 push {r4, r5, lr}
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
6f44: e3a01003 mov r1, #3
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
6f48: e1a04000 mov r4, r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
6f4c: e5900000 ldr r0, [r0]
6f50: eb00193c bl d448 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
6f54: e2000003 and r0, r0, #3
6f58: e2400001 sub r0, r0, #1
6f5c: e3500001 cmp r0, #1
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
6f60: 83a05009 movhi r5, #9
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
6f64: 8a00000f bhi 6fa8 <aio_write+0x68>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
6f68: e5943014 ldr r3, [r4, #20]
6f6c: e3530000 cmp r3, #0
6f70: 1a000013 bne 6fc4 <aio_write+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
6f74: e5943008 ldr r3, [r4, #8]
6f78: e3530000 cmp r3, #0
6f7c: ba000010 blt 6fc4 <aio_write+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
6f80: e3a00018 mov r0, #24
6f84: ebfff1c6 bl 36a4 <malloc>
if (req == NULL)
6f88: e2503000 subs r3, r0, #0
6f8c: 0a000004 beq 6fa4 <aio_write+0x64>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
6f90: e5834014 str r4, [r3, #20]
req->aiocbp->aio_lio_opcode = LIO_WRITE;
6f94: e3a03002 mov r3, #2
6f98: e584302c str r3, [r4, #44] ; 0x2c
return rtems_aio_enqueue (req);
}
6f9c: e8bd4030 pop {r4, r5, lr}
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
6fa0: eaffff48 b 6cc8 <rtems_aio_enqueue>
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
6fa4: e3a0500b mov r5, #11 <== NOT EXECUTED
6fa8: e3e03000 mvn r3, #0
6fac: e5845030 str r5, [r4, #48] ; 0x30
6fb0: e5843034 str r3, [r4, #52] ; 0x34
6fb4: eb0026fb bl 10ba8 <__errno>
6fb8: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
6fbc: e3e00000 mvn r0, #0
6fc0: e8bd8030 pop {r4, r5, pc}
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
6fc4: e3a05016 mov r5, #22
6fc8: eafffff6 b 6fa8 <aio_write+0x68>
0000ab9c <devFS_evaluate_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
ab9c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
aba0: e3d2a007 bics sl, r2, #7
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
aba4: e1a09000 mov r9, r0
aba8: e1a04001 mov r4, r1
abac: e1a0b003 mov fp, r3
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
abb0: 1a000027 bne ac54 <devFS_evaluate_path+0xb8>
rtems_set_errno_and_return_minus_one( EPERM );
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
abb4: e5937000 ldr r7, [r3]
if (!device_name_table)
abb8: e3570000 cmp r7, #0
abbc: 0a000029 beq ac68 <devFS_evaluate_path+0xcc>
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
abc0: e59f30b4 ldr r3, [pc, #180] ; ac7c <devFS_evaluate_path+0xe0>
abc4: e5938000 ldr r8, [r3]
abc8: e3580000 cmp r8, #0
abcc: 11a0500a movne r5, sl
abd0: 0a000010 beq ac18 <devFS_evaluate_path+0x7c>
if (!device_name_table[i].device_name)
abd4: e08aa10a add sl, sl, sl, lsl #2
abd8: e797610a ldr r6, [r7, sl, lsl #2]
abdc: e2561000 subs r1, r6, #0
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
abe0: e1a00009 mov r0, r9
abe4: e1a02004 mov r2, r4
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++) {
if (!device_name_table[i].device_name)
abe8: e087a10a add sl, r7, sl, lsl #2
abec: 0a000005 beq ac08 <devFS_evaluate_path+0x6c>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
abf0: eb000de0 bl e378 <strncmp>
abf4: e3500000 cmp r0, #0
abf8: 1a000002 bne ac08 <devFS_evaluate_path+0x6c>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
abfc: e7d60004 ldrb r0, [r6, r4]
ac00: e3500000 cmp r0, #0
ac04: 0a000008 beq ac2c <devFS_evaluate_path+0x90>
/* 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++) {
ac08: e2855001 add r5, r5, #1
ac0c: e1580005 cmp r8, r5
ac10: e1a0a005 mov sl, r5
ac14: 8affffee bhi abd4 <devFS_evaluate_path+0x38>
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
ac18: eb000a17 bl d47c <__errno>
ac1c: e3a03002 mov r3, #2
ac20: e5803000 str r3, [r0]
ac24: e3e00000 mvn r0, #0
}
ac28: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
ac2c: e59f304c ldr r3, [pc, #76] ; ac80 <devFS_evaluate_path+0xe4>
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
ac30: e59f204c ldr r2, [pc, #76] ; ac84 <devFS_evaluate_path+0xe8>
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
ac34: e5933000 ldr r3, [r3]
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
ac38: e58b2008 str r2, [fp, #8]
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
ac3c: e5933028 ldr r3, [r3, #40] ; 0x28
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
ac40: e59f2040 ldr r2, [pc, #64] ; ac88 <devFS_evaluate_path+0xec>
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
ac44: e58ba000 str sl, [fp]
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
ac48: e58b200c str r2, [fp, #12]
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
ac4c: e58b3010 str r3, [fp, #16]
return 0;
ac50: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
ac54: eb000a08 bl d47c <__errno> <== NOT EXECUTED
ac58: e3a03001 mov r3, #1 <== NOT EXECUTED
ac5c: e5803000 str r3, [r0] <== NOT EXECUTED
ac60: e3e00000 mvn r0, #0 <== NOT EXECUTED
ac64: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/* 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 );
ac68: eb000a03 bl d47c <__errno>
ac6c: e3a0300e mov r3, #14
ac70: e5803000 str r3, [r0]
ac74: e3e00000 mvn r0, #0
ac78: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000325c <drainOutput>:
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
325c: e59030b4 ldr r3, [r0, #180] ; 0xb4
3260: e3530000 cmp r3, #0
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
3264: e92d4030 push {r4, r5, lr}
3268: e1a04000 mov r4, r0
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
326c: 08bd8030 popeq {r4, r5, pc}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3270: e10f3000 mrs r3, CPSR
3274: e3832080 orr r2, r3, #128 ; 0x80
3278: e129f002 msr CPSR_fc, r2
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
327c: e5901084 ldr r1, [r0, #132] ; 0x84
3280: e5902080 ldr r2, [r0, #128] ; 0x80
3284: e1510002 cmp r1, r2
3288: 0a00000f beq 32cc <drainOutput+0x70>
tty->rawOutBufState = rob_wait;
328c: e3a05002 mov r5, #2 <== NOT EXECUTED
3290: e5845094 str r5, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3294: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
3298: e3a01000 mov r1, #0 <== NOT EXECUTED
329c: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED
32a0: e1a02001 mov r2, r1 <== NOT EXECUTED
32a4: eb0009d4 bl 59fc <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
32a8: e3500000 cmp r0, #0 <== NOT EXECUTED
32ac: 1a000008 bne 32d4 <drainOutput+0x78> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
32b0: e10f3000 mrs r3, CPSR <== NOT EXECUTED
32b4: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
32b8: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
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) {
32bc: e5941084 ldr r1, [r4, #132] ; 0x84 <== NOT EXECUTED
32c0: e5942080 ldr r2, [r4, #128] ; 0x80 <== NOT EXECUTED
32c4: e1510002 cmp r1, r2 <== NOT EXECUTED
32c8: 1afffff0 bne 3290 <drainOutput+0x34> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
32cc: e129f003 msr CPSR_fc, r3
32d0: e8bd8030 pop {r4, r5, pc}
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
32d4: eb000b70 bl 609c <rtems_fatal_error_occurred> <== NOT EXECUTED
0000408c <erase>:
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
408c: e5903020 ldr r3, [r0, #32]
4090: e3530000 cmp r3, #0
* 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)
{
4094: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
4098: e1a04000 mov r4, r0
409c: e1a06001 mov r6, r1
if (tty->ccount == 0)
40a0: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return;
if (lineFlag) {
40a4: e3510000 cmp r1, #0
40a8: 0a000010 beq 40f0 <erase+0x64>
if (!(tty->termios.c_lflag & ECHO)) {
40ac: e590103c ldr r1, [r0, #60] ; 0x3c
40b0: e2112008 ands r2, r1, #8
tty->ccount = 0;
40b4: 05802020 streq r2, [r0, #32]
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
40b8: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
40bc: e2110010 ands r0, r1, #16
40c0: 1a00000c bne 40f8 <erase+0x6c>
tty->ccount = 0;
40c4: e5840020 str r0, [r4, #32] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
40c8: e1a01004 mov r1, r4 <== NOT EXECUTED
40cc: e5d40044 ldrb r0, [r4, #68] ; 0x44 <== NOT EXECUTED
40d0: ebffffc8 bl 3ff8 <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
40d4: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
40d8: e3130020 tst r3, #32 <== NOT EXECUTED
40dc: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
echo ('\n', tty);
40e0: e3a0000a mov r0, #10 <== NOT EXECUTED
40e4: e1a01004 mov r1, r4 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
40e8: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
40ec: eaffffc1 b 3ff8 <echo> <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
40f0: e590103c ldr r1, [r0, #60] ; 0x3c
40f4: e2012008 and r2, r1, #8
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
40f8: e59f7198 ldr r7, [pc, #408] ; 4298 <erase+0x20c>
40fc: ea000008 b 4124 <erase+0x98>
4100: e3110c02 tst r1, #512 ; 0x200 <== NOT EXECUTED
4104: 1a00004b bne 4238 <erase+0x1ac> <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
4108: e3560000 cmp r6, #0 <== NOT EXECUTED
410c: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
4110: e5943020 ldr r3, [r4, #32]
4114: e3530000 cmp r3, #0
4118: 0a000045 beq 4234 <erase+0x1a8>
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
411c: e594103c ldr r1, [r4, #60] ; 0x3c
4120: e2012008 and r2, r1, #8
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
4124: e2433001 sub r3, r3, #1
4128: e594001c ldr r0, [r4, #28]
412c: e5843020 str r3, [r4, #32]
if (tty->termios.c_lflag & ECHO) {
4130: e3520000 cmp r2, #0
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
4134: e7d05003 ldrb r5, [r0, r3]
if (tty->termios.c_lflag & ECHO) {
4138: 0afffff2 beq 4108 <erase+0x7c>
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
413c: e3560000 cmp r6, #0
4140: 1a000001 bne 414c <erase+0xc0>
4144: e3110010 tst r1, #16
4148: 0a000035 beq 4224 <erase+0x198>
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
414c: e3550009 cmp r5, #9
4150: 0a00000f beq 4194 <erase+0x108>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
4154: e5973000 ldr r3, [r7]
4158: e2855001 add r5, r5, #1
415c: e7d33005 ldrb r3, [r3, r5]
4160: e3130020 tst r3, #32
4164: 1affffe5 bne 4100 <erase+0x74>
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
4168: e59f012c ldr r0, [pc, #300] ; 429c <erase+0x210>
416c: e3a01003 mov r1, #3
4170: e1a02004 mov r2, r4
4174: ebfffefc bl 3d6c <rtems_termios_puts>
if (tty->column)
4178: e5943028 ldr r3, [r4, #40] ; 0x28
417c: e3530000 cmp r3, #0
tty->column--;
4180: 12433001 subne r3, r3, #1
4184: 15843028 strne r3, [r4, #40] ; 0x28
}
}
}
if (!lineFlag)
4188: e3560000 cmp r6, #0
418c: 1affffdf bne 4110 <erase+0x84>
4190: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
4194: e3530000 cmp r3, #0
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
int col = tty->read_start_column;
4198: e594502c ldr r5, [r4, #44] ; 0x2c
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
419c: 0a000011 beq 41e8 <erase+0x15c>
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
41a0: e5978000 ldr r8, [r7]
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
int col = tty->read_start_column;
int i = 0;
41a4: e3a02000 mov r2, #0
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
41a8: e201ac02 and sl, r1, #512 ; 0x200
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
41ac: e7d01002 ldrb r1, [r0, r2]
if (c == '\t') {
41b0: e3510009 cmp r1, #9
col = (col | 7) + 1;
41b4: 03855007 orreq r5, r5, #7
} else if (iscntrl (c)) {
41b8: e088c001 add ip, r8, r1
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
41bc: e2822001 add r2, r2, #1
if (c == '\t') {
col = (col | 7) + 1;
41c0: 02855001 addeq r5, r5, #1
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
41c4: 0a000005 beq 41e0 <erase+0x154>
col = (col | 7) + 1;
} else if (iscntrl (c)) {
41c8: e5dcc001 ldrb ip, [ip, #1]
41cc: e31c0020 tst ip, #32
if (tty->termios.c_lflag & ECHOCTL)
col += 2;
} else {
col++;
41d0: 02855001 addeq r5, r5, #1
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
41d4: 0a000001 beq 41e0 <erase+0x154>
if (tty->termios.c_lflag & ECHOCTL)
41d8: e35a0000 cmp sl, #0 <== NOT EXECUTED
col += 2;
41dc: 12855002 addne r5, r5, #2 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
41e0: e1530002 cmp r3, r2
41e4: 1afffff0 bne 41ac <erase+0x120>
}
/*
* Back up over the tab
*/
while (tty->column > col) {
41e8: e5943028 ldr r3, [r4, #40] ; 0x28
41ec: e1550003 cmp r5, r3
41f0: aaffffc4 bge 4108 <erase+0x7c>
rtems_termios_puts ("\b", 1, tty);
41f4: e59f00a4 ldr r0, [pc, #164] ; 42a0 <erase+0x214>
41f8: e3a01001 mov r1, #1
41fc: e1a02004 mov r2, r4
4200: ebfffed9 bl 3d6c <rtems_termios_puts>
tty->column--;
4204: e5943028 ldr r3, [r4, #40] ; 0x28
4208: e2433001 sub r3, r3, #1
}
/*
* Back up over the tab
*/
while (tty->column > col) {
420c: e1530005 cmp r3, r5
rtems_termios_puts ("\b", 1, tty);
tty->column--;
4210: e5843028 str r3, [r4, #40] ; 0x28
}
/*
* Back up over the tab
*/
while (tty->column > col) {
4214: cafffff6 bgt 41f4 <erase+0x168>
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
4218: e3560000 cmp r6, #0
421c: 1affffbb bne 4110 <erase+0x84>
4220: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== 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);
4224: e5d40043 ldrb r0, [r4, #67] ; 0x43 <== NOT EXECUTED
4228: e1a01004 mov r1, r4 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
422c: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== 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);
4230: eaffff70 b 3ff8 <echo> <== NOT EXECUTED
4234: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
4238: e59f005c ldr r0, [pc, #92] ; 429c <erase+0x210> <== NOT EXECUTED
423c: e3a01003 mov r1, #3 <== NOT EXECUTED
4240: e1a02004 mov r2, r4 <== NOT EXECUTED
4244: ebfffec8 bl 3d6c <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
4248: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
424c: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
4250: 12433001 subne r3, r3, #1 <== NOT EXECUTED
4254: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
4258: e5973000 ldr r3, [r7] <== NOT EXECUTED
425c: e7d33005 ldrb r3, [r3, r5] <== NOT EXECUTED
4260: e3130020 tst r3, #32 <== NOT EXECUTED
4264: 0affffbf beq 4168 <erase+0xdc> <== NOT EXECUTED
4268: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
426c: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
4270: 0affffa4 beq 4108 <erase+0x7c> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
4274: e59f0020 ldr r0, [pc, #32] ; 429c <erase+0x210> <== NOT EXECUTED
4278: e3a01003 mov r1, #3 <== NOT EXECUTED
427c: e1a02004 mov r2, r4 <== NOT EXECUTED
4280: ebfffeb9 bl 3d6c <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
4284: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
4288: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
428c: 12433001 subne r3, r3, #1 <== NOT EXECUTED
4290: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
4294: eaffffbb b 4188 <erase+0xfc> <== NOT EXECUTED
00002c80 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
2c80: e92d000e push {r1, r2, r3}
2c84: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
2c88: e59f31d0 ldr r3, [pc, #464] ; 2e60 <fcntl+0x1e0>
2c8c: e5933000 ldr r3, [r3]
int fcntl(
int fd,
int cmd,
...
)
{
2c90: e24dd004 sub sp, sp, #4
int ret; va_list ap; va_start( ap, cmd );
2c94: e28d2028 add r2, sp, #40 ; 0x28
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
2c98: e1500003 cmp r0, r3
int fcntl(
int fd,
int cmd,
...
)
{
2c9c: e59d4024 ldr r4, [sp, #36] ; 0x24
int ret; va_list ap; va_start( ap, cmd );
2ca0: e58d2000 str r2, [sp]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
2ca4: 2a000061 bcs 2e30 <fcntl+0x1b0>
iop = rtems_libio_iop( fd );
2ca8: e59f71b4 ldr r7, [pc, #436] ; 2e64 <fcntl+0x1e4>
2cac: e5976000 ldr r6, [r7]
2cb0: e0600180 rsb r0, r0, r0, lsl #3
2cb4: e0865180 add r5, r6, r0, lsl #3
rtems_libio_check_is_open(iop);
2cb8: e595c014 ldr ip, [r5, #20]
2cbc: e31c0c01 tst ip, #256 ; 0x100
2cc0: 0a00005a beq 2e30 <fcntl+0x1b0>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
2cc4: e3540009 cmp r4, #9
2cc8: 979ff104 ldrls pc, [pc, r4, lsl #2]
2ccc: ea000028 b 2d74 <fcntl+0xf4>
2cd0: 00002d84 .word 0x00002d84
2cd4: 00002de8 .word 0x00002de8
2cd8: 00002df8 .word 0x00002df8
2cdc: 00002e18 .word 0x00002e18
2ce0: 00002d1c .word 0x00002d1c
2ce4: 00002cf8 .word 0x00002cf8
2ce8: 00002cf8 .word 0x00002cf8
2cec: 00002cf8 .word 0x00002cf8
2cf0: 00002cf8 .word 0x00002cf8
2cf4: 00002cf8 .word 0x00002cf8
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
2cf8: eb0030b0 bl efc0 <__errno>
2cfc: e3a03086 mov r3, #134 ; 0x86
2d00: e5803000 str r3, [r0]
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
if (err) {
errno = err;
ret = -1;
2d04: e3e06000 mvn r6, #0
va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; }
2d08: e1a00006 mov r0, r6
2d0c: e28dd004 add sp, sp, #4
2d10: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
2d14: e28dd00c add sp, sp, #12
2d18: e12fff1e bx lr
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
2d1c: e5920000 ldr r0, [r2]
2d20: eb000181 bl 332c <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
2d24: e5953014 ldr r3, [r5, #20]
2d28: e3c00f7f bic r0, r0, #508 ; 0x1fc
2d2c: e3c00002 bic r0, r0, #2
2d30: e1a00b00 lsl r0, r0, #22
2d34: e3c33c02 bic r3, r3, #512 ; 0x200
2d38: e1a00b20 lsr r0, r0, #22
2d3c: e3c33001 bic r3, r3, #1
2d40: e1800003 orr r0, r0, r3
2d44: e5850014 str r0, [r5, #20]
rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0;
2d48: e3a06000 mov r6, #0
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
2d4c: e1a00004 mov r0, r4
2d50: e5953020 ldr r3, [r5, #32]
2d54: e1a01005 mov r1, r5
2d58: e1a0e00f mov lr, pc
2d5c: e593f030 ldr pc, [r3, #48] ; 0x30
if (err) {
2d60: e2504000 subs r4, r0, #0
2d64: 0affffe7 beq 2d08 <fcntl+0x88>
errno = err;
2d68: eb003094 bl efc0 <__errno> <== NOT EXECUTED
2d6c: e5804000 str r4, [r0] <== NOT EXECUTED
2d70: eaffffe3 b 2d04 <fcntl+0x84> <== NOT EXECUTED
errno = ENOTSUP;
ret = -1;
break;
default:
errno = EINVAL;
2d74: eb003091 bl efc0 <__errno>
2d78: e3a03016 mov r3, #22
2d7c: e5803000 str r3, [r0]
2d80: eaffffdf b 2d04 <fcntl+0x84>
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
2d84: e592a000 ldr sl, [r2]
if ( fd2 )
2d88: e35a0000 cmp sl, #0
2d8c: 0a00002c beq 2e44 <fcntl+0x1c4>
diop = rtems_libio_iop( fd2 );
2d90: e153000a cmp r3, sl
2d94: 806aa18a rsbhi sl, sl, sl, lsl #3
2d98: 8086a18a addhi sl, r6, sl, lsl #3
2d9c: 81a0900a movhi r9, sl
2da0: 93a09000 movls r9, #0
2da4: 91a0a009 movls sl, r9
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
2da8: e2857018 add r7, r5, #24
2dac: e8b7000f ldm r7!, {r0, r1, r2, r3}
2db0: e28a8018 add r8, sl, #24
2db4: e8a8000f stmia r8!, {r0, r1, r2, r3}
ret = (int) (diop - rtems_libio_iops);
2db8: e0669009 rsb r9, r6, r9
2dbc: e1a091c9 asr r9, r9, #3
2dc0: e0896189 add r6, r9, r9, lsl #3
2dc4: e0866306 add r6, r6, r6, lsl #6
2dc8: e0896186 add r6, r9, r6, lsl #3
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
2dcc: e5973000 ldr r3, [r7]
ret = (int) (diop - rtems_libio_iops);
2dd0: e0866786 add r6, r6, r6, lsl #15
2dd4: e0896186 add r6, r9, r6, lsl #3
ret = -1;
break;
}
}
diop->flags = iop->flags;
2dd8: e58ac014 str ip, [sl, #20]
diop->pathinfo = iop->pathinfo;
2ddc: e5883000 str r3, [r8]
ret = (int) (diop - rtems_libio_iops);
2de0: e2666000 rsb r6, r6, #0
2de4: ea00000e b 2e24 <fcntl+0x1a4>
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
2de8: e31c0b02 tst ip, #2048 ; 0x800
2dec: 03a06000 moveq r6, #0
2df0: 13a06001 movne r6, #1
2df4: eaffffd4 b 2d4c <fcntl+0xcc>
* 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 ) )
2df8: e5926000 ldr r6, [r2]
2dfc: e3560000 cmp r6, #0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
2e00: 138ccb02 orrne ip, ip, #2048 ; 0x800
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
2e04: 03cccb02 biceq ip, ip, #2048 ; 0x800
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
2e08: 1585c014 strne ip, [r5, #20]
rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0;
2e0c: 13a06000 movne r6, #0
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
2e10: 0585c014 streq ip, [r5, #20]
2e14: eaffffcc b 2d4c <fcntl+0xcc>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
2e18: e1a0000c mov r0, ip
2e1c: eb00014f bl 3360 <rtems_libio_to_fcntl_flags>
2e20: e1a06000 mov r6, r0
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
2e24: e3560000 cmp r6, #0
2e28: aaffffc7 bge 2d4c <fcntl+0xcc>
2e2c: eaffffb5 b 2d08 <fcntl+0x88> <== NOT EXECUTED
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
2e30: eb003062 bl efc0 <__errno>
2e34: e3a03009 mov r3, #9
2e38: e5803000 str r3, [r0]
2e3c: e3e06000 mvn r6, #0
2e40: eaffffb0 b 2d08 <fcntl+0x88>
fd2 = va_arg( ap, int );
if ( fd2 )
diop = rtems_libio_iop( fd2 );
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
2e44: eb000158 bl 33ac <rtems_libio_allocate>
if ( diop == 0 ) {
2e48: e250a000 subs sl, r0, #0
2e4c: 0affffac beq 2d04 <fcntl+0x84>
2e50: e595c014 ldr ip, [r5, #20]
2e54: e1a0900a mov r9, sl
2e58: e5976000 ldr r6, [r7]
2e5c: eaffffd1 b 2da8 <fcntl+0x128>
0000c760 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
c760: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
c764: e59f546c ldr r5, [pc, #1132] ; cbd8 <fifo_open+0x478>
c768: e5958000 ldr r8, [r5]
c76c: e3580000 cmp r8, #0
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
c770: e24dd00c sub sp, sp, #12
c774: e1a04000 mov r4, r0
c778: e1a06001 mov r6, r1
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
c77c: 0a000024 beq c814 <fifo_open+0xb4>
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
c780: e3a01000 mov r1, #0
c784: e1a00008 mov r0, r8
c788: e1a02001 mov r2, r1
c78c: ebffed66 bl 7d2c <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
c790: e250a000 subs sl, r0, #0
c794: 1a0000e4 bne cb2c <fifo_open+0x3cc>
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
c798: e5945000 ldr r5, [r4]
if (pipe == NULL) {
c79c: e3550000 cmp r5, #0
c7a0: 0a00007f beq c9a4 <fifo_open+0x244>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
c7a4: e3a01000 mov r1, #0
c7a8: e5950028 ldr r0, [r5, #40] ; 0x28
c7ac: e1a02001 mov r2, r1
c7b0: ebffed5d bl 7d2c <rtems_semaphore_obtain>
err = -EINTR;
if (*pipep == NULL) {
c7b4: e5943000 ldr r3, [r4]
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
c7b8: e3500000 cmp r0, #0
c7bc: 01a07000 moveq r7, r0
c7c0: 13e07003 mvnne r7, #3
err = -EINTR;
if (*pipep == NULL) {
c7c4: e3530000 cmp r3, #0
c7c8: 0a0000c7 beq caec <fifo_open+0x38c>
else
*pipep = pipe;
}
out:
pipe_unlock();
c7cc: ebffffa9 bl c678 <pipe_unlock>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
c7d0: e3570000 cmp r7, #0
c7d4: 1a00000b bne c808 <fifo_open+0xa8>
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
c7d8: e5963014 ldr r3, [r6, #20]
c7dc: e2033006 and r3, r3, #6
c7e0: e3530004 cmp r3, #4
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
c7e4: e5945000 ldr r5, [r4]
switch (LIBIO_ACCMODE(iop)) {
c7e8: 0a000015 beq c844 <fifo_open+0xe4>
c7ec: e3530006 cmp r3, #6
c7f0: 0a000057 beq c954 <fifo_open+0x1f4>
c7f4: e3530002 cmp r3, #2
c7f8: 0a000035 beq c8d4 <fifo_open+0x174>
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
c7fc: e5950028 ldr r0, [r5, #40] ; 0x28
c800: ebffed92 bl 7e50 <rtems_semaphore_release>
return 0;
c804: e3a07000 mov r7, #0
out_error:
pipe_release(pipep, iop);
return err;
}
c808: e1a00007 mov r0, r7
c80c: e28dd00c add sp, sp, #12
c810: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
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 );
c814: e59f73c0 ldr r7, [pc, #960] ; cbdc <fifo_open+0x47c>
c818: e1a01008 mov r1, r8
c81c: e5970000 ldr r0, [r7]
c820: e1a02008 mov r2, r8
c824: ebffed40 bl 7d2c <rtems_semaphore_obtain>
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
c828: e5953000 ldr r3, [r5]
c82c: e3530000 cmp r3, #0
c830: 0a0000b2 beq cb00 <fifo_open+0x3a0>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
c834: e5970000 ldr r0, [r7] <== NOT EXECUTED
c838: ebffed84 bl 7e50 <rtems_semaphore_release> <== NOT EXECUTED
c83c: e5958000 ldr r8, [r5] <== NOT EXECUTED
c840: eaffffce b c780 <fifo_open+0x20> <== NOT EXECUTED
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
c844: e5953014 ldr r3, [r5, #20]
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
c848: e5951024 ldr r1, [r5, #36] ; 0x24
if (pipe->Writers ++ == 0)
c84c: e2832001 add r2, r3, #1
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
c850: e2811001 add r1, r1, #1
if (pipe->Writers ++ == 0)
c854: e3530000 cmp r3, #0
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
c858: e5851024 str r1, [r5, #36] ; 0x24
if (pipe->Writers ++ == 0)
c85c: e5852014 str r2, [r5, #20]
c860: 0a0000b3 beq cb34 <fifo_open+0x3d4>
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
c864: e5953010 ldr r3, [r5, #16]
c868: e3530000 cmp r3, #0
c86c: 1affffe2 bne c7fc <fifo_open+0x9c>
c870: e5963014 ldr r3, [r6, #20]
c874: e3130001 tst r3, #1
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
c878: 05957020 ldreq r7, [r5, #32]
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
c87c: 0a000007 beq c8a0 <fifo_open+0x140>
c880: ea0000c3 b cb94 <fifo_open+0x434>
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
c884: e5950028 ldr r0, [r5, #40] ; 0x28
c888: ebffed27 bl 7d2c <rtems_semaphore_obtain>
c88c: e3500000 cmp r0, #0
c890: 1a00000a bne c8c0 <fifo_open+0x160>
goto out_error;
} while (prevCounter == pipe->readerCounter);
c894: e5953020 ldr r3, [r5, #32]
c898: e1530007 cmp r3, r7
c89c: 1affffd6 bne c7fc <fifo_open+0x9c>
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
c8a0: e5950028 ldr r0, [r5, #40] ; 0x28
c8a4: ebffed69 bl 7e50 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
c8a8: e3a01000 mov r1, #0
c8ac: e5950030 ldr r0, [r5, #48] ; 0x30
c8b0: eb000728 bl e558 <rtems_barrier_wait>
c8b4: e2501000 subs r1, r0, #0
goto out_error;
if (! PIPE_LOCK(pipe))
c8b8: e1a02001 mov r2, r1
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
c8bc: 0afffff0 beq c884 <fifo_open+0x124>
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
c8c0: e3e07003 mvn r7, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
c8c4: e1a00004 mov r0, r4
c8c8: e1a01006 mov r1, r6
c8cc: ebffff6d bl c688 <pipe_release>
return err;
c8d0: eaffffcc b c808 <fifo_open+0xa8>
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
c8d4: e5953010 ldr r3, [r5, #16]
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
c8d8: e5951020 ldr r1, [r5, #32]
if (pipe->Readers ++ == 0)
c8dc: e2832001 add r2, r3, #1
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
c8e0: e2811001 add r1, r1, #1
if (pipe->Readers ++ == 0)
c8e4: e3530000 cmp r3, #0
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
c8e8: e5851020 str r1, [r5, #32]
if (pipe->Readers ++ == 0)
c8ec: e5852010 str r2, [r5, #16]
c8f0: 0a000097 beq cb54 <fifo_open+0x3f4>
PIPE_WAKEUPWRITERS(pipe);
if (pipe->Writers == 0) {
c8f4: e5953014 ldr r3, [r5, #20]
c8f8: e3530000 cmp r3, #0
c8fc: 1affffbe bne c7fc <fifo_open+0x9c>
/* Not an error */
if (LIBIO_NODELAY(iop))
c900: e5963014 ldr r3, [r6, #20]
c904: e3130001 tst r3, #1
c908: 1affffbb bne c7fc <fifo_open+0x9c>
break;
prevCounter = pipe->writerCounter;
c90c: e5957024 ldr r7, [r5, #36] ; 0x24
c910: ea000006 b c930 <fifo_open+0x1d0>
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
c914: e5950028 ldr r0, [r5, #40] ; 0x28
c918: ebffed03 bl 7d2c <rtems_semaphore_obtain>
c91c: e3500000 cmp r0, #0
c920: 1affffe6 bne c8c0 <fifo_open+0x160>
goto out_error;
} while (prevCounter == pipe->writerCounter);
c924: e5953024 ldr r3, [r5, #36] ; 0x24
c928: e1530007 cmp r3, r7
c92c: 1affffb2 bne c7fc <fifo_open+0x9c>
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
c930: e5950028 ldr r0, [r5, #40] ; 0x28
c934: ebffed45 bl 7e50 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
c938: e3a01000 mov r1, #0
c93c: e595002c ldr r0, [r5, #44] ; 0x2c
c940: eb000704 bl e558 <rtems_barrier_wait>
c944: e2501000 subs r1, r0, #0
goto out_error;
if (! PIPE_LOCK(pipe))
c948: e1a02001 mov r2, r1
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
c94c: 0afffff0 beq c914 <fifo_open+0x1b4>
c950: eaffffda b c8c0 <fifo_open+0x160> <== NOT EXECUTED
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
c954: e5953010 ldr r3, [r5, #16]
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
c958: e5951020 ldr r1, [r5, #32]
if (pipe->Readers ++ == 0)
c95c: e2832001 add r2, r3, #1
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
c960: e2811001 add r1, r1, #1
if (pipe->Readers ++ == 0)
c964: e3530000 cmp r3, #0
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
c968: e5851020 str r1, [r5, #32]
if (pipe->Readers ++ == 0)
c96c: e5852010 str r2, [r5, #16]
c970: 0a000073 beq cb44 <fifo_open+0x3e4>
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
c974: e5953014 ldr r3, [r5, #20]
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
c978: e5951024 ldr r1, [r5, #36] ; 0x24
if (pipe->Writers ++ == 0)
c97c: e2832001 add r2, r3, #1
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
c980: e2811001 add r1, r1, #1
if (pipe->Writers ++ == 0)
c984: e3530000 cmp r3, #0
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
c988: e5851024 str r1, [r5, #36] ; 0x24
if (pipe->Writers ++ == 0)
c98c: e5852014 str r2, [r5, #20]
c990: 1affff99 bne c7fc <fifo_open+0x9c>
PIPE_WAKEUPREADERS(pipe);
c994: e595002c ldr r0, [r5, #44] ; 0x2c
c998: e28d1008 add r1, sp, #8
c99c: eb0006d5 bl e4f8 <rtems_barrier_release>
c9a0: eaffff95 b c7fc <fifo_open+0x9c>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
c9a4: e3a00034 mov r0, #52 ; 0x34
c9a8: ebffdfb9 bl 4894 <malloc>
if (pipe == NULL)
c9ac: e3500000 cmp r0, #0
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
c9b0: e1a05000 mov r5, r0
c9b4: e1a08000 mov r8, r0
if (pipe == NULL)
c9b8: 0a000081 beq cbc4 <fifo_open+0x464>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
c9bc: e1a02000 mov r2, r0
c9c0: e482a004 str sl, [r2], #4
c9c4: e2822004 add r2, r2, #4
c9c8: e482a004 str sl, [r2], #4
c9cc: e482a004 str sl, [r2], #4
c9d0: e482a004 str sl, [r2], #4
c9d4: e482a004 str sl, [r2], #4
c9d8: e482a004 str sl, [r2], #4
c9dc: e482a004 str sl, [r2], #4
c9e0: e482a004 str sl, [r2], #4
c9e4: e482a004 str sl, [r2], #4
c9e8: e482a004 str sl, [r2], #4
c9ec: e482a004 str sl, [r2], #4
pipe->Size = PIPE_BUF;
c9f0: e3a03c02 mov r3, #512 ; 0x200
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
c9f4: e582a000 str sl, [r2]
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
c9f8: e1a00003 mov r0, r3
pipe = malloc(sizeof(pipe_control_t));
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
pipe->Size = PIPE_BUF;
c9fc: e5853004 str r3, [r5, #4]
pipe->Buffer = malloc(pipe->Size);
ca00: ebffdfa3 bl 4894 <malloc>
if (! pipe->Buffer)
ca04: e3500000 cmp r0, #0
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
ca08: e5850000 str r0, [r5]
if (! pipe->Buffer)
ca0c: 0a00006a beq cbbc <fifo_open+0x45c>
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
ca10: e59f71c8 ldr r7, [pc, #456] ; cbe0 <fifo_open+0x480>
ca14: e5d70000 ldrb r0, [r7]
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
ca18: e3800205 orr r0, r0, #1342177280 ; 0x50000000
ca1c: e3800849 orr r0, r0, #4784128 ; 0x490000
ca20: e1a0100a mov r1, sl
ca24: e3800c72 orr r0, r0, #29184 ; 0x7200
ca28: e1a0200a mov r2, sl
ca2c: e285302c add r3, r5, #44 ; 0x2c
ca30: eb000652 bl e380 <rtems_barrier_create>
ca34: e2501000 subs r1, r0, #0
ca38: 1a00005d bne cbb4 <fifo_open+0x454>
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'w', c),
ca3c: e5d73000 ldrb r3, [r7]
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(
ca40: e3833205 orr r3, r3, #1342177280 ; 0x50000000
ca44: e3833849 orr r3, r3, #4784128 ; 0x490000
ca48: e3830c77 orr r0, r3, #30464 ; 0x7700
ca4c: e1a02001 mov r2, r1
ca50: e2853030 add r3, r5, #48 ; 0x30
ca54: eb000649 bl e380 <rtems_barrier_create>
ca58: e2503000 subs r3, r0, #0
ca5c: 1a000052 bne cbac <fifo_open+0x44c>
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
rtems_build_name ('P', 'I', 's', c), 1,
ca60: e5d70000 ldrb r0, [r7]
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(
ca64: e3800205 orr r0, r0, #1342177280 ; 0x50000000
ca68: e3800849 orr r0, r0, #4784128 ; 0x490000
ca6c: e285c028 add ip, r5, #40 ; 0x28
ca70: e3800c73 orr r0, r0, #29440 ; 0x7300
ca74: e3a01001 mov r1, #1
ca78: e3a02010 mov r2, #16
ca7c: e58dc000 str ip, [sp]
ca80: ebffec0f bl 7ac4 <rtems_semaphore_create>
ca84: e3500000 cmp r0, #0
ca88: 1a000045 bne cba4 <fifo_open+0x444>
/* 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
ca8c: e28d8004 add r8, sp, #4
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
ca90: e595102c ldr r1, [r5, #44] ; 0x2c
ca94: e1a02008 mov r2, r8
ca98: e59f0144 ldr r0, [pc, #324] ; cbe4 <fifo_open+0x484>
ca9c: ebfff29e bl 951c <_Objects_Get>
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
caa0: e590304c ldr r3, [r0, #76] ; 0x4c
caa4: e3833201 orr r3, r3, #268435456 ; 0x10000000
caa8: e580304c str r3, [r0, #76] ; 0x4c
_Thread_Enable_dispatch();
caac: ebfff5dc bl a224 <_Thread_Enable_dispatch>
cab0: e1a02008 mov r2, r8
cab4: e5951030 ldr r1, [r5, #48] ; 0x30
cab8: e59f0124 ldr r0, [pc, #292] ; cbe4 <fifo_open+0x484>
cabc: ebfff296 bl 951c <_Objects_Get>
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
cac0: e590304c ldr r3, [r0, #76] ; 0x4c
cac4: e3833201 orr r3, r3, #268435456 ; 0x10000000
cac8: e580304c str r3, [r0, #76] ; 0x4c
_Thread_Enable_dispatch();
cacc: ebfff5d4 bl a224 <_Thread_Enable_dispatch>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
cad0: e5d73000 ldrb r3, [r7]
cad4: e353007a cmp r3, #122 ; 0x7a
cad8: e2832001 add r2, r3, #1
c = 'a';
cadc: 03a03061 moveq r3, #97 ; 0x61
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
cae0: e5c72000 strb r2, [r7]
c = 'a';
cae4: 05c73000 strbeq r3, [r7]
cae8: eaffff2d b c7a4 <fifo_open+0x44>
if (! PIPE_LOCK(pipe))
err = -EINTR;
if (*pipep == NULL) {
if (err)
caec: e3570000 cmp r7, #0
caf0: 1a00001b bne cb64 <fifo_open+0x404>
pipe_free(pipe);
else
*pipep = pipe;
caf4: e5845000 str r5, [r4]
}
out:
pipe_unlock();
caf8: ebfffede bl c678 <pipe_unlock>
cafc: eaffff35 b c7d8 <fifo_open+0x78>
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
sc = rtems_semaphore_create(
cb00: e1a03008 mov r3, r8
cb04: e3a01001 mov r1, #1
cb08: e3a02054 mov r2, #84 ; 0x54
cb0c: e59f00d4 ldr r0, [pc, #212] ; cbe8 <fifo_open+0x488>
cb10: e58d5000 str r5, [sp]
cb14: ebffebea bl 7ac4 <rtems_semaphore_create>
cb18: e1a08000 mov r8, r0
cb1c: e5970000 ldr r0, [r7]
cb20: ebffecca bl 7e50 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
cb24: e3580000 cmp r8, #0
cb28: 0a000028 beq cbd0 <fifo_open+0x470>
)
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
cb2c: e3e0700b mvn r7, #11
cb30: eaffff34 b c808 <fifo_open+0xa8>
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
cb34: e595002c ldr r0, [r5, #44] ; 0x2c
cb38: e28d1008 add r1, sp, #8
cb3c: eb00066d bl e4f8 <rtems_barrier_release>
cb40: eaffff47 b c864 <fifo_open+0x104>
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
cb44: e5950030 ldr r0, [r5, #48] ; 0x30
cb48: e28d1008 add r1, sp, #8
cb4c: eb000669 bl e4f8 <rtems_barrier_release>
cb50: eaffff87 b c974 <fifo_open+0x214>
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
cb54: e5950030 ldr r0, [r5, #48] ; 0x30
cb58: e28d1008 add r1, sp, #8
cb5c: eb000665 bl e4f8 <rtems_barrier_release>
cb60: eaffff63 b c8f4 <fifo_open+0x194>
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
cb64: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED
cb68: eb000636 bl e448 <rtems_barrier_delete> <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
cb6c: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED
cb70: eb000634 bl e448 <rtems_barrier_delete> <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
cb74: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
cb78: ebffec42 bl 7c88 <rtems_semaphore_delete> <== NOT EXECUTED
free(pipe->Buffer);
cb7c: e5950000 ldr r0, [r5] <== NOT EXECUTED
cb80: ebffdd29 bl 402c <free> <== NOT EXECUTED
free(pipe);
cb84: e1a00005 mov r0, r5 <== NOT EXECUTED
cb88: ebffdd27 bl 402c <free> <== NOT EXECUTED
else
*pipep = pipe;
}
out:
pipe_unlock();
cb8c: ebfffeb9 bl c678 <pipe_unlock> <== NOT EXECUTED
cb90: eaffff1c b c808 <fifo_open+0xa8> <== NOT EXECUTED
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
cb94: e5950028 ldr r0, [r5, #40] ; 0x28
cb98: ebffecac bl 7e50 <rtems_semaphore_release>
err = -ENXIO;
cb9c: e3e07005 mvn r7, #5
goto out_error;
cba0: eaffff47 b c8c4 <fifo_open+0x164>
if (c ++ == 'z')
c = 'a';
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
cba4: e5950030 ldr r0, [r5, #48] ; 0x30
cba8: eb000626 bl e448 <rtems_barrier_delete>
err_wbar: rtems_barrier_delete(pipe->readBarrier);
cbac: e598002c ldr r0, [r8, #44] ; 0x2c
cbb0: eb000624 bl e448 <rtems_barrier_delete>
err_rbar: free(pipe->Buffer);
cbb4: e5980000 ldr r0, [r8]
cbb8: ebffdd1b bl 402c <free>
err_buf: free(pipe);
cbbc: e1a00008 mov r0, r8
cbc0: ebffdd19 bl 402c <free>
)
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
cbc4: e3e0700b mvn r7, #11
else
*pipep = pipe;
}
out:
pipe_unlock();
cbc8: ebfffeaa bl c678 <pipe_unlock>
cbcc: eaffff0d b c808 <fifo_open+0xa8>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
cbd0: e5958000 ldr r8, [r5]
cbd4: eafffee9 b c780 <fifo_open+0x20>
00002ef0 <fpathconf>:
{
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
2ef0: e59f310c ldr r3, [pc, #268] ; 3004 <fpathconf+0x114>
2ef4: e5933000 ldr r3, [r3]
2ef8: e1500003 cmp r0, r3
long fpathconf(
int fd,
int name
)
{
2efc: e52de004 push {lr} ; (str lr, [sp, #-4]!)
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
2f00: 2a000035 bcs 2fdc <fpathconf+0xec>
iop = rtems_libio_iop(fd);
2f04: e59f30fc ldr r3, [pc, #252] ; 3008 <fpathconf+0x118>
2f08: e5933000 ldr r3, [r3]
2f0c: e0600180 rsb r0, r0, r0, lsl #3
2f10: e0830180 add r0, r3, r0, lsl #3
rtems_libio_check_is_open(iop);
2f14: e5903014 ldr r3, [r0, #20]
2f18: e3130c01 tst r3, #256 ; 0x100
2f1c: 0a00002e beq 2fdc <fpathconf+0xec>
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
2f20: e3130002 tst r3, #2
2f24: 0a000031 beq 2ff0 <fpathconf+0x100>
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
2f28: e5903028 ldr r3, [r0, #40] ; 0x28
switch ( name ) {
2f2c: e351000b cmp r1, #11
2f30: 979ff101 ldrls pc, [pc, r1, lsl #2]
2f34: ea00000d b 2f70 <fpathconf+0x80>
2f38: 00002f84 .word 0x00002f84
2f3c: 00002f8c .word 0x00002f8c
2f40: 00002f94 .word 0x00002f94
2f44: 00002f9c .word 0x00002f9c
2f48: 00002fa4 .word 0x00002fa4
2f4c: 00002fac .word 0x00002fac
2f50: 00002fb4 .word 0x00002fb4
2f54: 00002fbc .word 0x00002fbc
2f58: 00002fc4 .word 0x00002fc4
2f5c: 00002fcc .word 0x00002fcc
2f60: 00002fd4 .word 0x00002fd4
2f64: 00002f68 .word 0x00002f68
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
2f68: e5930060 ldr r0, [r3, #96] ; 0x60
break;
2f6c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2f70: eb003012 bl efc0 <__errno>
2f74: e3a03016 mov r3, #22
2f78: e5803000 str r3, [r0]
2f7c: e3e00000 mvn r0, #0
break;
}
return return_value;
}
2f80: e49df004 pop {pc} ; (ldr pc, [sp], #4)
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
case _PC_LINK_MAX:
return_value = the_limits->link_max;
2f84: e5930038 ldr r0, [r3, #56] ; 0x38
break;
2f88: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
2f8c: e593003c ldr r0, [r3, #60] ; 0x3c
break;
2f90: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
2f94: e5930040 ldr r0, [r3, #64] ; 0x40
break;
2f98: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_NAME_MAX:
return_value = the_limits->name_max;
2f9c: e5930044 ldr r0, [r3, #68] ; 0x44
break;
2fa0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PATH_MAX:
return_value = the_limits->path_max;
2fa4: e5930048 ldr r0, [r3, #72] ; 0x48
break;
2fa8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
2fac: e593004c ldr r0, [r3, #76] ; 0x4c
break;
2fb0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
2fb4: e5930054 ldr r0, [r3, #84] ; 0x54
break;
2fb8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
2fbc: e5930058 ldr r0, [r3, #88] ; 0x58
break;
2fc0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
2fc4: e5930064 ldr r0, [r3, #100] ; 0x64
break;
2fc8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
2fcc: e5930050 ldr r0, [r3, #80] ; 0x50
break;
2fd0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
2fd4: e593005c ldr r0, [r3, #92] ; 0x5c
break;
2fd8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
iop = rtems_libio_iop(fd);
rtems_libio_check_is_open(iop);
2fdc: eb002ff7 bl efc0 <__errno>
2fe0: e3a03009 mov r3, #9
2fe4: e5803000 str r3, [r0]
2fe8: e3e00000 mvn r0, #0
2fec: e49df004 pop {pc} ; (ldr pc, [sp], #4)
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
2ff0: eb002ff2 bl efc0 <__errno>
2ff4: e3a03016 mov r3, #22
2ff8: e5803000 str r3, [r0]
2ffc: e3e00000 mvn r0, #0
3000: e49df004 pop {pc} ; (ldr pc, [sp], #4)
000042a4 <iproc>:
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
if (tty->termios.c_iflag & ISTRIP)
42a4: e5913030 ldr r3, [r1, #48] ; 0x30
42a8: e3130020 tst r3, #32
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
42ac: e92d4030 push {r4, r5, lr}
42b0: e20040ff and r4, r0, #255 ; 0xff
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
42b4: 1200407f andne r4, r0, #127 ; 0x7f
if (tty->termios.c_iflag & IUCLC)
42b8: e3130c02 tst r3, #512 ; 0x200
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
42bc: e1a05001 mov r5, r1
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
42c0: 0a000007 beq 42e4 <iproc+0x40>
c = tolower (c);
42c4: e59f21a0 ldr r2, [pc, #416] ; 446c <iproc+0x1c8>
42c8: e5922000 ldr r2, [r2]
42cc: e0822004 add r2, r2, r4
42d0: e5d22001 ldrb r2, [r2, #1]
42d4: e2022003 and r2, r2, #3
42d8: e3520001 cmp r2, #1
42dc: 02844020 addeq r4, r4, #32
42e0: e20440ff and r4, r4, #255 ; 0xff
if (c == '\r') {
42e4: e354000d cmp r4, #13
42e8: 0a000014 beq 4340 <iproc+0x9c>
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
42ec: e354000a cmp r4, #10
42f0: 0a000036 beq 43d0 <iproc+0x12c>
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
42f4: e3540000 cmp r4, #0
42f8: 1a000016 bne 4358 <iproc+0xb4>
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
42fc: e59f316c ldr r3, [pc, #364] ; 4470 <iproc+0x1cc>
4300: e5932008 ldr r2, [r3, #8]
4304: e5953020 ldr r3, [r5, #32]
4308: e2422001 sub r2, r2, #1
430c: e1530002 cmp r3, r2
4310: aa000008 bge 4338 <iproc+0x94>
if (tty->termios.c_lflag & ECHO)
4314: e595203c ldr r2, [r5, #60] ; 0x3c
4318: e3120008 tst r2, #8
431c: 1a00002e bne 43dc <iproc+0x138>
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
4320: e595101c ldr r1, [r5, #28] <== NOT EXECUTED
4324: e2832001 add r2, r3, #1 <== NOT EXECUTED
4328: e7c14003 strb r4, [r1, r3] <== NOT EXECUTED
} return 0;
432c: e3a00000 mov r0, #0 <== NOT EXECUTED
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
4330: e5852020 str r2, [r5, #32] <== NOT EXECUTED
4334: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
} return 0;
4338: e3a00000 mov r0, #0 <== NOT EXECUTED
}
433c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
4340: e3130080 tst r3, #128 ; 0x80
return 0;
4344: 13a00000 movne r0, #0
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
4348: 18bd8030 popne {r4, r5, pc}
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
434c: e3130c01 tst r3, #256 ; 0x100
4350: 03a0400d moveq r4, #13
4354: 13a0400a movne r4, #10
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
4358: e595303c ldr r3, [r5, #60] ; 0x3c
435c: e3130002 tst r3, #2
4360: 0affffe5 beq 42fc <iproc+0x58>
if (c == tty->termios.c_cc[VERASE]) {
4364: e5d52043 ldrb r2, [r5, #67] ; 0x43
4368: e1520004 cmp r2, r4
436c: 0a000039 beq 4458 <iproc+0x1b4>
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
4370: e5d52044 ldrb r2, [r5, #68] ; 0x44
4374: e1520004 cmp r2, r4
4378: 0a000025 beq 4414 <iproc+0x170>
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
437c: e5d52045 ldrb r2, [r5, #69] ; 0x45
4380: e1520004 cmp r2, r4
return 1;
4384: 03a00001 moveq r0, #1
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
4388: 08bd8030 popeq {r4, r5, pc}
return 1;
} else if (c == '\n') {
438c: e354000a cmp r4, #10
4390: 0a000024 beq 4428 <iproc+0x184>
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
4394: e5d5204c ldrb r2, [r5, #76] ; 0x4c
4398: e1520004 cmp r2, r4
439c: 0a000002 beq 43ac <iproc+0x108>
43a0: e5d52051 ldrb r2, [r5, #81] ; 0x51
43a4: e1520004 cmp r2, r4
43a8: 1affffd3 bne 42fc <iproc+0x58>
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
43ac: e3130008 tst r3, #8 <== NOT EXECUTED
43b0: 1a000013 bne 4404 <iproc+0x160> <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
43b4: e285101c add r1, r5, #28 <== NOT EXECUTED
43b8: e891000a ldm r1, {r1, r3} <== NOT EXECUTED
43bc: e2832001 add r2, r3, #1 <== NOT EXECUTED
43c0: e7c14003 strb r4, [r1, r3] <== NOT EXECUTED
return 1;
43c4: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
43c8: e5852020 str r2, [r5, #32] <== NOT EXECUTED
return 1;
43cc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
43d0: e3130040 tst r3, #64 ; 0x40
43d4: 13a0400d movne r4, #13
43d8: eaffffde b 4358 <iproc+0xb4>
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
43dc: e1a00004 mov r0, r4
43e0: e1a01005 mov r1, r5
43e4: ebffff03 bl 3ff8 <echo>
43e8: e285101c add r1, r5, #28
43ec: e891000a ldm r1, {r1, r3}
tty->cbuf[tty->ccount++] = c;
43f0: e2832001 add r2, r3, #1
43f4: e7c14003 strb r4, [r1, r3]
} return 0;
43f8: e3a00000 mov r0, #0
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
43fc: e5852020 str r2, [r5, #32]
4400: e8bd8030 pop {r4, r5, pc}
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
4404: e1a00004 mov r0, r4 <== NOT EXECUTED
4408: e1a01005 mov r1, r5 <== NOT EXECUTED
440c: ebfffef9 bl 3ff8 <echo> <== NOT EXECUTED
4410: eaffffe7 b 43b4 <iproc+0x110> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
4414: e1a00005 mov r0, r5
4418: e3a01001 mov r1, #1
441c: ebffff1a bl 408c <erase>
return 0;
4420: e3a00000 mov r0, #0
4424: e8bd8030 pop {r4, r5, pc}
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
4428: e3130048 tst r3, #72 ; 0x48
echo (c, tty);
442c: 11a00004 movne r0, r4
4430: 11a01005 movne r1, r5
4434: 1bfffeef blne 3ff8 <echo>
tty->cbuf[tty->ccount++] = c;
4438: e285101c add r1, r5, #28
443c: e891000a ldm r1, {r1, r3}
4440: e3a0000a mov r0, #10
4444: e2832001 add r2, r3, #1
4448: e7c10003 strb r0, [r1, r3]
return 1;
444c: e3a00001 mov r0, #1
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
4450: e5852020 str r2, [r5, #32]
return 1;
4454: e8bd8030 pop {r4, r5, pc}
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
4458: e1a00005 mov r0, r5
445c: e3a01000 mov r1, #0
4460: ebffff09 bl 408c <erase>
return 0;
4464: e3a00000 mov r0, #0
4468: e8bd8030 pop {r4, r5, pc}
00022cfc <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
22cfc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
22d00: e24dd00c sub sp, sp, #12
22d04: e1a04000 mov r4, r0
22d08: e1a05001 mov r5, r1
22d0c: e1a08002 mov r8, r2
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
22d10: ebffff40 bl 22a18 <getpid> 22d14: e1500004 cmp r0, r4
22d18: 1a000096 bne 22f78 <killinfo+0x27c>
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
22d1c: e3550000 cmp r5, #0
22d20: 0a000099 beq 22f8c <killinfo+0x290>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
22d24: e2454001 sub r4, r5, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
22d28: e354001f cmp r4, #31
22d2c: 8a000096 bhi 22f8c <killinfo+0x290>
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 )
22d30: e59f6280 ldr r6, [pc, #640] ; 22fb8 <killinfo+0x2bc> 22d34: e1a07085 lsl r7, r5, #1 22d38: e0873005 add r3, r7, r5 22d3c: e0863103 add r3, r6, r3, lsl #2 22d40: e5933008 ldr r3, [r3, #8] 22d44: e3530001 cmp r3, #1
return 0;
22d48: 03a00000 moveq r0, #0
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 )
22d4c: 0a000039 beq 22e38 <killinfo+0x13c>
/*
* 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 ) )
22d50: e3550008 cmp r5, #8 22d54: 13550004 cmpne r5, #4
22d58: 0a000038 beq 22e40 <killinfo+0x144>
22d5c: e355000b cmp r5, #11
22d60: 0a000036 beq 22e40 <killinfo+0x144>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
22d64: e3a03001 mov r3, #1
/* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER;
22d68: e58d3004 str r3, [sp, #4]
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
22d6c: e58d5000 str r5, [sp]
siginfo->si_code = SI_USER;
if ( !value ) {
22d70: e3580000 cmp r8, #0 22d74: e1a04413 lsl r4, r3, r4
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
22d78: 15983000 ldrne r3, [r8] 22d7c: 158d3008 strne r3, [sp, #8] 22d80: e59f3234 ldr r3, [pc, #564] ; 22fbc <killinfo+0x2c0> 22d84: e5932000 ldr r2, [r3] 22d88: e2822001 add r2, r2, #1
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
22d8c: 058d8008 streq r8, [sp, #8] 22d90: e5832000 str r2, [r3]
/*
* 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;
22d94: e59f3224 ldr r3, [pc, #548] ; 22fc0 <killinfo+0x2c4> 22d98: e5930004 ldr r0, [r3, #4]
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
22d9c: e59030fc ldr r3, [r0, #252] ; 0xfc 22da0: e59330d0 ldr r3, [r3, #208] ; 0xd0 22da4: e1d43003 bics r3, r4, r3
22da8: 1a000014 bne 22e00 <killinfo+0x104>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
22dac: e59f1210 ldr r1, [pc, #528] ; 22fc4 <killinfo+0x2c8> 22db0: e4913004 ldr r3, [r1], #4
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
22db4: e1530001 cmp r3, r1
22db8: 0a000031 beq 22e84 <killinfo+0x188>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
22dbc: e5932030 ldr r2, [r3, #48] ; 0x30 22dc0: e1140002 tst r4, r2
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
22dc4: e1a00003 mov r0, r3
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
22dc8: e59320fc ldr r2, [r3, #252] ; 0xfc
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
22dcc: 0a000008 beq 22df4 <killinfo+0xf8>
22dd0: ea00000a b 22e00 <killinfo+0x104>
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
22dd4: e5933000 ldr r3, [r3]
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
22dd8: e1530001 cmp r3, r1
22ddc: 0a000028 beq 22e84 <killinfo+0x188>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
22de0: e5932030 ldr r2, [r3, #48] ; 0x30 <== NOT EXECUTED 22de4: e1140002 tst r4, r2 <== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
22de8: e1a00003 mov r0, r3 <== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
22dec: e59320fc ldr r2, [r3, #252] ; 0xfc <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
22df0: 1a000002 bne 22e00 <killinfo+0x104> <== NOT EXECUTED
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
22df4: e59220d0 ldr r2, [r2, #208] ; 0xd0 22df8: e1d42002 bics r2, r4, r2
22dfc: 0afffff4 beq 22dd4 <killinfo+0xd8>
/*
* 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 ) ) {
22e00: e1a01005 mov r1, r5 22e04: e1a0200d mov r2, sp 22e08: eb00007d bl 23004 <_POSIX_signals_Unblock_thread> 22e0c: e3500000 cmp r0, #0
22e10: 1a000006 bne 22e30 <killinfo+0x134>
* 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 );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
22e14: e0875005 add r5, r7, r5
/*
* 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 );
22e18: e1a00004 mov r0, r4
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
22e1c: e1a05105 lsl r5, r5, #2
/*
* 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 );
22e20: eb00006d bl 22fdc <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
22e24: e7963005 ldr r3, [r6, r5] 22e28: e3530002 cmp r3, #2
22e2c: 0a000007 beq 22e50 <killinfo+0x154>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
22e30: ebffa9ec bl d5e8 <_Thread_Enable_dispatch>
return 0;
22e34: e3a00000 mov r0, #0
}
22e38: e28dd00c add sp, sp, #12
22e3c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* 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 ) )
return pthread_kill( pthread_self(), sig );
22e40: eb0000f4 bl 23218 <pthread_self> 22e44: e1a01005 mov r1, r5 22e48: eb0000bc bl 23140 <pthread_kill> 22e4c: eafffff9 b 22e38 <killinfo+0x13c>
_POSIX_signals_Set_process_signals( mask );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
22e50: e59f0170 ldr r0, [pc, #368] ; 22fc8 <killinfo+0x2cc> 22e54: ebffa2eb bl ba08 <_Chain_Get>
if ( !psiginfo ) {
22e58: e250c000 subs ip, r0, #0
22e5c: 0a00004f beq 22fa0 <killinfo+0x2a4>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
22e60: e1a0300d mov r3, sp
22e64: e8930007 ldm r3, {r0, r1, r2}
22e68: e28c3008 add r3, ip, #8
22e6c: e8830007 stm r3, {r0, r1, r2}
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
22e70: e59f0154 ldr r0, [pc, #340] ; 22fcc <killinfo+0x2d0> 22e74: e1a0100c mov r1, ip 22e78: e0800005 add r0, r0, r5 22e7c: ebffa2ce bl b9bc <_Chain_Append> 22e80: eaffffea b 22e30 <killinfo+0x134>
* NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
22e84: e59f3144 ldr r3, [pc, #324] ; 22fd0 <killinfo+0x2d4> 22e88: e5d3e000 ldrb lr, [r3] 22e8c: e59fa140 ldr sl, [pc, #320] ; 22fd4 <killinfo+0x2d8> 22e90: e28ee001 add lr, lr, #1
* * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL;
22e94: e3a08000 mov r8, #0
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
22e98: e5ba3004 ldr r3, [sl, #4]! 22e9c: e3530000 cmp r3, #0
22ea0: 0a000022 beq 22f30 <killinfo+0x234>
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
22ea4: e5933004 ldr r3, [r3, #4]
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
22ea8: e1d3c1b0 ldrh ip, [r3, #16]
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
22eac: e35c0000 cmp ip, #0
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
22eb0: e593101c ldr r1, [r3, #28]
for ( index = 1 ; index <= maximum ; index++ ) {
22eb4: 0a00001d beq 22f30 <killinfo+0x234>
22eb8: e3a02001 mov r2, #1
the_thread = (Thread_Control *) object_table[ index ];
22ebc: e5b13004 ldr r3, [r1, #4]!
if ( !the_thread )
22ec0: e3530000 cmp r3, #0
22ec4: 0a000016 beq 22f24 <killinfo+0x228>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
22ec8: e5930014 ldr r0, [r3, #20] 22ecc: e150000e cmp r0, lr
22ed0: 8a000013 bhi 22f24 <killinfo+0x228>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
22ed4: e59390fc ldr r9, [r3, #252] ; 0xfc 22ed8: e59990d0 ldr r9, [r9, #208] ; 0xd0 22edc: e1d49009 bics r9, r4, r9
22ee0: 0a00000f beq 22f24 <killinfo+0x228>
*
* 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 ) {
22ee4: e150000e cmp r0, lr
22ee8: 3a00001c bcc 22f60 <killinfo+0x264>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
22eec: e3580000 cmp r8, #0
22ef0: 0a00000b beq 22f24 <killinfo+0x228>
22ef4: e5989010 ldr r9, [r8, #16] 22ef8: e3590000 cmp r9, #0
22efc: 0a000008 beq 22f24 <killinfo+0x228>
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
22f00: e593b010 ldr fp, [r3, #16] 22f04: e35b0000 cmp fp, #0
22f08: 0a000014 beq 22f60 <killinfo+0x264>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
22f0c: e3190201 tst r9, #268435456 ; 0x10000000
22f10: 1a000003 bne 22f24 <killinfo+0x228>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
22f14: e20bb201 and fp, fp, #268435456 ; 0x10000000
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
22f18: e35b0000 cmp fp, #0 22f1c: 11a0e000 movne lr, r0 22f20: 11a08003 movne r8, r3
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
22f24: e2822001 add r2, r2, #1 22f28: e15c0002 cmp ip, r2
22f2c: 2affffe2 bcs 22ebc <killinfo+0x1c0>
* + 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++) {
22f30: e59f30a0 ldr r3, [pc, #160] ; 22fd8 <killinfo+0x2dc> 22f34: e15a0003 cmp sl, r3
22f38: 1affffd6 bne 22e98 <killinfo+0x19c>
}
}
}
}
if ( interested ) {
22f3c: e3580000 cmp r8, #0
22f40: 0affffb3 beq 22e14 <killinfo+0x118>
22f44: e1a00008 mov r0, r8
/*
* 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 ) ) {
22f48: e1a01005 mov r1, r5 22f4c: e1a0200d mov r2, sp 22f50: eb00002b bl 23004 <_POSIX_signals_Unblock_thread> 22f54: e3500000 cmp r0, #0
22f58: 0affffad beq 22e14 <killinfo+0x118>
22f5c: eaffffb3 b 22e30 <killinfo+0x134> <== NOT EXECUTED
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
22f60: e2822001 add r2, r2, #1 22f64: e15c0002 cmp ip, r2
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
22f68: e1a0e000 mov lr, r0 22f6c: e1a08003 mov r8, r3
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
22f70: 2affffd1 bcs 22ebc <killinfo+0x1c0>
22f74: eaffffed b 22f30 <killinfo+0x234>
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
rtems_set_errno_and_return_minus_one( ESRCH );
22f78: ebffc1bd bl 13674 <__errno> 22f7c: e3a03003 mov r3, #3 22f80: e5803000 str r3, [r0] 22f84: e3e00000 mvn r0, #0 22f88: eaffffaa b 22e38 <killinfo+0x13c>
*/
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
22f8c: ebffc1b8 bl 13674 <__errno> 22f90: e3a03016 mov r3, #22 22f94: e5803000 str r3, [r0] 22f98: e3e00000 mvn r0, #0 22f9c: eaffffa5 b 22e38 <killinfo+0x13c>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
_Thread_Enable_dispatch();
22fa0: ebffa990 bl d5e8 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
22fa4: ebffc1b2 bl 13674 <__errno> 22fa8: e3a0300b mov r3, #11 22fac: e5803000 str r3, [r0] 22fb0: e3e00000 mvn r0, #0 22fb4: eaffff9f b 22e38 <killinfo+0x13c>
00002654 <malloc>:
size_t size
)
{
void *return_this;
MSBUMP(malloc_calls, 1);
2654: e59f30d4 ldr r3, [pc, #212] ; 2730 <malloc+0xdc>
2658: e5932004 ldr r2, [r3, #4]
265c: e2822001 add r2, r2, #1
#include "malloc_p.h"
void *malloc(
size_t size
)
{
2660: e92d4030 push {r4, r5, lr}
2664: e1a04000 mov r4, r0
void *return_this;
MSBUMP(malloc_calls, 1);
2668: e5832004 str r2, [r3, #4]
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
266c: ebffffb0 bl 2534 <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
2670: e3540000 cmp r4, #0
return (void *) 0;
2674: 01a05004 moveq r5, r4
malloc_deferred_frees_process();
/*
* Validate the parameters
*/
if ( !size )
2678: 0a000018 beq 26e0 <malloc+0x8c>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
267c: e59f30b0 ldr r3, [pc, #176] ; 2734 <malloc+0xe0>
2680: e5933000 ldr r3, [r3]
2684: e3530003 cmp r3, #3
2688: 0a000024 beq 2720 <malloc+0xcc>
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
268c: e59f30a4 ldr r3, [pc, #164] ; 2738 <malloc+0xe4>
2690: e3a02000 mov r2, #0
2694: e5930000 ldr r0, [r3]
2698: e1a01004 mov r1, r4
269c: e1a03002 mov r3, r2
26a0: eb0013a0 bl 7528 <_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 ) {
26a4: e2505000 subs r5, r0, #0
26a8: 0a00000e beq 26e8 <malloc+0x94>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
26ac: e59f3088 ldr r3, [pc, #136] ; 273c <malloc+0xe8>
26b0: e5933000 ldr r3, [r3]
26b4: e3530000 cmp r3, #0
(*rtems_malloc_dirty_helper)( return_this, size );
26b8: 11a00005 movne r0, r5
26bc: 11a01004 movne r1, r4
26c0: 11a0e00f movne lr, pc
26c4: 112fff13 bxne r3
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
26c8: e59f3070 ldr r3, [pc, #112] ; 2740 <malloc+0xec>
26cc: e5933000 ldr r3, [r3]
26d0: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
26d4: 11a00005 movne r0, r5
26d8: 11a0e00f movne lr, pc
26dc: 1593f004 ldrne pc, [r3, #4]
return return_this;
}
26e0: e1a00005 mov r0, r5
26e4: e8bd8030 pop {r4, r5, pc}
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
26e8: e59f3054 ldr r3, [pc, #84] ; 2744 <malloc+0xf0>
26ec: e5933000 ldr r3, [r3]
26f0: e3530000 cmp r3, #0
26f4: 0a000005 beq 2710 <malloc+0xbc>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
26f8: e1a00004 mov r0, r4
26fc: e1a0e00f mov lr, pc
2700: e593f004 ldr pc, [r3, #4]
if ( !return_this ) {
2704: e3500000 cmp r0, #0
2708: 11a05000 movne r5, r0
270c: 1affffe6 bne 26ac <malloc+0x58>
errno = ENOMEM;
2710: eb002e03 bl df24 <__errno>
2714: e3a0300c mov r3, #12
2718: e5803000 str r3, [r0]
return (void *) 0;
271c: eaffffef b 26e0 <malloc+0x8c>
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
2720: ebffff6f bl 24e4 <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()) &&
2724: e2505000 subs r5, r0, #0
2728: 1affffd7 bne 268c <malloc+0x38>
272c: eaffffeb b 26e0 <malloc+0x8c> <== NOT EXECUTED
0000ceec <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
ceec: e92d4030 push {r4, r5, lr}
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
cef0: e5905018 ldr r5, [r0, #24]
if (the_jnode->type == IMFS_LINEAR_FILE) {
cef4: e595304c ldr r3, [r5, #76] ; 0x4c
cef8: e3530006 cmp r3, #6
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
cefc: e1a04000 mov r4, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
cf00: 0a00000d beq cf3c <memfile_lseek+0x50>
if (iop->offset > the_jnode->info.linearfile.size)
iop->offset = the_jnode->info.linearfile.size;
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
cf04: e1a00005 mov r0, r5
cf08: e284200c add r2, r4, #12
cf0c: e8920006 ldm r2, {r1, r2}
cf10: ebfffee7 bl cab4 <IMFS_memfile_extend>
cf14: e3500000 cmp r0, #0
cf18: 1a000018 bne cf80 <memfile_lseek+0x94>
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
cf1c: e2853050 add r3, r5, #80 ; 0x50
cf20: e893000c ldm r3, {r2, r3}
cf24: e984000c stmib r4, {r2, r3}
cf28: e284300c add r3, r4, #12
cf2c: e893000c ldm r3, {r2, r3}
} return iop->offset; }
cf30: e1a00002 mov r0, r2
cf34: e1a01003 mov r1, r3
cf38: e8bd8030 pop {r4, r5, pc}
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
if (iop->offset > the_jnode->info.linearfile.size)
cf3c: e280300c add r3, r0, #12
cf40: e893000c ldm r3, {r2, r3}
cf44: e5951054 ldr r1, [r5, #84] ; 0x54
cf48: e1530001 cmp r3, r1
cf4c: e5950050 ldr r0, [r5, #80] ; 0x50
cf50: ca000002 bgt cf60 <memfile_lseek+0x74>
cf54: 1afffff5 bne cf30 <memfile_lseek+0x44>
cf58: e1520000 cmp r2, r0
cf5c: 9afffff3 bls cf30 <memfile_lseek+0x44>
iop->offset = the_jnode->info.linearfile.size;
cf60: e1a02000 mov r2, r0 <== NOT EXECUTED
cf64: e1a03001 mov r3, r1 <== NOT EXECUTED
cf68: e1a05000 mov r5, r0 <== NOT EXECUTED
cf6c: e584000c str r0, [r4, #12] <== NOT EXECUTED
cf70: e5841010 str r1, [r4, #16] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
}
return iop->offset;
}
cf74: e1a00002 mov r0, r2 <== NOT EXECUTED
cf78: e1a01003 mov r1, r3 <== NOT EXECUTED
cf7c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (iop->offset > the_jnode->info.linearfile.size)
iop->offset = the_jnode->info.linearfile.size;
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
rtems_set_errno_and_return_minus_one( ENOSPC );
cf80: eb0003e7 bl df24 <__errno>
cf84: e3a0301c mov r3, #28
cf88: e5803000 str r3, [r0]
cf8c: e3e02000 mvn r2, #0
cf90: e3e03000 mvn r3, #0
cf94: eaffffe5 b cf30 <memfile_lseek+0x44>
0000cdd8 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
cdd8: e92d4070 push {r4, r5, r6, lr}
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
cddc: e5903014 ldr r3, [r0, #20]
cde0: e3130f81 tst r3, #516 ; 0x204
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
cde4: e24dd004 sub sp, sp, #4
cde8: e1a04000 mov r4, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
cdec: e5905018 ldr r5, [r0, #24]
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
cdf0: 0a000002 beq ce00 <memfile_open+0x28>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
cdf4: e595204c ldr r2, [r5, #76] ; 0x4c
cdf8: e3520006 cmp r2, #6
cdfc: 0a00000a beq ce2c <memfile_open+0x54>
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))
ce00: e2850050 add r0, r5, #80 ; 0x50
ce04: e8900005 ldm r0, {r0, r2}
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
ce08: e3130c02 tst r3, #512 ; 0x200
iop->offset = the_jnode->info.file.size;
ce0c: 1584000c strne r0, [r4, #12]
ce10: 15842010 strne r2, [r4, #16]
ce14: 15952054 ldrne r2, [r5, #84] ; 0x54
ce18: 15950050 ldrne r0, [r5, #80] ; 0x50
iop->size = the_jnode->info.file.size;
ce1c: e9840005 stmib r4, {r0, r2}
return 0;
ce20: e3a00000 mov r0, #0
}
ce24: e28dd004 add sp, sp, #4
ce28: e8bd8070 pop {r4, r5, r6, pc}
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
ce2c: e595c050 ldr ip, [r5, #80] ; 0x50 <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
ce30: e3a00000 mov r0, #0 <== NOT EXECUTED
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
ce34: e3a01000 mov r1, #0 <== NOT EXECUTED
ce38: e3a02000 mov r2, #0 <== NOT EXECUTED
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
ce3c: e3a06005 mov r6, #5 <== 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)
ce40: e15c0000 cmp ip, r0 <== NOT EXECUTED
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
ce44: e5953058 ldr r3, [r5, #88] ; 0x58 <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
ce48: e585604c str r6, [r5, #76] ; 0x4c <== NOT EXECUTED
the_jnode->info.file.size = 0;
ce4c: e5851050 str r1, [r5, #80] ; 0x50 <== NOT EXECUTED
ce50: e5852054 str r2, [r5, #84] ; 0x54 <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
ce54: e5850058 str r0, [r5, #88] ; 0x58 <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
ce58: e585005c str r0, [r5, #92] ; 0x5c <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
ce5c: e5850060 str r0, [r5, #96] ; 0x60 <== NOT EXECUTED
if ((count != 0)
ce60: 05943014 ldreq r3, [r4, #20] <== NOT EXECUTED
ce64: 01a00001 moveq r0, r1 <== NOT EXECUTED
ce68: 0affffe6 beq ce08 <memfile_open+0x30> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
ce6c: e1a00005 mov r0, r5 <== NOT EXECUTED
ce70: e58dc000 str ip, [sp] <== NOT EXECUTED
ce74: ebffff5b bl cbe8 <IMFS_memfile_write> <== NOT EXECUTED
ce78: e3700001 cmn r0, #1 <== NOT EXECUTED
ce7c: 0affffe8 beq ce24 <memfile_open+0x4c> <== NOT EXECUTED
ce80: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
ce84: eaffffdd b ce00 <memfile_open+0x28> <== NOT EXECUTED
000028b4 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
28b4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
28b8: e3530001 cmp r3, #1
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
28bc: e24dd030 sub sp, sp, #48 ; 0x30
28c0: e58d3008 str r3, [sp, #8]
28c4: e1a07000 mov r7, r0
28c8: e1a06001 mov r6, r1
28cc: e1a09002 mov r9, r2
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
28d0: 8a00009a bhi 2b40 <mount+0x28c>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
28d4: e1a00002 mov r0, r2
28d8: eb00203e bl a9d8 <rtems_filesystem_get_mount_handler>
if ( !mount_h )
28dc: e3500000 cmp r0, #0
28e0: e58d0014 str r0, [sp, #20]
28e4: 0a000095 beq 2b40 <mount+0x28c>
{
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;
28e8: e2565000 subs r5, r6, #0
28ec: 13a05001 movne r5, #1
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
28f0: e3550000 cmp r5, #0
28f4: 0a00008a beq 2b24 <mount+0x270>
* 4) The mount point exists with the proper permissions to allow mounting
* 5) The selected mount point already has a file system mounted to it
*
*/
int mount(
28f8: e1a00006 mov r0, r6
28fc: eb003172 bl eecc <strlen>
2900: e2803001 add r3, r0, #1
2904: e58d0010 str r0, [sp, #16]
2908: e58d300c str r3, [sp, #12]
290c: e58d6018 str r6, [sp, #24]
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
2910: e1a00009 mov r0, r9
2914: eb00316c bl eecc <strlen>
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2918: e3570000 cmp r7, #0
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
291c: e280b001 add fp, r0, #1
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2920: 01a08007 moveq r8, r7
2924: 0a000002 beq 2934 <mount+0x80>
2928: e1a00007 mov r0, r7
292c: eb003166 bl eecc <strlen>
2930: e2808001 add r8, r0, #1
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
2934: e59d300c ldr r3, [sp, #12]
2938: e2831074 add r1, r3, #116 ; 0x74
293c: e081100b add r1, r1, fp
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
2940: e3a00001 mov r0, #1
2944: e0811008 add r1, r1, r8
2948: ebfffdfa bl 2138 <calloc>
if ( mt_entry != NULL ) {
294c: e2504000 subs r4, r0, #0
2950: 0a00006e beq 2b10 <mount+0x25c>
char *str = (char *) mt_entry + sizeof( *mt_entry );
2954: e284a074 add sl, r4, #116 ; 0x74
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
2958: e08a300b add r3, sl, fp
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
memcpy( str, filesystemtype, filesystemtype_size );
295c: e1a01009 mov r1, r9
2960: e1a0200b mov r2, fp
2964: e1a0000a mov r0, sl
2968: e58d3004 str r3, [sp, #4]
296c: eb002f9a bl e7dc <memcpy>
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
2970: e59d3004 ldr r3, [sp, #4]
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
2974: e1a01007 mov r1, r7
2978: e1a02008 mov r2, r8
297c: e1a00003 mov r0, r3
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
2980: e584a06c str sl, [r4, #108] ; 0x6c
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
2984: e0839008 add r9, r3, r8
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
2988: eb002f93 bl e7dc <memcpy>
mt_entry->dev = str;
298c: e59d3004 ldr r3, [sp, #4]
str += source_size;
memcpy( str, target, target_size );
2990: e59d1018 ldr r1, [sp, #24]
2994: e59d200c ldr r2, [sp, #12]
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
2998: e5843070 str r3, [r4, #112] ; 0x70
str += source_size;
memcpy( str, target, target_size );
299c: e1a00009 mov r0, r9
29a0: eb002f8d bl e7dc <memcpy>
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
mt_entry->options = options;
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
29a4: e59fe20c ldr lr, [pc, #524] ; 2bb8 <mount+0x304>
29a8: e8be000f ldm lr!, {r0, r1, r2, r3}
29ac: e284c038 add ip, r4, #56 ; 0x38
29b0: e8ac000f stmia ip!, {r0, r1, r2, r3}
29b4: e8be000f ldm lr!, {r0, r1, r2, r3}
29b8: e8ac000f stmia ip!, {r0, r1, r2, r3}
29bc: e89e000f ldm lr, {r0, r1, r2, r3}
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
mt_entry->options = options;
29c0: e59de008 ldr lr, [sp, #8]
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
29c4: e3550000 cmp r5, #0
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
memcpy( str, target, target_size );
mt_entry->target = str;
29c8: e5849068 str r9, [r4, #104] ; 0x68
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
29cc: e584402c str r4, [r4, #44] ; 0x2c
mt_entry->options = options;
29d0: e584e030 str lr, [r4, #48] ; 0x30
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
29d4: e88c000f stm ip, {r0, r1, r2, r3}
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
29d8: 1a000024 bne 2a70 <mount+0x1bc>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
29dc: e59f31d8 ldr r3, [pc, #472] ; 2bbc <mount+0x308>
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
29e0: e5932000 ldr r2, [r3]
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
29e4: e2833004 add r3, r3, #4
29e8: e1520003 cmp r2, r3
)
{
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;
29ec: 01a07005 moveq r7, r5
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
29f0: 1a000057 bne 2b54 <mount+0x2a0>
* 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 ) ) {
29f4: e1a00004 mov r0, r4
29f8: e59d1054 ldr r1, [sp, #84] ; 0x54
29fc: e59d3014 ldr r3, [sp, #20]
2a00: e1a0e00f mov lr, pc
2a04: e12fff13 bx r3
2a08: e2506000 subs r6, r0, #0
2a0c: 1a000057 bne 2b70 <mount+0x2bc>
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 );
2a10: e59f71a8 ldr r7, [pc, #424] ; 2bc0 <mount+0x30c>
2a14: e1a02006 mov r2, r6
2a18: e1a01006 mov r1, r6
2a1c: e5970000 ldr r0, [r7]
2a20: eb000bf5 bl 59fc <rtems_semaphore_obtain>
2a24: e59f0190 ldr r0, [pc, #400] ; 2bbc <mount+0x308>
2a28: e1a01004 mov r1, r4
2a2c: eb000e66 bl 63cc <_Chain_Append>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
2a30: e5970000 ldr r0, [r7]
2a34: eb000c39 bl 5b20 <rtems_semaphore_release>
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
2a38: e3550000 cmp r5, #0
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
2a3c: 11a00006 movne r0, r6
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
2a40: 1a000008 bne 2a68 <mount+0x1b4>
rtems_filesystem_root = mt_entry->mt_fs_root;
2a44: e59f3178 ldr r3, [pc, #376] ; 2bc4 <mount+0x310>
2a48: e284401c add r4, r4, #28
2a4c: e593c000 ldr ip, [r3]
2a50: e8b4000f ldm r4!, {r0, r1, r2, r3}
2a54: e28cc018 add ip, ip, #24
2a58: e8ac000f stmia ip!, {r0, r1, r2, r3}
2a5c: e5943000 ldr r3, [r4]
2a60: e58c3000 str r3, [ip]
return 0;
2a64: e1a00005 mov r0, r5
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
}
2a68: e28dd030 add sp, sp, #48 ; 0x30
2a6c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
2a70: e28d701c add r7, sp, #28
2a74: e3a0c001 mov ip, #1
2a78: e1a00006 mov r0, r6
2a7c: e59d1010 ldr r1, [sp, #16]
2a80: e3a02007 mov r2, #7
2a84: e1a03007 mov r3, r7
2a88: e58dc000 str ip, [sp]
2a8c: ebfffdd7 bl 21f0 <rtems_filesystem_evaluate_path>
2a90: e3700001 cmn r0, #1
2a94: 0a000031 beq 2b60 <mount+0x2ac>
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
2a98: e1a00007 mov r0, r7
2a9c: e59d3028 ldr r3, [sp, #40] ; 0x28
2aa0: e1a0e00f mov lr, pc
2aa4: e593f010 ldr pc, [r3, #16]
2aa8: e3500001 cmp r0, #1
2aac: 1a000039 bne 2b98 <mount+0x2e4>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
2ab0: e59f0110 ldr r0, [pc, #272] ; 2bc8 <mount+0x314>
2ab4: e59d101c ldr r1, [sp, #28]
2ab8: ebffff5f bl 283c <rtems_filesystem_mount_iterate>
2abc: e3500000 cmp r0, #0
2ac0: 1a000038 bne 2ba8 <mount+0x2f4>
* 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;
2ac4: e59d201c ldr r2, [sp, #28]
2ac8: e5842008 str r2, [r4, #8]
mt_entry->mt_point_node.handlers = loc.handlers;
2acc: e28d2024 add r2, sp, #36 ; 0x24
2ad0: e892000c ldm r2, {r2, r3}
2ad4: e5842010 str r2, [r4, #16]
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
2ad8: e59d202c ldr r2, [sp, #44] ; 0x2c
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
2adc: e5843014 str r3, [r4, #20]
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
2ae0: e5842018 str r2, [r4, #24]
/*
* 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 ) ) {
2ae4: e1a00004 mov r0, r4
2ae8: e1a0e00f mov lr, pc
2aec: e593f020 ldr pc, [r3, #32]
2af0: e3500000 cmp r0, #0
2af4: 0affffbe beq 29f4 <mount+0x140>
return 0;
cleanup_and_bail:
free( mt_entry );
2af8: e1a00004 mov r0, r4
2afc: ebfffdfa bl 22ec <free>
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
2b00: e1a00007 mov r0, r7
2b04: ebfffdf3 bl 22d8 <rtems_filesystem_freenode>
return -1;
2b08: e3e00000 mvn r0, #0
2b0c: eaffffd5 b 2a68 <mount+0x1b4>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
2b10: eb002d03 bl df24 <__errno> <== NOT EXECUTED
2b14: e3a0300c mov r3, #12 <== NOT EXECUTED
2b18: e5803000 str r3, [r0] <== NOT EXECUTED
2b1c: e3e00000 mvn r0, #0 <== NOT EXECUTED
2b20: eaffffd0 b 2a68 <mount+0x1b4> <== NOT EXECUTED
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
2b24: e59fe0a0 ldr lr, [pc, #160] ; 2bcc <mount+0x318>
2b28: e3a03002 mov r3, #2
2b2c: e58de018 str lr, [sp, #24]
2b30: e3a0e001 mov lr, #1
2b34: e58d300c str r3, [sp, #12]
2b38: e58de010 str lr, [sp, #16]
2b3c: eaffff73 b 2910 <mount+0x5c>
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
if ( !mount_h )
rtems_set_errno_and_return_minus_one( EINVAL );
2b40: eb002cf7 bl df24 <__errno>
2b44: e3a03016 mov r3, #22
2b48: e5803000 str r3, [r0]
2b4c: e3e00000 mvn r0, #0
2b50: eaffffc4 b 2a68 <mount+0x1b4>
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
errno = EINVAL;
2b54: eb002cf2 bl df24 <__errno>
2b58: e3a03016 mov r3, #22
2b5c: e5803000 str r3, [r0]
return 0;
cleanup_and_bail:
free( mt_entry );
2b60: e1a00004 mov r0, r4
2b64: ebfffde0 bl 22ec <free>
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
2b68: e3e00000 mvn r0, #0
2b6c: eaffffbd b 2a68 <mount+0x1b4>
if ( (*mount_h)( mt_entry, data ) ) {
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
2b70: e59d3028 ldr r3, [sp, #40] ; 0x28
2b74: e1a00004 mov r0, r4
2b78: e1a0e00f mov lr, pc
2b7c: e593f028 ldr pc, [r3, #40] ; 0x28
return 0;
cleanup_and_bail:
free( mt_entry );
2b80: e1a00004 mov r0, r4
2b84: ebfffdd8 bl 22ec <free>
if ( loc_to_free )
2b88: e3570000 cmp r7, #0
rtems_filesystem_freenode( loc_to_free );
return -1;
2b8c: 03e00000 mvneq r0, #0
cleanup_and_bail:
free( mt_entry );
if ( loc_to_free )
2b90: 0affffb4 beq 2a68 <mount+0x1b4>
2b94: eaffffd9 b 2b00 <mount+0x24c>
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
errno = ENOTDIR;
2b98: eb002ce1 bl df24 <__errno>
2b9c: e3a03014 mov r3, #20
2ba0: e5803000 str r3, [r0]
goto cleanup_and_bail;
2ba4: eaffffd3 b 2af8 <mount+0x244>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
errno = EBUSY;
2ba8: eb002cdd bl df24 <__errno>
2bac: e3a03010 mov r3, #16
2bb0: e5803000 str r3, [r0]
goto cleanup_and_bail;
2bb4: eaffffcf b 2af8 <mount+0x244>
00002bd4 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
2bd4: e92d4010 push {r4, lr}
2bd8: e1a04000 mov r4, r0
switch ( fileno(fp) ) {
2bdc: eb002dd3 bl e330 <fileno>
2be0: e3500002 cmp r0, #2
2be4: 9a000003 bls 2bf8 <newlib_free_buffers+0x24>
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
2be8: e1a00004 mov r0, r4 <== NOT EXECUTED
2bec: eb002d1a bl e05c <fclose> <== NOT EXECUTED
} return 0; }
2bf0: e3a00000 mov r0, #0
2bf4: e8bd8010 pop {r4, pc}
{
switch ( fileno(fp) ) {
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
2bf8: e1d430bc ldrh r3, [r4, #12]
2bfc: e3130080 tst r3, #128 ; 0x80
2c00: 0afffffa beq 2bf0 <newlib_free_buffers+0x1c>
free( fp->_bf._base );
2c04: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
2c08: ebfffdb7 bl 22ec <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
2c0c: e1d420bc ldrh r2, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
2c10: e3a03000 mov r3, #0 <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
2c14: e3c22080 bic r2, r2, #128 ; 0x80 <== NOT EXECUTED
2c18: e1c420bc strh r2, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
2c1c: e5843000 str r3, [r4] <== NOT EXECUTED
2c20: e5843010 str r3, [r4, #16] <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
2c24: e3a00000 mov r0, #0 <== NOT EXECUTED
2c28: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00003e88 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
3e88: e92d4010 push {r4, lr}
int i;
if (tty->termios.c_oflag & OPOST) {
3e8c: e5913034 ldr r3, [r1, #52] ; 0x34
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
3e90: e24dd004 sub sp, sp, #4
int i;
if (tty->termios.c_oflag & OPOST) {
3e94: e3130001 tst r3, #1
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
3e98: e1a04001 mov r4, r1
3e9c: e5cd0000 strb r0, [sp]
int i;
if (tty->termios.c_oflag & OPOST) {
3ea0: 0a000014 beq 3ef8 <oproc+0x70>
switch (c) {
3ea4: e5dd1000 ldrb r1, [sp]
3ea8: e2412008 sub r2, r1, #8
3eac: e3520005 cmp r2, #5
3eb0: 979ff102 ldrls pc, [pc, r2, lsl #2]
3eb4: ea000005 b 3ed0 <oproc+0x48>
3eb8: 00003f80 .word 0x00003f80
3ebc: 00003f48 .word 0x00003f48
3ec0: 00003f94 .word 0x00003f94
3ec4: 00003ed0 .word 0x00003ed0
3ec8: 00003ed0 .word 0x00003ed0
3ecc: 00003f10 .word 0x00003f10
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
3ed0: e3130002 tst r3, #2
3ed4: 1a00003a bne 3fc4 <oproc+0x13c>
3ed8: e59f310c ldr r3, [pc, #268] ; 3fec <oproc+0x164>
3edc: e5933000 ldr r3, [r3]
c = toupper(c);
if (!iscntrl(c))
3ee0: e0831001 add r1, r3, r1
3ee4: e5d13001 ldrb r3, [r1, #1]
3ee8: e3130020 tst r3, #32
tty->column++;
3eec: 05943028 ldreq r3, [r4, #40] ; 0x28
3ef0: 02833001 addeq r3, r3, #1
3ef4: 05843028 streq r3, [r4, #40] ; 0x28
break;
}
}
rtems_termios_puts (&c, 1, tty);
3ef8: e1a0000d mov r0, sp
3efc: e3a01001 mov r1, #1
3f00: e1a02004 mov r2, r4
3f04: ebffff98 bl 3d6c <rtems_termios_puts>
}
3f08: e28dd004 add sp, sp, #4
3f0c: e8bd8010 pop {r4, pc}
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
3f10: e3130010 tst r3, #16 <== NOT EXECUTED
3f14: 0a000002 beq 3f24 <oproc+0x9c> <== NOT EXECUTED
3f18: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED
3f1c: e3520000 cmp r2, #0 <== NOT EXECUTED
3f20: 0afffff8 beq 3f08 <oproc+0x80> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
3f24: e2132008 ands r2, r3, #8 <== NOT EXECUTED
c = '\n';
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
break;
}
tty->column = 0;
3f28: 05842028 streq r2, [r4, #40] ; 0x28 <== NOT EXECUTED
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
return;
if (tty->termios.c_oflag & OCRNL) {
3f2c: 0afffff1 beq 3ef8 <oproc+0x70> <== NOT EXECUTED
c = '\n';
if (tty->termios.c_oflag & ONLRET)
3f30: e3130020 tst r3, #32 <== NOT EXECUTED
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
return;
if (tty->termios.c_oflag & OCRNL) {
c = '\n';
3f34: e3a0300a mov r3, #10 <== NOT EXECUTED
3f38: e5cd3000 strb r3, [sp] <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
3f3c: 13a03000 movne r3, #0 <== NOT EXECUTED
3f40: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
3f44: eaffffeb b 3ef8 <oproc+0x70> <== NOT EXECUTED
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
3f48: e5942028 ldr r2, [r4, #40] ; 0x28
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
3f4c: e2033b06 and r3, r3, #6144 ; 0x1800
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
3f50: e2021007 and r1, r2, #7
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
3f54: e3530b06 cmp r3, #6144 ; 0x1800
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
3f58: e2611008 rsb r1, r1, #8
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
rtems_termios_puts ( " ", i, tty);
return;
}
tty->column += i;
3f5c: 10811002 addne r1, r1, r2
3f60: 15841028 strne r1, [r4, #40] ; 0x28
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
3f64: 1affffe3 bne 3ef8 <oproc+0x70>
tty->column += i;
3f68: e0812002 add r2, r1, r2
3f6c: e5842028 str r2, [r4, #40] ; 0x28
rtems_termios_puts ( " ", i, tty);
3f70: e59f0078 ldr r0, [pc, #120] ; 3ff0 <oproc+0x168>
3f74: e1a02004 mov r2, r4
3f78: ebffff7b bl 3d6c <rtems_termios_puts>
return;
3f7c: eaffffe1 b 3f08 <oproc+0x80>
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
3f80: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
3f84: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
3f88: c2433001 subgt r3, r3, #1 <== NOT EXECUTED
3f8c: c5843028 strgt r3, [r4, #40] ; 0x28 <== NOT EXECUTED
3f90: eaffffd8 b 3ef8 <oproc+0x70> <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
3f94: e3130020 tst r3, #32
tty->column = 0;
3f98: 13a02000 movne r2, #0
3f9c: 15842028 strne r2, [r4, #40] ; 0x28
if (tty->termios.c_oflag & ONLCR) {
3fa0: e3130004 tst r3, #4
3fa4: 0affffd3 beq 3ef8 <oproc+0x70>
rtems_termios_puts ("\r", 1, tty);
3fa8: e59f0044 ldr r0, [pc, #68] ; 3ff4 <oproc+0x16c>
3fac: e3a01001 mov r1, #1
3fb0: e1a02004 mov r2, r4
3fb4: ebffff6c bl 3d6c <rtems_termios_puts>
tty->column = 0;
3fb8: e3a03000 mov r3, #0
3fbc: e5843028 str r3, [r4, #40] ; 0x28
3fc0: eaffffcc b 3ef8 <oproc+0x70>
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
c = toupper(c);
3fc4: e59f3020 ldr r3, [pc, #32] ; 3fec <oproc+0x164> <== NOT EXECUTED
3fc8: e5933000 ldr r3, [r3] <== NOT EXECUTED
3fcc: e0832001 add r2, r3, r1 <== NOT EXECUTED
3fd0: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED
3fd4: e2022003 and r2, r2, #3 <== NOT EXECUTED
3fd8: e3520002 cmp r2, #2 <== NOT EXECUTED
3fdc: 02411020 subeq r1, r1, #32 <== NOT EXECUTED
3fe0: e20110ff and r1, r1, #255 ; 0xff <== NOT EXECUTED
3fe4: e5cd1000 strb r1, [sp] <== NOT EXECUTED
3fe8: eaffffbc b 3ee0 <oproc+0x58> <== NOT EXECUTED
0000cfb8 <pipe_ioctl>:
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
cfb8: e3a03a46 mov r3, #286720 ; 0x46000
cfbc: e2833e67 add r3, r3, #1648 ; 0x670
cfc0: e283313d add r3, r3, #1073741839 ; 0x4000000f
cfc4: e1510003 cmp r1, r3
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
cfc8: e92d4070 push {r4, r5, r6, lr}
cfcc: e1a05000 mov r5, r0
cfd0: e1a04002 mov r4, r2
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
cfd4: 13e00015 mvnne r0, #21
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
cfd8: 18bd8070 popne {r4, r5, r6, pc}
if (buffer == NULL)
cfdc: e3520000 cmp r2, #0
return -EFAULT;
cfe0: 03e0000d mvneq r0, #13
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
cfe4: 08bd8070 popeq {r4, r5, r6, pc}
return -EFAULT;
if (! PIPE_LOCK(pipe))
cfe8: e3a01000 mov r1, #0
cfec: e5950028 ldr r0, [r5, #40] ; 0x28
cff0: e1a02001 mov r2, r1
cff4: ebffeb4c bl 7d2c <rtems_semaphore_obtain>
cff8: e2506000 subs r6, r0, #0
cffc: 0a000001 beq d008 <pipe_ioctl+0x50>
return -EINTR;
d000: e3e00003 mvn r0, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
d004: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
d008: e595300c ldr r3, [r5, #12]
PIPE_UNLOCK(pipe);
d00c: e5950028 ldr r0, [r5, #40] ; 0x28
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
d010: e5843000 str r3, [r4]
PIPE_UNLOCK(pipe);
d014: ebffeb8d bl 7e50 <rtems_semaphore_release>
return 0;
d018: e1a00006 mov r0, r6
d01c: e8bd8070 pop {r4, r5, r6, pc}
0000cbec <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
cbec: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
cbf0: e1a09001 mov r9, r1
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
cbf4: e3a01000 mov r1, #0
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
cbf8: e24dd008 sub sp, sp, #8
cbfc: e1a04000 mov r4, r0
cc00: e1a05002 mov r5, r2
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
cc04: e5900028 ldr r0, [r0, #40] ; 0x28
cc08: e1a02001 mov r2, r1
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
cc0c: e1a07003 mov r7, r3
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
cc10: ebffec45 bl 7d2c <rtems_semaphore_obtain>
cc14: e250a000 subs sl, r0, #0
return -EINTR;
cc18: 13e00003 mvnne r0, #3
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
cc1c: 1a000028 bne ccc4 <pipe_read+0xd8>
return -EINTR;
while (read < count) {
cc20: e3550000 cmp r5, #0
cc24: 01a08005 moveq r8, r5
cc28: 01a06008 moveq r6, r8
cc2c: 0a00001f beq ccb0 <pipe_read+0xc4>
cc30: e1a0800a mov r8, sl
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
cc34: e28db004 add fp, sp, #4
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
cc38: e594200c ldr r2, [r4, #12]
cc3c: e3520000 cmp r2, #0
cc40: 1a000021 bne cccc <pipe_read+0xe0>
/* Not an error */
if (pipe->Writers == 0)
cc44: e5946014 ldr r6, [r4, #20]
cc48: e3560000 cmp r6, #0
cc4c: 0a000017 beq ccb0 <pipe_read+0xc4>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
cc50: e5976014 ldr r6, [r7, #20]
cc54: e2166001 ands r6, r6, #1
cc58: 1a00003b bne cd4c <pipe_read+0x160>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
cc5c: e5943018 ldr r3, [r4, #24]
cc60: e2833001 add r3, r3, #1
cc64: e5843018 str r3, [r4, #24]
PIPE_UNLOCK(pipe);
cc68: e5940028 ldr r0, [r4, #40] ; 0x28
cc6c: ebffec77 bl 7e50 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
cc70: e1a01006 mov r1, r6
cc74: e594002c ldr r0, [r4, #44] ; 0x2c
cc78: eb000636 bl e558 <rtems_barrier_wait>
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
cc7c: e1a01006 mov r1, r6
cc80: e1a02001 mov r2, r1
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
cc84: e2506000 subs r6, r0, #0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
cc88: e5940028 ldr r0, [r4, #40] ; 0x28
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
cc8c: 13e06003 mvnne r6, #3
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
cc90: ebffec25 bl 7d2c <rtems_semaphore_obtain>
cc94: e3500000 cmp r0, #0
cc98: 1a00002d bne cd54 <pipe_read+0x168>
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
cc9c: e5943018 ldr r3, [r4, #24]
if (ret != 0)
cca0: e3560000 cmp r6, #0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
cca4: e2433001 sub r3, r3, #1
cca8: e5843018 str r3, [r4, #24]
if (ret != 0)
ccac: 0affffe1 beq cc38 <pipe_read+0x4c>
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
ccb0: e5940028 ldr r0, [r4, #40] ; 0x28
ccb4: ebffec65 bl 7e50 <rtems_semaphore_release>
out_nolock:
if (read > 0)
ccb8: e3580000 cmp r8, #0
ccbc: c1a00008 movgt r0, r8
ccc0: d1a00006 movle r0, r6
return read;
return ret;
}
ccc4: e28dd008 add sp, sp, #8
ccc8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
cccc: e5941008 ldr r1, [r4, #8]
ccd0: e5943004 ldr r3, [r4, #4]
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
ccd4: e06a6005 rsb r6, sl, r5
ccd8: e1520006 cmp r2, r6
ccdc: 31a06002 movcc r6, r2
chunk1 = pipe->Size - pipe->Start;
cce0: e0613003 rsb r3, r1, r3
if (chunk > chunk1) {
cce4: e1560003 cmp r6, r3
cce8: ca00001b bgt cd5c <pipe_read+0x170>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
ccec: e5943000 ldr r3, [r4]
ccf0: e089000a add r0, r9, sl
ccf4: e0831001 add r1, r3, r1
ccf8: e1a02006 mov r2, r6
ccfc: eb00120f bl 11540 <memcpy>
pipe->Start += chunk;
cd00: e5940008 ldr r0, [r4, #8]
pipe->Start %= pipe->Size;
cd04: e5941004 ldr r1, [r4, #4]
cd08: e0860000 add r0, r6, r0
cd0c: eb00411a bl 1d17c <__umodsi3>
pipe->Length -= chunk;
cd10: e594300c ldr r3, [r4, #12]
cd14: e0663003 rsb r3, r6, r3
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
cd18: e3530000 cmp r3, #0
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
cd1c: e5840008 str r0, [r4, #8]
pipe->Length -= chunk;
cd20: e584300c str r3, [r4, #12]
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
cd24: 05843008 streq r3, [r4, #8]
if (pipe->waitingWriters > 0)
cd28: e594301c ldr r3, [r4, #28]
cd2c: e3530000 cmp r3, #0
cd30: 1a000016 bne cd90 <pipe_read+0x1a4>
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
cd34: e0888006 add r8, r8, r6
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
cd38: e1580005 cmp r8, r5
cd3c: e1a0a008 mov sl, r8
cd40: 3affffbc bcc cc38 <pipe_read+0x4c>
cd44: e3a06000 mov r6, #0
cd48: eaffffd8 b ccb0 <pipe_read+0xc4>
/* Not an error */
if (pipe->Writers == 0)
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
cd4c: e3e0600a mvn r6, #10
cd50: eaffffd6 b ccb0 <pipe_read+0xc4>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
cd54: e3e06003 mvn r6, #3 <== NOT EXECUTED
cd58: eaffffd6 b ccb8 <pipe_read+0xcc> <== NOT EXECUTED
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
cd5c: e5940000 ldr r0, [r4]
cd60: e1a02003 mov r2, r3
cd64: e0801001 add r1, r0, r1
cd68: e089000a add r0, r9, sl
cd6c: e58d3000 str r3, [sp]
cd70: eb0011f2 bl 11540 <memcpy>
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
cd74: e59d3000 ldr r3, [sp]
cd78: e08a0003 add r0, sl, r3
cd7c: e0890000 add r0, r9, r0
cd80: e5941000 ldr r1, [r4]
cd84: e0632006 rsb r2, r3, r6
cd88: eb0011ec bl 11540 <memcpy>
cd8c: eaffffdb b cd00 <pipe_read+0x114>
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
cd90: e5940030 ldr r0, [r4, #48] ; 0x30
cd94: e1a0100b mov r1, fp
cd98: eb0005d6 bl e4f8 <rtems_barrier_release>
cd9c: eaffffe4 b cd34 <pipe_read+0x148>
0000cda0 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
cda0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
cda4: e2524000 subs r4, r2, #0
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
cda8: e1a05000 mov r5, r0
cdac: e24dd008 sub sp, sp, #8
cdb0: e1a06001 mov r6, r1
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
cdb4: 01a00004 moveq r0, r4
)
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
cdb8: 1a000001 bne cdc4 <pipe_write+0x24>
#endif
if (written > 0)
return written;
return ret;
}
cdbc: e28dd008 add sp, sp, #8
cdc0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
cdc4: e3a01000 mov r1, #0
cdc8: e5950028 ldr r0, [r5, #40] ; 0x28
cdcc: e1a02001 mov r2, r1
cdd0: e58d3000 str r3, [sp]
cdd4: ebffebd4 bl 7d2c <rtems_semaphore_obtain>
cdd8: e2509000 subs r9, r0, #0
cddc: e59d3000 ldr r3, [sp]
return -EINTR;
cde0: 13e00003 mvnne r0, #3
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
cde4: 1afffff4 bne cdbc <pipe_write+0x1c>
return -EINTR;
if (pipe->Readers == 0) {
cde8: e595a010 ldr sl, [r5, #16]
cdec: e35a0000 cmp sl, #0
cdf0: 0a000058 beq cf58 <pipe_write+0x1b8>
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
cdf4: e5957004 ldr r7, [r5, #4]
cdf8: e1540007 cmp r4, r7
cdfc: 91a08004 movls r8, r4
ce00: 83a08001 movhi r8, #1
ce04: e1a0a009 mov sl, r9
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
ce08: e28db004 add fp, sp, #4
/* 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) {
ce0c: e595100c ldr r1, [r5, #12]
ce10: e0612007 rsb r2, r1, r7
ce14: e1520008 cmp r2, r8
ce18: 2a000021 bcs cea4 <pipe_write+0x104>
if (LIBIO_NODELAY(iop)) {
ce1c: e5937014 ldr r7, [r3, #20]
ce20: e2177001 ands r7, r7, #1
ce24: 1a000053 bne cf78 <pipe_write+0x1d8>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
ce28: e595201c ldr r2, [r5, #28]
ce2c: e2822001 add r2, r2, #1
ce30: e585201c str r2, [r5, #28]
PIPE_UNLOCK(pipe);
ce34: e5950028 ldr r0, [r5, #40] ; 0x28
ce38: e58d3000 str r3, [sp]
ce3c: ebffec03 bl 7e50 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
ce40: e1a01007 mov r1, r7
ce44: e5950030 ldr r0, [r5, #48] ; 0x30
ce48: eb0005c2 bl e558 <rtems_barrier_wait>
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
ce4c: e1a01007 mov r1, r7
ce50: e1a02001 mov r2, r1
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ce54: e2507000 subs r7, r0, #0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
ce58: e5950028 ldr r0, [r5, #40] ; 0x28
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ce5c: 13e07003 mvnne r7, #3
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
ce60: ebffebb1 bl 7d2c <rtems_semaphore_obtain>
ce64: e3500000 cmp r0, #0
ce68: e59d3000 ldr r3, [sp]
ce6c: 1a00003f bne cf70 <pipe_write+0x1d0>
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
ce70: e595201c ldr r2, [r5, #28]
if (ret != 0)
ce74: e3570000 cmp r7, #0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
ce78: e2422001 sub r2, r2, #1
ce7c: e585201c str r2, [r5, #28]
if (ret != 0)
ce80: 1a00002c bne cf38 <pipe_write+0x198>
goto out_locked;
if (pipe->Readers == 0) {
ce84: e5952010 ldr r2, [r5, #16]
ce88: e3520000 cmp r2, #0
ce8c: 0a000031 beq cf58 <pipe_write+0x1b8>
ce90: e5957004 ldr r7, [r5, #4]
/* 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) {
ce94: e595100c ldr r1, [r5, #12]
ce98: e0612007 rsb r2, r1, r7
ce9c: e1520008 cmp r2, r8
cea0: 3affffdd bcc ce1c <pipe_write+0x7c>
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
cea4: e5950008 ldr r0, [r5, #8]
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
cea8: e0698004 rsb r8, r9, r4
chunk1 = pipe->Size - PIPE_WSTART(pipe);
ceac: e0810000 add r0, r1, r0
ceb0: e1a01007 mov r1, r7
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
ceb4: e1520008 cmp r2, r8
ceb8: 31a08002 movcc r8, r2
chunk1 = pipe->Size - PIPE_WSTART(pipe);
cebc: e58d3000 str r3, [sp]
cec0: eb0040ad bl 1d17c <__umodsi3>
cec4: e0607007 rsb r7, r0, r7
if (chunk > chunk1) {
cec8: e1580007 cmp r8, r7
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
cecc: e1a0c000 mov ip, r0
if (chunk > chunk1) {
ced0: e59d3000 ldr r3, [sp]
ced4: da000029 ble cf80 <pipe_write+0x1e0>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
ced8: e5950000 ldr r0, [r5]
cedc: e0861009 add r1, r6, r9
cee0: e1a02007 mov r2, r7
cee4: e080000c add r0, r0, ip
cee8: eb001194 bl 11540 <memcpy>
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
ceec: e0871009 add r1, r7, r9
cef0: e5950000 ldr r0, [r5]
cef4: e0861001 add r1, r6, r1
cef8: e0672008 rsb r2, r7, r8
cefc: eb00118f bl 11540 <memcpy>
cf00: e59d3000 ldr r3, [sp]
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
cf04: e595200c ldr r2, [r5, #12]
if (pipe->waitingReaders > 0)
cf08: e5951018 ldr r1, [r5, #24]
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
cf0c: e0822008 add r2, r2, r8
if (pipe->waitingReaders > 0)
cf10: e3510000 cmp r1, #0
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
cf14: e585200c str r2, [r5, #12]
if (pipe->waitingReaders > 0)
cf18: 1a000020 bne cfa0 <pipe_write+0x200>
PIPE_WAKEUPREADERS(pipe);
written += chunk;
cf1c: e08aa008 add sl, sl, r8
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
cf20: e154000a cmp r4, sl
cf24: e1a0900a mov r9, sl
cf28: 85957004 ldrhi r7, [r5, #4]
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
written += chunk;
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
cf2c: 83a08001 movhi r8, #1
cf30: 8affffb5 bhi ce0c <pipe_write+0x6c>
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
cf34: e3a07000 mov r7, #0
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
cf38: e5950028 ldr r0, [r5, #40] ; 0x28
cf3c: ebffebc3 bl 7e50 <rtems_semaphore_release>
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
cf40: e3770020 cmn r7, #32
cf44: 0a000005 beq cf60 <pipe_write+0x1c0>
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
cf48: e35a0000 cmp sl, #0
cf4c: c1a0000a movgt r0, sl
cf50: d1a00007 movle r0, r7
cf54: eaffff98 b cdbc <pipe_write+0x1c>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
cf58: e3e0701f mvn r7, #31
cf5c: eafffff5 b cf38 <pipe_write+0x198>
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
cf60: eb00022a bl d810 <getpid>
cf64: e3a0100d mov r1, #13
cf68: eb0002f6 bl db48 <kill>
cf6c: eafffff5 b cf48 <pipe_write+0x1a8>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
cf70: e3e07003 mvn r7, #3 <== NOT EXECUTED
cf74: eafffff3 b cf48 <pipe_write+0x1a8> <== NOT EXECUTED
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
cf78: e3e0700a mvn r7, #10
cf7c: eaffffed b cf38 <pipe_write+0x198>
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
cf80: e5950000 ldr r0, [r5]
cf84: e0861009 add r1, r6, r9
cf88: e080000c add r0, r0, ip
cf8c: e1a02008 mov r2, r8
cf90: e58d3000 str r3, [sp]
cf94: eb001169 bl 11540 <memcpy>
cf98: e59d3000 ldr r3, [sp]
cf9c: eaffffd8 b cf04 <pipe_write+0x164>
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
cfa0: e595002c ldr r0, [r5, #44] ; 0x2c
cfa4: e1a0100b mov r1, fp
cfa8: e58d3000 str r3, [sp]
cfac: eb000551 bl e4f8 <rtems_barrier_release>
cfb0: e59d3000 ldr r3, [sp]
cfb4: eaffffd8 b cf1c <pipe_write+0x17c>
0000ac74 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
ac74: e3500000 cmp r0, #0
ac78: 0a00000e beq acb8 <pthread_attr_setschedpolicy+0x44>
ac7c: e5903000 ldr r3, [r0]
ac80: e3530000 cmp r3, #0
ac84: 0a00000b beq acb8 <pthread_attr_setschedpolicy+0x44>
return EINVAL;
switch ( policy ) {
ac88: e3510004 cmp r1, #4
ac8c: 9a000001 bls ac98 <pthread_attr_setschedpolicy+0x24>
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
ac90: e3a00086 mov r0, #134 ; 0x86
} }
ac94: e12fff1e bx lr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
ac98: e3a03001 mov r3, #1
ac9c: e1a03113 lsl r3, r3, r1
aca0: e3130017 tst r3, #23
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
aca4: 15801014 strne r1, [r0, #20]
return 0;
aca8: 13a00000 movne r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
acac: 112fff1e bxne lr
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
acb0: e3a00086 mov r0, #134 ; 0x86 <== NOT EXECUTED
} }
acb4: e12fff1e bx lr <== NOT EXECUTED
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
acb8: e3a00016 mov r0, #22
acbc: e12fff1e bx lr
00023140 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
23140: e92d40f0 push {r4, r5, r6, r7, lr}
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
23144: e2516000 subs r6, r1, #0
int pthread_kill(
pthread_t thread,
int sig
)
{
23148: e24dd008 sub sp, sp, #8
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
2314c: 0a000025 beq 231e8 <pthread_kill+0xa8>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
23150: e2467001 sub r7, r6, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
23154: e357001f cmp r7, #31
23158: 8a000022 bhi 231e8 <pthread_kill+0xa8>
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _Thread_Get( thread, &location );
2315c: e28d1004 add r1, sp, #4 23160: ebffa929 bl d60c <_Thread_Get>
switch ( location ) {
23164: e59d2004 ldr r2, [sp, #4] 23168: e3520000 cmp r2, #0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _Thread_Get( thread, &location );
2316c: e1a04000 mov r4, r0
switch ( location ) {
23170: 1a000021 bne 231fc <pthread_kill+0xbc>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
23174: e59f3094 ldr r3, [pc, #148] ; 23210 <pthread_kill+0xd0> 23178: e0861086 add r1, r6, r6, lsl #1 2317c: e0833101 add r3, r3, r1, lsl #2 23180: e5933008 ldr r3, [r3, #8] 23184: e3530001 cmp r3, #1
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
23188: e59030fc ldr r3, [r0, #252] ; 0xfc
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
2318c: 0a000010 beq 231d4 <pthread_kill+0x94>
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
23190: e59310d4 ldr r1, [r3, #212] ; 0xd4
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
23194: e3a05001 mov r5, #1 23198: e1817715 orr r7, r1, r5, lsl r7
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
2319c: e1a01006 mov r1, r6
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
231a0: e58370d4 str r7, [r3, #212] ; 0xd4
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
231a4: ebffff96 bl 23004 <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
231a8: e59f3064 ldr r3, [pc, #100] ; 23214 <pthread_kill+0xd4> 231ac: e5932000 ldr r2, [r3] 231b0: e3520000 cmp r2, #0
231b4: 0a000002 beq 231c4 <pthread_kill+0x84>
231b8: e5932004 ldr r2, [r3, #4] 231bc: e1540002 cmp r4, r2
_Thread_Dispatch_necessary = true;
231c0: 05c35010 strbeq r5, [r3, #16]
}
_Thread_Enable_dispatch();
231c4: ebffa907 bl d5e8 <_Thread_Enable_dispatch>
return 0;
231c8: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
}
231cc: e28dd008 add sp, sp, #8
231d0: e8bd80f0 pop {r4, r5, r6, r7, pc}
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
_Thread_Enable_dispatch();
231d4: e58d2000 str r2, [sp] 231d8: ebffa902 bl d5e8 <_Thread_Enable_dispatch>
return 0;
231dc: e59d2000 ldr r2, [sp] 231e0: e1a00002 mov r0, r2 231e4: eafffff8 b 231cc <pthread_kill+0x8c>
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
231e8: ebffc121 bl 13674 <__errno> 231ec: e3a03016 mov r3, #22 231f0: e5803000 str r3, [r0] 231f4: e3e00000 mvn r0, #0 231f8: eafffff3 b 231cc <pthread_kill+0x8c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
231fc: ebffc11c bl 13674 <__errno> <== NOT EXECUTED 23200: e3a03003 mov r3, #3 <== NOT EXECUTED 23204: e5803000 str r3, [r0] <== NOT EXECUTED 23208: e3e00000 mvn r0, #0 <== NOT EXECUTED 2320c: eaffffee b 231cc <pthread_kill+0x8c> <== NOT EXECUTED
00007b28 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
7b28: e3500000 cmp r0, #0
7b2c: 0a000008 beq 7b54 <pthread_mutexattr_setpshared+0x2c>
7b30: e5903000 ldr r3, [r0]
7b34: e3530000 cmp r3, #0
7b38: 0a000005 beq 7b54 <pthread_mutexattr_setpshared+0x2c>
return EINVAL;
switch ( pshared ) {
7b3c: e3510001 cmp r1, #1
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
7b40: 95801004 strls r1, [r0, #4]
return 0;
7b44: 93a00000 movls r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
7b48: 912fff1e bxls lr
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
7b4c: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
7b50: e12fff1e bx lr <== NOT EXECUTED
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
7b54: e3a00016 mov r0, #22
7b58: e12fff1e bx lr
00006f80 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
6f80: e92d4030 push {r4, r5, lr}
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
6f84: e2505000 subs r5, r0, #0
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
6f88: e24dd00c sub sp, sp, #12
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
6f8c: 0a00001d beq 7008 <pthread_rwlock_timedrdlock+0x88>
*
* 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 );
6f90: e1a00001 mov r0, r1
6f94: e28d1004 add r1, sp, #4
6f98: eb001a30 bl d860 <_POSIX_Absolute_timeout_to_ticks>
6f9c: e5951000 ldr r1, [r5]
6fa0: e1a04000 mov r4, r0
6fa4: e28d2008 add r2, sp, #8
6fa8: e59f0098 ldr r0, [pc, #152] ; 7048 <pthread_rwlock_timedrdlock+0xc8>
6fac: eb000aad bl 9a68 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
6fb0: e59d3008 ldr r3, [sp, #8]
6fb4: e3530000 cmp r3, #0
6fb8: 1a000012 bne 7008 <pthread_rwlock_timedrdlock+0x88>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
6fbc: e5951000 ldr r1, [r5]
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,
6fc0: e3540003 cmp r4, #3
6fc4: 13a05000 movne r5, #0
6fc8: 03a05001 moveq r5, #1
6fcc: e58d3000 str r3, [sp]
6fd0: e2800010 add r0, r0, #16
6fd4: e1a02005 mov r2, r5
6fd8: e59d3004 ldr r3, [sp, #4]
6fdc: eb00073d bl 8cd8 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
6fe0: eb000dd4 bl a738 <_Thread_Enable_dispatch>
if ( !do_wait ) {
6fe4: e3550000 cmp r5, #0
6fe8: 1a000011 bne 7034 <pthread_rwlock_timedrdlock+0xb4>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
6fec: e59f3058 ldr r3, [pc, #88] ; 704c <pthread_rwlock_timedrdlock+0xcc>
6ff0: e5933004 ldr r3, [r3, #4]
6ff4: e5930034 ldr r0, [r3, #52] ; 0x34
6ff8: e3500002 cmp r0, #2
6ffc: 0a000004 beq 7014 <pthread_rwlock_timedrdlock+0x94>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
7000: eb000046 bl 7120 <_POSIX_RWLock_Translate_core_RWLock_return_code>
7004: ea000000 b 700c <pthread_rwlock_timedrdlock+0x8c>
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
7008: e3a00016 mov r0, #22
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
700c: e28dd00c add sp, sp, #12
7010: e8bd8030 pop {r4, r5, pc}
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
7014: e3540000 cmp r4, #0
7018: 0afffffa beq 7008 <pthread_rwlock_timedrdlock+0x88>
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
701c: e2444001 sub r4, r4, #1
7020: e3540001 cmp r4, #1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
7024: 93a00074 movls r0, #116 ; 0x74
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
7028: 9afffff7 bls 700c <pthread_rwlock_timedrdlock+0x8c>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
702c: eb00003b bl 7120 <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED
7030: eafffff5 b 700c <pthread_rwlock_timedrdlock+0x8c> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
7034: e59f3010 ldr r3, [pc, #16] ; 704c <pthread_rwlock_timedrdlock+0xcc>
7038: e5933004 ldr r3, [r3, #4]
703c: e5930034 ldr r0, [r3, #52] ; 0x34
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
7040: eb000036 bl 7120 <_POSIX_RWLock_Translate_core_RWLock_return_code>
7044: eafffff0 b 700c <pthread_rwlock_timedrdlock+0x8c>
00007050 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
7050: e92d4030 push {r4, r5, lr}
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
7054: e2505000 subs r5, r0, #0
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
7058: e24dd00c sub sp, sp, #12
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
705c: 0a00001d beq 70d8 <pthread_rwlock_timedwrlock+0x88>
*
* 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 );
7060: e1a00001 mov r0, r1
7064: e28d1004 add r1, sp, #4
7068: eb0019fc bl d860 <_POSIX_Absolute_timeout_to_ticks>
706c: e5951000 ldr r1, [r5]
7070: e1a04000 mov r4, r0
7074: e28d2008 add r2, sp, #8
7078: e59f0098 ldr r0, [pc, #152] ; 7118 <pthread_rwlock_timedwrlock+0xc8>
707c: eb000a79 bl 9a68 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
7080: e59d3008 ldr r3, [sp, #8]
7084: e3530000 cmp r3, #0
7088: 1a000012 bne 70d8 <pthread_rwlock_timedwrlock+0x88>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
708c: e5951000 ldr r1, [r5]
(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,
7090: e3540003 cmp r4, #3
7094: 13a05000 movne r5, #0
7098: 03a05001 moveq r5, #1
709c: e58d3000 str r3, [sp]
70a0: e2800010 add r0, r0, #16
70a4: e1a02005 mov r2, r5
70a8: e59d3004 ldr r3, [sp, #4]
70ac: eb000740 bl 8db4 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
70b0: eb000da0 bl a738 <_Thread_Enable_dispatch>
if ( !do_wait &&
70b4: e3550000 cmp r5, #0
70b8: 1a000011 bne 7104 <pthread_rwlock_timedwrlock+0xb4>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
70bc: e59f3058 ldr r3, [pc, #88] ; 711c <pthread_rwlock_timedwrlock+0xcc>
70c0: e5933004 ldr r3, [r3, #4]
70c4: e5930034 ldr r0, [r3, #52] ; 0x34
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
70c8: e3500002 cmp r0, #2
70cc: 0a000004 beq 70e4 <pthread_rwlock_timedwrlock+0x94>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
70d0: eb000012 bl 7120 <_POSIX_RWLock_Translate_core_RWLock_return_code>
70d4: ea000000 b 70dc <pthread_rwlock_timedwrlock+0x8c>
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
70d8: e3a00016 mov r0, #22
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
70dc: e28dd00c add sp, sp, #12
70e0: e8bd8030 pop {r4, r5, pc}
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
70e4: e3540000 cmp r4, #0
70e8: 0afffffa beq 70d8 <pthread_rwlock_timedwrlock+0x88>
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
70ec: e2444001 sub r4, r4, #1
70f0: e3540001 cmp r4, #1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
70f4: 93a00074 movls r0, #116 ; 0x74
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
70f8: 9afffff7 bls 70dc <pthread_rwlock_timedwrlock+0x8c>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
70fc: eb000007 bl 7120 <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED
7100: eafffff5 b 70dc <pthread_rwlock_timedwrlock+0x8c> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
7104: e59f3010 ldr r3, [pc, #16] ; 711c <pthread_rwlock_timedwrlock+0xcc>
7108: e5933004 ldr r3, [r3, #4]
710c: e5930034 ldr r0, [r3, #52] ; 0x34
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
7110: eb000002 bl 7120 <_POSIX_RWLock_Translate_core_RWLock_return_code>
7114: eafffff0 b 70dc <pthread_rwlock_timedwrlock+0x8c>
000078b8 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
78b8: e3500000 cmp r0, #0
78bc: 0a000008 beq 78e4 <pthread_rwlockattr_setpshared+0x2c>
return EINVAL;
if ( !attr->is_initialized )
78c0: e5903000 ldr r3, [r0]
78c4: e3530000 cmp r3, #0
78c8: 0a000005 beq 78e4 <pthread_rwlockattr_setpshared+0x2c>
return EINVAL;
switch ( pshared ) {
78cc: e3510001 cmp r1, #1
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
78d0: 95801004 strls r1, [r0, #4]
return 0;
78d4: 93a00000 movls r0, #0
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
78d8: 912fff1e bxls lr
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
78dc: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
78e0: e12fff1e bx lr <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
78e4: e3a00016 mov r0, #22
78e8: e12fff1e bx lr
00004418 <readv>:
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
4418: e59f313c ldr r3, [pc, #316] ; 455c <readv+0x144>
441c: e5933000 ldr r3, [r3]
4420: e1500003 cmp r0, r3
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
4424: e92d41f0 push {r4, r5, r6, r7, r8, lr}
4428: e1a04002 mov r4, r2
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
442c: 2a000045 bcs 4548 <readv+0x130>
iop = rtems_libio_iop( fd );
4430: e59f3128 ldr r3, [pc, #296] ; 4560 <readv+0x148>
4434: e5933000 ldr r3, [r3]
4438: e0600180 rsb r0, r0, r0, lsl #3
443c: e0836180 add r6, r3, r0, lsl #3
rtems_libio_check_is_open( iop );
4440: e5963014 ldr r3, [r6, #20]
4444: e3130c01 tst r3, #256 ; 0x100
4448: 0a00003e beq 4548 <readv+0x130>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
444c: e3130002 tst r3, #2
4450: 0a000036 beq 4530 <readv+0x118>
/*
* Argument validation on IO vector
*/
if ( !iov )
4454: e3510000 cmp r1, #0
4458: 0a000034 beq 4530 <readv+0x118>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
445c: e3520000 cmp r2, #0
4460: da000032 ble 4530 <readv+0x118>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
4464: e3520b01 cmp r2, #1024 ; 0x400
4468: ca000030 bgt 4530 <readv+0x118>
446c: e3a02000 mov r2, #0
rtems_set_errno_and_return_minus_one( EINVAL );
4470: e1a05001 mov r5, r1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
4474: e1a03001 mov r3, r1
4478: e3a07001 mov r7, #1
447c: e1a01002 mov r1, r2
4480: ea000000 b 4488 <readv+0x70>
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
4484: e1a0100c mov r1, ip
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
4488: e5930000 ldr r0, [r3]
448c: e3500000 cmp r0, #0
* 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++ ) {
4490: e2822001 add r2, r2, #1
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
4494: 0a000025 beq 4530 <readv+0x118>
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
4498: e5930004 ldr r0, [r3, #4]
449c: e081c000 add ip, r1, r0
if ( total < old )
44a0: e151000c cmp r1, ip
44a4: ca000021 bgt 4530 <readv+0x118>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
44a8: e3500000 cmp r0, #0
44ac: 13a07000 movne r7, #0
* 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++ ) {
44b0: e1540002 cmp r4, r2
44b4: e2833008 add r3, r3, #8
44b8: cafffff1 bgt 4484 <readv+0x6c>
/*
* 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 ) {
44bc: e3570000 cmp r7, #0
return 0;
44c0: 13a08000 movne r8, #0
/*
* 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 ) {
44c4: 1a00001d bne 4540 <readv+0x128>
44c8: e1a08007 mov r8, r7
44cc: ea00000d b 4508 <readv+0xf0>
);
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
44d0: 0a000006 beq 44f0 <readv+0xd8>
iop->offset += bytes;
44d4: e286300c add r3, r6, #12
44d8: e893000c ldm r3, {r2, r3}
44dc: e0922000 adds r2, r2, r0
44e0: e0a33fc0 adc r3, r3, r0, asr #31
44e4: e586200c str r2, [r6, #12]
44e8: e5863010 str r3, [r6, #16]
total += bytes;
44ec: e0888000 add r8, r8, r0
}
if (bytes != iov[ v ].iov_len)
44f0: e5953004 ldr r3, [r5, #4]
44f4: e1500003 cmp r0, r3
44f8: 1a000010 bne 4540 <readv+0x128>
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
44fc: e1540007 cmp r4, r7
4500: e2855008 add r5, r5, #8
4504: da00000d ble 4540 <readv+0x128>
bytes = (*iop->pathinfo.handlers->read_h)(
4508: e8950006 ldm r5, {r1, r2}
450c: e5963020 ldr r3, [r6, #32]
4510: e1a00006 mov r0, r6
4514: e1a0e00f mov lr, pc
4518: e593f008 ldr pc, [r3, #8]
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
451c: e3500000 cmp r0, #0
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
4520: e2877001 add r7, r7, #1
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
4524: aaffffe9 bge 44d0 <readv+0xb8>
return -1;
4528: e3e08000 mvn r8, #0 <== NOT EXECUTED
452c: ea000003 b 4540 <readv+0x128> <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
4530: eb002aa6 bl efd0 <__errno>
4534: e3a03016 mov r3, #22
4538: e5803000 str r3, [r0]
453c: e3e08000 mvn r8, #0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
4540: e1a00008 mov r0, r8
4544: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
4548: eb002aa0 bl efd0 <__errno>
454c: e3a03009 mov r3, #9
4550: e5803000 str r3, [r0]
4554: e3e08000 mvn r8, #0
4558: eafffff8 b 4540 <readv+0x128>
000131b8 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
131b8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
131bc: e59f2118 ldr r2, [pc, #280] ; 132dc <realloc+0x124>
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
131c0: e59f5118 ldr r5, [pc, #280] ; 132e0 <realloc+0x128>
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
131c4: e5922000 ldr r2, [r2]
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
131c8: e5953010 ldr r3, [r5, #16]
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
131cc: e3520003 cmp r2, #3
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
131d0: e2833001 add r3, r3, #1
void *realloc(
void *ptr,
size_t size
)
{
131d4: e24dd004 sub sp, sp, #4 131d8: e1a04000 mov r4, r0 131dc: e1a06001 mov r6, r1
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
131e0: e5853010 str r3, [r5, #16]
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
131e4: 0a000020 beq 1326c <realloc+0xb4>
}
/*
* Continue with realloc().
*/
if ( !ptr )
131e8: e3540000 cmp r4, #0
131ec: 0a00001a beq 1325c <realloc+0xa4>
return malloc( size );
if ( !size ) {
131f0: e3560000 cmp r6, #0
131f4: 0a00000f beq 13238 <realloc+0x80>
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
131f8: e59f70e4 ldr r7, [pc, #228] ; 132e4 <realloc+0x12c> 131fc: e1a01004 mov r1, r4 13200: e5970000 ldr r0, [r7] 13204: e1a0200d mov r2, sp 13208: eb000065 bl 133a4 <_Protected_heap_Get_block_size> 1320c: e2508000 subs r8, r0, #0
13210: 0a00000c beq 13248 <realloc+0x90>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
13214: e5970000 ldr r0, [r7] 13218: e1a01004 mov r1, r4 1321c: e1a02006 mov r2, r6 13220: eb000070 bl 133e8 <_Protected_heap_Resize_block> 13224: e3500000 cmp r0, #0
13228: 0a00001a beq 13298 <realloc+0xe0>
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
1322c: e1a00004 mov r0, r4
13230: e28dd004 add sp, sp, #4
13234: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
*/
if ( !ptr )
return malloc( size );
if ( !size ) {
free( ptr );
13238: e1a00004 mov r0, r4 <== NOT EXECUTED 1323c: ebffbc2a bl 22ec <free> <== NOT EXECUTED
return (void *) 0;
13240: e1a04006 mov r4, r6 <== NOT EXECUTED 13244: eafffff8 b 1322c <realloc+0x74> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
13248: ebffeb35 bl df24 <__errno> 1324c: e3a03016 mov r3, #22 13250: e5803000 str r3, [r0]
return (void *) 0;
13254: e1a04008 mov r4, r8 13258: eafffff3 b 1322c <realloc+0x74>
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
1325c: e1a00006 mov r0, r6 13260: ebffbcfb bl 2654 <malloc> 13264: e1a04000 mov r4, r0 13268: eaffffef b 1322c <realloc+0x74>
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
1326c: e59f3074 ldr r3, [pc, #116] ; 132e8 <realloc+0x130> 13270: e5933000 ldr r3, [r3] 13274: e3530000 cmp r3, #0
return (void *) 0;
13278: 13a04000 movne r4, #0
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
1327c: 1affffea bne 1322c <realloc+0x74>
return (void *) 0;
if (_ISR_Nest_level > 0)
13280: e59f2064 ldr r2, [pc, #100] ; 132ec <realloc+0x134> 13284: e5922000 ldr r2, [r2] 13288: e3520000 cmp r2, #0
return (void *) 0;
1328c: 11a04003 movne r4, r3
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
return (void *) 0;
if (_ISR_Nest_level > 0)
13290: 0affffd4 beq 131e8 <realloc+0x30>
13294: eaffffe4 b 1322c <realloc+0x74> <== NOT EXECUTED
* 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 );
13298: e1a00006 mov r0, r6 1329c: ebffbcec bl 2654 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
132a0: e5953004 ldr r3, [r5, #4]
if ( !new_area ) {
132a4: e2507000 subs r7, r0, #0
* and the C Standard.
*/
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
132a8: e2433001 sub r3, r3, #1 132ac: e5853004 str r3, [r5, #4]
if ( !new_area ) {
return (void *) 0;
132b0: 01a04007 moveq r4, r7
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
132b4: 0affffdc beq 1322c <realloc+0x74>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
132b8: e59d2000 ldr r2, [sp] 132bc: e1a01004 mov r1, r4 132c0: e1560002 cmp r6, r2 132c4: 31a02006 movcc r2, r6 132c8: ebffed43 bl e7dc <memcpy>
free( ptr );
132cc: e1a00004 mov r0, r4 132d0: ebffbc05 bl 22ec <free>
return new_area;
132d4: e1a04007 mov r4, r7 132d8: eaffffd3 b 1322c <realloc+0x74>
00006cc8 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
6cc8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
6ccc: e59f41c4 ldr r4, [pc, #452] ; 6e98 <rtems_aio_enqueue+0x1d0>
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
6cd0: e24dd024 sub sp, sp, #36 ; 0x24
6cd4: e1a06000 mov r6, r0
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
6cd8: e1a00004 mov r0, r4
6cdc: eb000256 bl 763c <pthread_mutex_lock>
if (result != 0) {
6ce0: e2505000 subs r5, r0, #0
6ce4: 1a00002a bne 6d94 <rtems_aio_enqueue+0xcc>
return result;
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
6ce8: eb000483 bl 7efc <pthread_self>
6cec: e28d101c add r1, sp, #28
6cf0: e1a0200d mov r2, sp
6cf4: eb000380 bl 7afc <pthread_getschedparam>
req->caller_thread = pthread_self ();
6cf8: eb00047f bl 7efc <pthread_self>
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
6cfc: e5963014 ldr r3, [r6, #20]
6d00: e59dc000 ldr ip, [sp]
6d04: e5932014 ldr r2, [r3, #20]
6d08: e062200c rsb r2, r2, ip
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
6d0c: e5941068 ldr r1, [r4, #104] ; 0x68
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
6d10: e586200c str r2, [r6, #12]
req->policy = policy;
6d14: e59d201c ldr r2, [sp, #28]
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
6d18: e3510000 cmp r1, #0
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
6d1c: e5862008 str r2, [r6, #8]
req->aiocbp->error_code = EINPROGRESS;
6d20: e3a02077 mov r2, #119 ; 0x77
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
6d24: e5860010 str r0, [r6, #16]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio; req->policy = policy; req->aiocbp->error_code = EINPROGRESS;
6d28: e5832030 str r2, [r3, #48] ; 0x30
req->aiocbp->return_value = 0;
6d2c: e5835034 str r5, [r3, #52] ; 0x34
if ((aio_request_queue.idle_threads == 0) &&
6d30: 1a000002 bne 6d40 <rtems_aio_enqueue+0x78>
6d34: e5942064 ldr r2, [r4, #100] ; 0x64
6d38: e3520004 cmp r2, #4
6d3c: da000017 ble 6da0 <rtems_aio_enqueue+0xd8>
else
{
/* the maximum number of threads has been already created
even though some of them might be idle.
The request belongs to one of the active fd chain */
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
6d40: e59f0154 ldr r0, [pc, #340] ; 6e9c <rtems_aio_enqueue+0x1d4>
6d44: e5931000 ldr r1, [r3]
6d48: e3a02000 mov r2, #0
6d4c: ebfffeb3 bl 6820 <rtems_aio_search_fd>
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
6d50: e2507000 subs r7, r0, #0
6d54: 0a00002e beq 6e14 <rtems_aio_enqueue+0x14c>
{
pthread_mutex_lock (&r_chain->mutex);
6d58: e287401c add r4, r7, #28
6d5c: e1a00004 mov r0, r4
6d60: eb000235 bl 763c <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
6d64: e2870008 add r0, r7, #8
6d68: e1a01006 mov r1, r6
6d6c: ebffff8f bl 6bb0 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
6d70: e2870020 add r0, r7, #32
6d74: eb00011a bl 71e4 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
6d78: e1a00004 mov r0, r4
6d7c: eb00024f bl 76c0 <pthread_mutex_unlock>
if (aio_request_queue.idle_threads > 0)
pthread_cond_signal (&aio_request_queue.new_req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
6d80: e59f0110 ldr r0, [pc, #272] ; 6e98 <rtems_aio_enqueue+0x1d0>
6d84: eb00024d bl 76c0 <pthread_mutex_unlock>
return 0; }
6d88: e1a00005 mov r0, r5
6d8c: e28dd024 add sp, sp, #36 ; 0x24
6d90: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
if (result != 0) {
free (req);
6d94: e1a00006 mov r0, r6 <== NOT EXECUTED
6d98: ebfff0a2 bl 3028 <free> <== NOT EXECUTED
return result;
6d9c: eafffff9 b 6d88 <rtems_aio_enqueue+0xc0> <== NOT EXECUTED
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
6da0: e5931000 ldr r1, [r3]
6da4: e2840048 add r0, r4, #72 ; 0x48
6da8: e3a02001 mov r2, #1
6dac: ebfffe9b bl 6820 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
6db0: e5903018 ldr r3, [r0, #24]
6db4: e3530001 cmp r3, #1
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
6db8: e1a07000 mov r7, r0
if (r_chain->new_fd == 1) {
6dbc: 1affffe5 bne 6d58 <rtems_aio_enqueue+0x90>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
6dc0: e1a01006 mov r1, r6
6dc4: e2800008 add r0, r0, #8
6dc8: eb00089e bl 9048 <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL);
6dcc: e1a01005 mov r1, r5
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
if (r_chain->new_fd == 1) {
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
6dd0: e5875018 str r5, [r7, #24]
pthread_mutex_init (&r_chain->mutex, NULL);
6dd4: e287001c add r0, r7, #28
6dd8: eb0001c4 bl 74f0 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
6ddc: e1a01005 mov r1, r5
6de0: e2870020 add r0, r7, #32
6de4: eb0000cd bl 7120 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
6de8: e28d0020 add r0, sp, #32
6dec: e2841008 add r1, r4, #8
6df0: e59f20a8 ldr r2, [pc, #168] ; 6ea0 <rtems_aio_enqueue+0x1d8>
6df4: e1a03007 mov r3, r7
6df8: eb000296 bl 7858 <pthread_create>
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
6dfc: e2506000 subs r6, r0, #0
6e00: 1a000020 bne 6e88 <rtems_aio_enqueue+0x1c0>
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
++aio_request_queue.active_threads;
6e04: e5943064 ldr r3, [r4, #100] ; 0x64
6e08: e2833001 add r3, r3, #1
6e0c: e5843064 str r3, [r4, #100] ; 0x64
6e10: eaffffda b 6d80 <rtems_aio_enqueue+0xb8>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
6e14: e5963014 ldr r3, [r6, #20]
6e18: e59f0084 ldr r0, [pc, #132] ; 6ea4 <rtems_aio_enqueue+0x1dc>
6e1c: e5931000 ldr r1, [r3]
6e20: e3a02001 mov r2, #1
6e24: ebfffe7d bl 6820 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
6e28: e5903018 ldr r3, [r0, #24]
6e2c: e3530001 cmp r3, #1
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
6e30: e1a08000 mov r8, r0
if (r_chain->new_fd == 1) {
6e34: 0a000008 beq 6e5c <rtems_aio_enqueue+0x194>
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
pthread_cond_init (&r_chain->cond, NULL);
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
6e38: e2800008 add r0, r0, #8
6e3c: e1a01006 mov r1, r6
6e40: ebffff5a bl 6bb0 <rtems_aio_insert_prio>
if (aio_request_queue.idle_threads > 0)
6e44: e5943068 ldr r3, [r4, #104] ; 0x68
6e48: e3530000 cmp r3, #0
6e4c: daffffcb ble 6d80 <rtems_aio_enqueue+0xb8>
pthread_cond_signal (&aio_request_queue.new_req);
6e50: e59f0050 ldr r0, [pc, #80] ; 6ea8 <rtems_aio_enqueue+0x1e0><== NOT EXECUTED
6e54: eb0000e2 bl 71e4 <pthread_cond_signal> <== NOT EXECUTED
6e58: eaffffc8 b 6d80 <rtems_aio_enqueue+0xb8> <== NOT EXECUTED
6e5c: e1a01006 mov r1, r6
6e60: e2800008 add r0, r0, #8
6e64: eb000877 bl 9048 <_Chain_Insert>
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
6e68: e1a01007 mov r1, r7
if (r_chain->new_fd == 1) {
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
6e6c: e5887018 str r7, [r8, #24]
pthread_mutex_init (&r_chain->mutex, NULL);
6e70: e288001c add r0, r8, #28
6e74: eb00019d bl 74f0 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
6e78: e2880020 add r0, r8, #32
6e7c: e1a01007 mov r1, r7
6e80: eb0000a6 bl 7120 <pthread_cond_init>
6e84: eaffffee b 6e44 <rtems_aio_enqueue+0x17c>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
pthread_mutex_unlock (&aio_request_queue.mutex);
6e88: e1a00004 mov r0, r4 <== NOT EXECUTED
6e8c: eb00020b bl 76c0 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
6e90: e1a05006 mov r5, r6 <== NOT EXECUTED
6e94: eaffffbb b 6d88 <rtems_aio_enqueue+0xc0> <== NOT EXECUTED
00006944 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
6944: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
6948: e24dd02c sub sp, sp, #44 ; 0x2c
694c: e1a05000 mov r5, r0
6950: e280601c add r6, r0, #28
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
6954: e28d8028 add r8, sp, #40 ; 0x28
6958: e28d7004 add r7, sp, #4
if (result == -1) {
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
req->aiocbp->error_code = 0;
695c: e3a09000 mov r9, #0
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
6960: e1a00006 mov r0, r6
6964: eb000334 bl 763c <pthread_mutex_lock>
if (result != 0)
6968: e250a000 subs sl, r0, #0
696c: 1a000022 bne 69fc <rtems_aio_handle+0xb8>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
6970: e5954008 ldr r4, [r5, #8]
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
6974: e285300c add r3, r5, #12
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
6978: e1540003 cmp r4, r3
697c: 0a000039 beq 6a68 <rtems_aio_handle+0x124>
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
6980: eb00055d bl 7efc <pthread_self>
6984: e1a01008 mov r1, r8
6988: e1a02007 mov r2, r7
698c: eb00045a bl 7afc <pthread_getschedparam>
param.sched_priority = req->priority;
6990: e594300c ldr r3, [r4, #12]
6994: e58d3004 str r3, [sp, #4]
pthread_setschedparam (pthread_self(), req->policy, ¶m);
6998: eb000557 bl 7efc <pthread_self>
699c: e5941008 ldr r1, [r4, #8]
69a0: e1a02007 mov r2, r7
69a4: eb000559 bl 7f10 <pthread_setschedparam>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
69a8: e1a00004 mov r0, r4
69ac: eb000990 bl 8ff4 <_Chain_Extract>
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
69b0: e1a00006 mov r0, r6
69b4: eb000341 bl 76c0 <pthread_mutex_unlock>
switch (req->aiocbp->aio_lio_opcode) {
69b8: e594a014 ldr sl, [r4, #20]
69bc: e59a302c ldr r3, [sl, #44] ; 0x2c
69c0: e3530002 cmp r3, #2
69c4: 0a00001f beq 6a48 <rtems_aio_handle+0x104>
69c8: e3530003 cmp r3, #3
69cc: 0a00001a beq 6a3c <rtems_aio_handle+0xf8>
69d0: e3530001 cmp r3, #1
69d4: 0a00000b beq 6a08 <rtems_aio_handle+0xc4>
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
69d8: e3e01000 mvn r1, #0 <== NOT EXECUTED
69dc: e58a1034 str r1, [sl, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = errno;
69e0: eb002870 bl 10ba8 <__errno> <== NOT EXECUTED
69e4: e5903000 ldr r3, [r0] <== NOT EXECUTED
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
69e8: e1a00006 mov r0, r6 <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
69ec: e58a3030 str r3, [sl, #48] ; 0x30 <== NOT EXECUTED
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
69f0: eb000311 bl 763c <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
69f4: e250a000 subs sl, r0, #0 <== NOT EXECUTED
69f8: 0affffdc beq 6970 <rtems_aio_handle+0x2c> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
69fc: e3a00000 mov r0, #0
6a00: e28dd02c add sp, sp, #44 ; 0x2c
6a04: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
6a08: e59ac008 ldr ip, [sl, #8]
6a0c: e59a0000 ldr r0, [sl]
6a10: e28a100c add r1, sl, #12
6a14: e8910006 ldm r1, {r1, r2}
6a18: e59a3004 ldr r3, [sl, #4]
6a1c: e58dc000 str ip, [sp]
6a20: eb002b64 bl 117b8 <pread>
break;
default:
result = -1;
}
if (result == -1) {
6a24: e3700001 cmn r0, #1
6a28: 0a000056 beq 6b88 <rtems_aio_handle+0x244>
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
6a2c: e5943014 ldr r3, [r4, #20]
6a30: e5830034 str r0, [r3, #52] ; 0x34
req->aiocbp->error_code = 0;
6a34: e5839030 str r9, [r3, #48] ; 0x30
6a38: eaffffc8 b 6960 <rtems_aio_handle+0x1c>
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
6a3c: e59a0000 ldr r0, [sl] <== NOT EXECUTED
6a40: eb001afe bl d640 <fsync> <== NOT EXECUTED
break;
6a44: eafffff6 b 6a24 <rtems_aio_handle+0xe0> <== NOT EXECUTED
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
6a48: e59ac008 ldr ip, [sl, #8]
6a4c: e59a0000 ldr r0, [sl]
6a50: e28a100c add r1, sl, #12
6a54: e8910006 ldm r1, {r1, r2}
6a58: e59a3004 ldr r3, [sl, #4]
6a5c: e58dc000 str ip, [sp]
6a60: eb002b9e bl 118e0 <pwrite>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
6a64: eaffffee b 6a24 <rtems_aio_handle+0xe0>
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
6a68: e59fb138 ldr fp, [pc, #312] ; 6ba8 <rtems_aio_handle+0x264>
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
6a6c: e1a00006 mov r0, r6
6a70: eb000312 bl 76c0 <pthread_mutex_unlock>
pthread_mutex_lock (&aio_request_queue.mutex);
6a74: e1a0000b mov r0, fp
6a78: eb0002ef bl 763c <pthread_mutex_lock>
if (rtems_chain_is_empty (chain))
6a7c: e5953008 ldr r3, [r5, #8]
6a80: e1540003 cmp r4, r3
6a84: 0a000002 beq 6a94 <rtems_aio_handle+0x150>
}
}
/* If there was a request added in the initial fd chain then release
the mutex and process it */
pthread_mutex_unlock (&aio_request_queue.mutex);
6a88: e59f0118 ldr r0, [pc, #280] ; 6ba8 <rtems_aio_handle+0x264>
6a8c: eb00030b bl 76c0 <pthread_mutex_unlock>
6a90: eaffffb2 b 6960 <rtems_aio_handle+0x1c>
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
6a94: e28d1020 add r1, sp, #32
6a98: e3a00001 mov r0, #1
6a9c: eb00014a bl 6fcc <clock_gettime>
timeout.tv_sec += 3;
6aa0: e59d3020 ldr r3, [sp, #32]
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
6aa4: e2854020 add r4, r5, #32
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
6aa8: e2833003 add r3, r3, #3
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
6aac: e1a00004 mov r0, r4
6ab0: e1a0100b mov r1, fp
6ab4: e28d2020 add r2, sp, #32
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
6ab8: e58d3020 str r3, [sp, #32]
timeout.tv_nsec = 0;
6abc: e58da024 str sl, [sp, #36] ; 0x24
result = pthread_cond_timedwait (&r_chain->cond,
6ac0: eb0001e1 bl 724c <pthread_cond_timedwait>
&aio_request_queue.mutex,
&timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
6ac4: e3500074 cmp r0, #116 ; 0x74
6ac8: 1affffee bne 6a88 <rtems_aio_handle+0x144>
6acc: e1a00005 mov r0, r5
6ad0: eb000947 bl 8ff4 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex);
6ad4: e1a00006 mov r0, r6
6ad8: eb000234 bl 73b0 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
6adc: e1a00004 mov r0, r4
6ae0: eb00015b bl 7054 <pthread_cond_destroy>
free (r_chain);
6ae4: e1a00005 mov r0, r5
6ae8: ebfff14e bl 3028 <free>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
6aec: e59b5054 ldr r5, [fp, #84] ; 0x54
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
6af0: e59f20b4 ldr r2, [pc, #180] ; 6bac <rtems_aio_handle+0x268>
6af4: e1550002 cmp r5, r2
6af8: 0a00000d beq 6b34 <rtems_aio_handle+0x1f0>
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
6afc: e59f30a4 ldr r3, [pc, #164] ; 6ba8 <rtems_aio_handle+0x264>
6b00: e5932068 ldr r2, [r3, #104] ; 0x68
++aio_request_queue.active_threads;
6b04: e5933064 ldr r3, [r3, #100] ; 0x64
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
6b08: e59fc098 ldr ip, [pc, #152] ; 6ba8 <rtems_aio_handle+0x264>
6b0c: e2422001 sub r2, r2, #1
++aio_request_queue.active_threads;
6b10: e2833001 add r3, r3, #1
6b14: e1a00005 mov r0, r5
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
6b18: e58c2068 str r2, [ip, #104] ; 0x68
++aio_request_queue.active_threads;
6b1c: e58c3064 str r3, [ip, #100] ; 0x64
6b20: eb000933 bl 8ff4 <_Chain_Extract>
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = (rtems_aio_request_chain *) node;
rtems_aio_move_to_work (r_chain);
6b24: e1a00005 mov r0, r5
6b28: ebffff6f bl 68ec <rtems_aio_move_to_work>
6b2c: e285601c add r6, r5, #28
6b30: eaffffd4 b 6a88 <rtems_aio_handle+0x144>
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
6b34: e59b2068 ldr r2, [fp, #104] ; 0x68
--aio_request_queue.active_threads;
6b38: e59b3064 ldr r3, [fp, #100] ; 0x64
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
6b3c: e2822001 add r2, r2, #1
--aio_request_queue.active_threads;
6b40: e2433001 sub r3, r3, #1
clock_gettime (CLOCK_REALTIME, &timeout);
6b44: e28d1020 add r1, sp, #32
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
6b48: e58b2068 str r2, [fp, #104] ; 0x68
--aio_request_queue.active_threads;
6b4c: e58b3064 str r3, [fp, #100] ; 0x64
clock_gettime (CLOCK_REALTIME, &timeout);
6b50: e3a00001 mov r0, #1
6b54: eb00011c bl 6fcc <clock_gettime>
timeout.tv_sec += 3;
6b58: e59d3020 ldr r3, [sp, #32]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
6b5c: e28b0004 add r0, fp, #4
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
6b60: e2833003 add r3, r3, #3
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
6b64: e1a0100b mov r1, fp
6b68: e28d2020 add r2, sp, #32
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
6b6c: e58d3020 str r3, [sp, #32]
timeout.tv_nsec = 0;
6b70: e58da024 str sl, [sp, #36] ; 0x24
result = pthread_cond_timedwait (&aio_request_queue.new_req,
6b74: eb0001b4 bl 724c <pthread_cond_timedwait>
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
6b78: e3500074 cmp r0, #116 ; 0x74
6b7c: 0a000003 beq 6b90 <rtems_aio_handle+0x24c>
6b80: e59b5054 ldr r5, [fp, #84] ; 0x54 <== NOT EXECUTED
6b84: eaffffdc b 6afc <rtems_aio_handle+0x1b8> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
6b88: e594a014 ldr sl, [r4, #20] <== NOT EXECUTED
6b8c: eaffff91 b 69d8 <rtems_aio_handle+0x94> <== NOT EXECUTED
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
6b90: e59b3068 ldr r3, [fp, #104] ; 0x68
6b94: e2433001 sub r3, r3, #1
pthread_mutex_unlock (&aio_request_queue.mutex);
6b98: e1a0000b mov r0, fp
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
6b9c: e58b3068 str r3, [fp, #104] ; 0x68
pthread_mutex_unlock (&aio_request_queue.mutex);
6ba0: eb0002c6 bl 76c0 <pthread_mutex_unlock>
return NULL;
6ba4: eaffff94 b 69fc <rtems_aio_handle+0xb8>
0000671c <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
671c: e92d4070 push {r4, r5, r6, lr}
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
6720: e59f00e8 ldr r0, [pc, #232] ; 6810 <rtems_aio_init+0xf4>
6724: eb00042b bl 77d8 <pthread_attr_init>
if (result != 0)
6728: e2505000 subs r5, r0, #0
672c: 0a000001 beq 6738 <rtems_aio_init+0x1c>
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
return result;
}
6730: e1a00005 mov r0, r5 <== NOT EXECUTED
6734: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
result = pthread_attr_init (&aio_request_queue.attr);
if (result != 0)
return result;
result =
6738: e59f00d0 ldr r0, [pc, #208] ; 6810 <rtems_aio_init+0xf4>
673c: e1a01005 mov r1, r5
6740: eb000437 bl 7824 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
6744: e3500000 cmp r0, #0
6748: 1a00001c bne 67c0 <rtems_aio_init+0xa4>
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
674c: e59f40c0 ldr r4, [pc, #192] ; 6814 <rtems_aio_init+0xf8>
6750: e3a01000 mov r1, #0
6754: e1a00004 mov r0, r4
6758: eb000364 bl 74f0 <pthread_mutex_init>
if (result != 0)
675c: e3500000 cmp r0, #0
6760: 1a00001e bne 67e0 <rtems_aio_init+0xc4>
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
6764: e59f00ac ldr r0, [pc, #172] ; 6818 <rtems_aio_init+0xfc>
6768: e3a01000 mov r1, #0
676c: eb00026b bl 7120 <pthread_cond_init>
if (result != 0) {
6770: e2505000 subs r5, r0, #0
6774: 1a000020 bne 67fc <rtems_aio_init+0xe0>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
6778: e59f209c ldr r2, [pc, #156] ; 681c <rtems_aio_init+0x100>
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
677c: e3a01a0b mov r1, #45056 ; 0xb000
head->previous = NULL;
6780: e3a03000 mov r3, #0
tail->previous = head;
6784: e2820008 add r0, r2, #8
6788: e2426004 sub r6, r2, #4
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
678c: e282c00c add ip, r2, #12
6790: e281100b add r1, r1, #11
head->previous = NULL; tail->previous = head;
6794: e584005c str r0, [r4, #92] ; 0x5c
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
6798: e5842048 str r2, [r4, #72] ; 0x48
head->previous = NULL;
679c: e584304c str r3, [r4, #76] ; 0x4c
tail->previous = head;
67a0: e5846050 str r6, [r4, #80] ; 0x50
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
67a4: e584c054 str ip, [r4, #84] ; 0x54
head->previous = NULL;
67a8: e5843058 str r3, [r4, #88] ; 0x58
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
67ac: e5843064 str r3, [r4, #100] ; 0x64
aio_request_queue.idle_threads = 0;
67b0: e5843068 str r3, [r4, #104] ; 0x68
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
67b4: e5841060 str r1, [r4, #96] ; 0x60
return result;
}
67b8: e1a00005 mov r0, r5
67bc: e8bd8070 pop {r4, r5, r6, pc}
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
67c0: e59f404c ldr r4, [pc, #76] ; 6814 <rtems_aio_init+0xf8> <== NOT EXECUTED
result =
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
67c4: e59f0044 ldr r0, [pc, #68] ; 6810 <rtems_aio_init+0xf4> <== NOT EXECUTED
67c8: eb0003f9 bl 77b4 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
67cc: e3a01000 mov r1, #0 <== NOT EXECUTED
67d0: e1a00004 mov r0, r4 <== NOT EXECUTED
67d4: eb000345 bl 74f0 <pthread_mutex_init> <== NOT EXECUTED
if (result != 0)
67d8: e3500000 cmp r0, #0 <== NOT EXECUTED
67dc: 0affffe0 beq 6764 <rtems_aio_init+0x48> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
67e0: e2840008 add r0, r4, #8 <== NOT EXECUTED
67e4: eb0003f2 bl 77b4 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
67e8: e59f0028 ldr r0, [pc, #40] ; 6818 <rtems_aio_init+0xfc> <== NOT EXECUTED
67ec: e3a01000 mov r1, #0 <== NOT EXECUTED
67f0: eb00024a bl 7120 <pthread_cond_init> <== NOT EXECUTED
if (result != 0) {
67f4: e2505000 subs r5, r0, #0 <== NOT EXECUTED
67f8: 0affffde beq 6778 <rtems_aio_init+0x5c> <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
67fc: e59f0010 ldr r0, [pc, #16] ; 6814 <rtems_aio_init+0xf8> <== NOT EXECUTED
6800: eb0002ea bl 73b0 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
6804: e59f0004 ldr r0, [pc, #4] ; 6810 <rtems_aio_init+0xf4> <== NOT EXECUTED
6808: eb0003e9 bl 77b4 <pthread_attr_destroy> <== NOT EXECUTED
680c: eaffffd9 b 6778 <rtems_aio_init+0x5c> <== NOT EXECUTED
00006bb0 <rtems_aio_insert_prio>:
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
6bb0: e1a03000 mov r3, r0
6bb4: e4932004 ldr r2, [r3], #4
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
6bb8: e1520003 cmp r2, r3
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
6bbc: e1a0c001 mov ip, r1
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
6bc0: 0a00000f beq 6c04 <rtems_aio_insert_prio+0x54>
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
6bc4: e5910014 ldr r0, [r1, #20]
if (rtems_chain_is_empty (chain)) {
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
6bc8: e5921014 ldr r1, [r2, #20]
while (req->aiocbp->aio_reqprio > prio &&
6bcc: e5900014 ldr r0, [r0, #20]
6bd0: e5911014 ldr r1, [r1, #20]
6bd4: e1510000 cmp r1, r0
6bd8: ba000002 blt 6be8 <rtems_aio_insert_prio+0x38>
6bdc: ea000006 b 6bfc <rtems_aio_insert_prio+0x4c>
6be0: e1520003 cmp r2, r3 <== NOT EXECUTED
6be4: 0a000007 beq 6c08 <rtems_aio_insert_prio+0x58> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
6be8: e5922000 ldr r2, [r2] <== NOT EXECUTED
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
6bec: e5921014 ldr r1, [r2, #20] <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
6bf0: e5911014 ldr r1, [r1, #20] <== NOT EXECUTED
6bf4: e1510000 cmp r1, r0 <== NOT EXECUTED
6bf8: bafffff8 blt 6be0 <rtems_aio_insert_prio+0x30> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
6bfc: e5920004 ldr r0, [r2, #4]
6c00: e1a0100c mov r1, ip
6c04: ea00090f b 9048 <_Chain_Insert>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
6c08: e1a02003 mov r2, r3 <== NOT EXECUTED
6c0c: eafffffa b 6bfc <rtems_aio_insert_prio+0x4c> <== NOT EXECUTED
000068ec <rtems_aio_move_to_work>:
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
68ec: e59f204c ldr r2, [pc, #76] ; 6940 <rtems_aio_move_to_work+0x54>
68f0: e5923048 ldr r3, [r2, #72] ; 0x48
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
68f4: e590c014 ldr ip, [r0, #20]
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
68f8: e1a01000 mov r1, r0
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
68fc: e5930014 ldr r0, [r3, #20]
6900: e150000c cmp r0, ip
6904: aa000009 bge 6930 <rtems_aio_move_to_work+0x44>
6908: e282204c add r2, r2, #76 ; 0x4c
690c: e1530002 cmp r3, r2
6910: 1a000002 bne 6920 <rtems_aio_move_to_work+0x34>
6914: ea000005 b 6930 <rtems_aio_move_to_work+0x44> <== NOT EXECUTED
6918: e1530002 cmp r3, r2
691c: 0a000005 beq 6938 <rtems_aio_move_to_work+0x4c>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
6920: e5933000 ldr r3, [r3]
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
6924: e5930014 ldr r0, [r3, #20]
6928: e150000c cmp r0, ip
692c: bafffff9 blt 6918 <rtems_aio_move_to_work+0x2c>
6930: e5930004 ldr r0, [r3, #4]
6934: ea0009c3 b 9048 <_Chain_Insert>
6938: e1a03002 mov r3, r2 <== NOT EXECUTED
693c: eafffffb b 6930 <rtems_aio_move_to_work+0x44> <== NOT EXECUTED
00006c10 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
6c10: e92d41f0 push {r4, r5, r6, r7, r8, lr}
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
6c14: e5904008 ldr r4, [r0, #8]
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
6c18: e280600c add r6, r0, #12
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
6c1c: e1540006 cmp r4, r6
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
6c20: 13a0808c movne r8, #140 ; 0x8c
req->aiocbp->return_value = -1;
6c24: 13e07000 mvnne r7, #0
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
6c28: 1a000001 bne 6c34 <rtems_aio_remove_fd+0x24>
6c2c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
6c30: e1a04005 mov r4, r5
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
6c34: e1a00004 mov r0, r4
6c38: eb0008ed bl 8ff4 <_Chain_Extract>
req->aiocbp->error_code = ECANCELED;
6c3c: e5943014 ldr r3, [r4, #20]
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
6c40: e5945000 ldr r5, [r4]
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
6c44: e1a00004 mov r0, r4
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
6c48: e5838030 str r8, [r3, #48] ; 0x30
req->aiocbp->return_value = -1;
6c4c: e5837034 str r7, [r3, #52] ; 0x34
free (req);
6c50: ebfff0f4 bl 3028 <free>
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
6c54: e1550006 cmp r5, r6
6c58: 1afffff4 bne 6c30 <rtems_aio_remove_fd+0x20>
6c5c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
00006c60 <rtems_aio_remove_req>:
* AIO_NOTCANCELED - if request was not canceled
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
6c60: e92d4010 push {r4, lr}
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
6c64: e4903004 ldr r3, [r0], #4
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
6c68: e1530000 cmp r3, r0
return AIO_ALLDONE;
6c6c: 03a00002 moveq r0, #2
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
6c70: 1a000003 bne 6c84 <rtems_aio_remove_req+0x24>
6c74: e8bd8010 pop {r4, pc}
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
6c78: e5933000 ldr r3, [r3] <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
6c7c: e1530000 cmp r3, r0 <== NOT EXECUTED
6c80: 0a00000e beq 6cc0 <rtems_aio_remove_req+0x60> <== NOT EXECUTED
6c84: e5932014 ldr r2, [r3, #20]
6c88: e1520001 cmp r2, r1
return AIO_ALLDONE;
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
6c8c: e1a04003 mov r4, r3
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
6c90: 1afffff8 bne 6c78 <rtems_aio_remove_req+0x18>
6c94: e1a00003 mov r0, r3
6c98: eb0008d5 bl 8ff4 <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
6c9c: e5943014 ldr r3, [r4, #20]
6ca0: e3a0208c mov r2, #140 ; 0x8c
6ca4: e5832030 str r2, [r3, #48] ; 0x30
current->aiocbp->return_value = -1;
6ca8: e3e02000 mvn r2, #0
free (current);
6cac: e1a00004 mov r0, r4
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
current->aiocbp->return_value = -1;
6cb0: e5832034 str r2, [r3, #52] ; 0x34
free (current);
6cb4: ebfff0db bl 3028 <free>
}
return AIO_CANCELED;
6cb8: e3a00000 mov r0, #0
6cbc: e8bd8010 pop {r4, pc}
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
6cc0: e3a00001 mov r0, #1 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
6cc4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00002ed8 <rtems_assoc_ptr_by_name>:
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
2ed8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
2edc: e5904000 ldr r4, [r0]
2ee0: e3540000 cmp r4, #0
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
2ee4: e1a06000 mov r6, r0
2ee8: e1a07001 mov r7, r1
const rtems_assoc_t *default_ap = 0;
2eec: 01a06004 moveq r6, r4
if (rtems_assoc_is_default(ap))
2ef0: 0a000011 beq 2f3c <rtems_assoc_ptr_by_name+0x64>
2ef4: e1a00004 mov r0, r4
2ef8: e59f106c ldr r1, [pc, #108] ; 2f6c <rtems_assoc_ptr_by_name+0x94>
2efc: eb0032bc bl f9f4 <strcmp>
2f00: e3500000 cmp r0, #0
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
const rtems_assoc_t *default_ap = 0;
2f04: 13a08000 movne r8, #0
if (rtems_assoc_is_default(ap))
2f08: 0a00000d beq 2f44 <rtems_assoc_ptr_by_name+0x6c>
default_ap = ap++;
for ( ; ap->name; ap++)
2f0c: e1a05006 mov r5, r6
2f10: ea000003 b 2f24 <rtems_assoc_ptr_by_name+0x4c>
2f14: e595400c ldr r4, [r5, #12]
2f18: e3540000 cmp r4, #0
2f1c: e285500c add r5, r5, #12
2f20: 0a00000e beq 2f60 <rtems_assoc_ptr_by_name+0x88>
if (strcmp(ap->name, name) == 0)
2f24: e1a00004 mov r0, r4
2f28: e1a01007 mov r1, r7
2f2c: eb0032b0 bl f9f4 <strcmp>
2f30: e3500000 cmp r0, #0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
2f34: e1a06005 mov r6, r5
if (strcmp(ap->name, name) == 0)
2f38: 1afffff5 bne 2f14 <rtems_assoc_ptr_by_name+0x3c>
return ap;
return default_ap;
}
2f3c: e1a00006 mov r0, r6
2f40: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
2f44: e596400c ldr r4, [r6, #12]
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
2f48: e286300c add r3, r6, #12
for ( ; ap->name; ap++)
2f4c: e3540000 cmp r4, #0
2f50: 11a08006 movne r8, r6
2f54: 11a06003 movne r6, r3
2f58: 1affffeb bne 2f0c <rtems_assoc_ptr_by_name+0x34>
2f5c: eafffff6 b 2f3c <rtems_assoc_ptr_by_name+0x64> <== NOT EXECUTED
2f60: e1a06008 mov r6, r8
if (strcmp(ap->name, name) == 0)
return ap;
return default_ap;
}
2f64: e1a00006 mov r0, r6
2f68: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
00001ddc <rtems_bsp_cmdline_get_param>:
const char *rtems_bsp_cmdline_get_param(
const char *name,
char *value,
size_t length
)
{
1ddc: e92d4070 push {r4, r5, r6, lr}
const char *p;
if ( !name )
1de0: e2503000 subs r3, r0, #0
const char *rtems_bsp_cmdline_get_param(
const char *name,
char *value,
size_t length
)
{
1de4: e24dd008 sub sp, sp, #8
const char *p;
if ( !name )
return NULL;
1de8: 01a00003 moveq r0, r3
size_t length
)
{
const char *p;
if ( !name )
1dec: 1a000001 bne 1df8 <rtems_bsp_cmdline_get_param+0x1c>
return NULL;
copy_string( p, value, length );
return value;
}
1df0: e28dd008 add sp, sp, #8
1df4: e8bd8070 pop {r4, r5, r6, pc}
const char *p;
if ( !name )
return NULL;
if ( !value )
1df8: e3510000 cmp r1, #0
1dfc: 1a000001 bne 1e08 <rtems_bsp_cmdline_get_param+0x2c>
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
1e00: e1a00001 mov r0, r1
1e04: eafffff9 b 1df0 <rtems_bsp_cmdline_get_param+0x14>
return NULL;
if ( !value )
return NULL;
if ( !length )
1e08: e3520000 cmp r2, #0
return NULL;
1e0c: 01a00002 moveq r0, r2
return NULL;
if ( !value )
return NULL;
if ( !length )
1e10: 0afffff6 beq 1df0 <rtems_bsp_cmdline_get_param+0x14>
return NULL;
value[0] = '\0';
1e14: e3a04000 mov r4, #0
1e18: e5c14000 strb r4, [r1]
p = rtems_bsp_cmdline_get_param_raw( name );
1e1c: e58d1004 str r1, [sp, #4]
1e20: e58d2000 str r2, [sp]
1e24: eb00001e bl 1ea4 <rtems_bsp_cmdline_get_param_raw>
if ( !p )
1e28: e3500000 cmp r0, #0
1e2c: e59d1004 ldr r1, [sp, #4]
1e30: e59d2000 ldr r2, [sp]
1e34: 0affffed beq 1df0 <rtems_bsp_cmdline_get_param+0x14>
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
1e38: e5d0c000 ldrb ip, [r0]
1e3c: e15c0004 cmp ip, r4
1e40: 0affffee beq 1e00 <rtems_bsp_cmdline_get_param+0x24>
1e44: e2526001 subs r6, r2, #1
1e48: 11a03004 movne r3, r4
1e4c: 11a02004 movne r2, r4
if ( *p == '\"' ) {
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
break;
value[i++] = *p++;
value[i] = '\0';
1e50: 11a05004 movne r5, r4
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
1e54: 1a000003 bne 1e68 <rtems_bsp_cmdline_get_param+0x8c>
1e58: eaffffe8 b 1e00 <rtems_bsp_cmdline_get_param+0x24> <== NOT EXECUTED
1e5c: e1530006 cmp r3, r6
1e60: 2affffe6 bcs 1e00 <rtems_bsp_cmdline_get_param+0x24>
1e64: e1a04003 mov r4, r3
if ( *p == '\"' ) {
1e68: e35c0022 cmp ip, #34 ; 0x22
quotes++;
1e6c: 02822001 addeq r2, r2, #1
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
if ( *p == '\"' ) {
1e70: 0a000003 beq 1e84 <rtems_bsp_cmdline_get_param+0xa8>
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
1e74: e3120001 tst r2, #1
1e78: 1a000001 bne 1e84 <rtems_bsp_cmdline_get_param+0xa8>
1e7c: e35c0020 cmp ip, #32
1e80: 0affffde beq 1e00 <rtems_bsp_cmdline_get_param+0x24>
break;
value[i++] = *p++;
1e84: e2833001 add r3, r3, #1
1e88: e7c1c004 strb ip, [r1, r4]
value[i] = '\0';
1e8c: e7c15003 strb r5, [r1, r3]
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
1e90: e5f0c001 ldrb ip, [r0, #1]!
1e94: e35c0000 cmp ip, #0
1e98: 1affffef bne 1e5c <rtems_bsp_cmdline_get_param+0x80>
1e9c: e1a00001 mov r0, r1
1ea0: eaffffd2 b 1df0 <rtems_bsp_cmdline_get_param+0x14>
00002248 <rtems_filesystem_dirname>:
int rtems_filesystem_dirname(
const char *pathname
)
{
2248: e92d4030 push {r4, r5, lr}
224c: e1a05000 mov r5, r0
int len = strlen( pathname );
2250: eb00331d bl eecc <strlen>
while ( len ) {
2254: e2504000 subs r4, r0, #0
2258: 1a000002 bne 2268 <rtems_filesystem_dirname+0x20>
225c: ea000006 b 227c <rtems_filesystem_dirname+0x34> <== NOT EXECUTED
2260: e3540000 cmp r4, #0
2264: 0a000004 beq 227c <rtems_filesystem_dirname+0x34>
len--;
2268: e2444001 sub r4, r4, #1
if ( rtems_filesystem_is_separator( pathname[len] ) )
226c: e7d50004 ldrb r0, [r5, r4]
2270: eb0003de bl 31f0 <rtems_filesystem_is_separator>
2274: e3500000 cmp r0, #0
2278: 0afffff8 beq 2260 <rtems_filesystem_dirname+0x18>
break;
}
return len;
}
227c: e1a00004 mov r0, r4
2280: e8bd8030 pop {r4, r5, pc}
00002014 <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 )
{
2014: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_filesystem_umask = 022;
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
2018: e59f2104 ldr r2, [pc, #260] ; 2124 <rtems_filesystem_initialize+0x110>
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
201c: e59f6104 ldr r6, [pc, #260] ; 2128 <rtems_filesystem_initialize+0x114>
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
2020: e5922000 ldr r2, [r2]
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
2024: e5963000 ldr r3, [r6]
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
2028: e3520000 cmp r2, #0
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
202c: e3a02012 mov r2, #18
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
2030: e24dd018 sub sp, sp, #24
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
2034: e583202c str r2, [r3, #44] ; 0x2c
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
2038: 0a00002d beq 20f4 <rtems_filesystem_initialize+0xe0>
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
203c: e59f30e8 ldr r3, [pc, #232] ; 212c <rtems_filesystem_initialize+0x118>
2040: e5933000 ldr r3, [r3]
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
2044: e3a05000 mov r5, #0
2048: e2830008 add r0, r3, #8
204c: e8900003 ldm r0, {r0, r1}
2050: e893000c ldm r3, {r2, r3}
2054: e58d5000 str r5, [sp]
2058: eb000215 bl 28b4 <mount>
if ( status == -1 )
205c: e3700001 cmn r0, #1
2060: 0a00002b beq 2114 <rtems_filesystem_initialize+0x100>
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
2064: e5963000 ldr r3, [r6]
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
2068: e28d4004 add r4, sp, #4
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
206c: e1c353b0 strh r5, [r3, #48] ; 0x30
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
2070: e3a01001 mov r1, #1
2074: e1a03004 mov r3, r4
2078: e1a02005 mov r2, r5
207c: e59f00ac ldr r0, [pc, #172] ; 2130 <rtems_filesystem_initialize+0x11c>
rtems_filesystem_root = loc;
2080: e1a07004 mov r7, r4
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
2084: e58d5000 str r5, [sp]
2088: eb000058 bl 21f0 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
208c: e596c000 ldr ip, [r6]
2090: e8b7000f ldm r7!, {r0, r1, r2, r3}
2094: e28cc018 add ip, ip, #24
2098: e8ac000f stmia ip!, {r0, r1, r2, r3}
209c: e5973000 ldr r3, [r7]
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
20a0: e3a01001 mov r1, #1
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
20a4: e58c3000 str r3, [ip]
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
20a8: e1a02005 mov r2, r5
20ac: e1a03004 mov r3, r4
20b0: e59f0078 ldr r0, [pc, #120] ; 2130 <rtems_filesystem_initialize+0x11c>
20b4: e58d5000 str r5, [sp]
20b8: eb00004c bl 21f0 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
20bc: e596c000 ldr ip, [r6]
20c0: e8b4000f ldm r4!, {r0, r1, r2, r3}
20c4: e28cc004 add ip, ip, #4
20c8: e8ac000f stmia ip!, {r0, r1, r2, r3}
20cc: e5973000 ldr r3, [r7]
*
* 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);
20d0: e3a01f7f mov r1, #508 ; 0x1fc
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_current = loc;
20d4: e58c3000 str r3, [ip]
*
* 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);
20d8: e59f0054 ldr r0, [pc, #84] ; 2134 <rtems_filesystem_initialize+0x120>
20dc: e2811003 add r1, r1, #3
20e0: eb000198 bl 2748 <mkdir>
if ( status != 0 )
20e4: e3500000 cmp r0, #0
20e8: 1a000005 bne 2104 <rtems_filesystem_initialize+0xf0>
* 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.
*/
}
20ec: e28dd018 add sp, sp, #24
20f0: e8bd80f0 pop {r4, r5, r6, r7, pc}
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
20f4: e3a004ab mov r0, #-1426063360 ; 0xab000000 <== NOT EXECUTED
20f8: e28008cd add r0, r0, #13434880 ; 0xcd0000 <== NOT EXECUTED
20fc: e2800001 add r0, r0, #1 <== NOT EXECUTED
2100: eb000fe5 bl 609c <rtems_fatal_error_occurred> <== NOT EXECUTED
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
if ( status != 0 )
rtems_fatal_error_occurred( 0xABCD0003 );
2104: e3a004ab mov r0, #-1426063360 ; 0xab000000 <== NOT EXECUTED
2108: e28008cd add r0, r0, #13434880 ; 0xcd0000 <== NOT EXECUTED
210c: e2800003 add r0, r0, #3 <== NOT EXECUTED
2110: eb000fe1 bl 609c <rtems_fatal_error_occurred> <== NOT EXECUTED
mt = &rtems_filesystem_mount_table[0];
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
2114: e3a004ab mov r0, #-1426063360 ; 0xab000000
2118: e28008cd add r0, r0, #13434880 ; 0xcd0000
211c: e2800002 add r0, r0, #2
2120: eb000fdd bl 609c <rtems_fatal_error_occurred>
0000a914 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
a914: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
a918: e59f60ac ldr r6, [pc, #172] ; a9cc <rtems_filesystem_iterate+0xb8>
a91c: e5963000 ldr r3, [r6]
a920: e3530000 cmp r3, #0
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
a924: e1a04000 mov r4, r0
a928: e1a05001 mov r5, r1
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
a92c: 1a000003 bne a940 <rtems_filesystem_iterate+0x2c>
a930: ea00000c b a968 <rtems_filesystem_iterate+0x54> <== NOT EXECUTED
a934: e3500000 cmp r0, #0
a938: e2866008 add r6, r6, #8
a93c: 1a000020 bne a9c4 <rtems_filesystem_iterate+0xb0>
stop = (*routine)( table_entry, routine_arg );
a940: e1a00006 mov r0, r6
a944: e1a01005 mov r1, r5
a948: e1a0e00f mov lr, pc
a94c: e12fff14 bx r4
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
a950: e5963008 ldr r3, [r6, #8]
a954: e3530000 cmp r3, #0
stop = (*routine)( table_entry, routine_arg );
a958: e1a0a000 mov sl, r0
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
a95c: 1afffff4 bne a934 <rtems_filesystem_iterate+0x20>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
a960: e3500000 cmp r0, #0
a964: 1a000016 bne a9c4 <rtems_filesystem_iterate+0xb0>
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 );
a968: e59f7060 ldr r7, [pc, #96] ; a9d0 <rtems_filesystem_iterate+0xbc>
a96c: e3a01000 mov r1, #0
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
a970: e59f605c ldr r6, [pc, #92] ; a9d4 <rtems_filesystem_iterate+0xc0>
a974: e5970000 ldr r0, [r7]
a978: e1a02001 mov r2, r1
a97c: ebffec1e bl 59fc <rtems_semaphore_obtain>
a980: e4968004 ldr r8, [r6], #4
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
a984: e1580006 cmp r8, r6
a988: 03a0a000 moveq sl, #0
a98c: 1a000002 bne a99c <rtems_filesystem_iterate+0x88>
a990: ea000009 b a9bc <rtems_filesystem_iterate+0xa8>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
a994: e3500000 cmp r0, #0
a998: 1a000007 bne a9bc <rtems_filesystem_iterate+0xa8>
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
a99c: e2880008 add r0, r8, #8
a9a0: e1a01005 mov r1, r5
a9a4: e1a0e00f mov lr, pc
a9a8: e12fff14 bx r4
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
a9ac: e5988000 ldr r8, [r8]
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
a9b0: e1580006 cmp r8, r6
!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 );
a9b4: e1a0a000 mov sl, r0
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
a9b8: 1afffff5 bne a994 <rtems_filesystem_iterate+0x80>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
a9bc: e5970000 ldr r0, [r7]
a9c0: ebffec56 bl 5b20 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
return stop;
}
a9c4: e1a0000a mov r0, sl
a9c8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
0000283c <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
283c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
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 );
2840: e59f7064 ldr r7, [pc, #100] ; 28ac <rtems_filesystem_mount_iterate+0x70>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
2844: e59f4064 ldr r4, [pc, #100] ; 28b0 <rtems_filesystem_mount_iterate+0x74>
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
2848: e1a06001 mov r6, r1
284c: e3a01000 mov r1, #0
2850: e1a05000 mov r5, r0
2854: e1a02001 mov r2, r1
2858: e5970000 ldr r0, [r7]
285c: eb000c66 bl 59fc <rtems_semaphore_obtain>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
2860: e4948004 ldr r8, [r4], #4
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
2864: e1580004 cmp r8, r4
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
rtems_chain_node *node = NULL;
bool stop = false;
2868: 03a0a000 moveq sl, #0
rtems_libio_lock();
for (
286c: 1a000002 bne 287c <rtems_filesystem_mount_iterate+0x40>
2870: ea000009 b 289c <rtems_filesystem_mount_iterate+0x60> <== NOT EXECUTED
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
2874: e3500000 cmp r0, #0
2878: 1a000007 bne 289c <rtems_filesystem_mount_iterate+0x60>
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 );
287c: e1a00008 mov r0, r8
2880: e1a01006 mov r1, r6
2884: e1a0e00f mov lr, pc
2888: e12fff15 bx r5
}
rtems_libio_unlock();
return stop;
}
288c: e5988000 ldr r8, [r8]
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
2890: e1580004 cmp r8, r4
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 );
2894: e1a0a000 mov sl, r0
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
2898: 1afffff5 bne 2874 <rtems_filesystem_mount_iterate+0x38>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
289c: e5970000 ldr r0, [r7]
28a0: eb000c9e bl 5b20 <rtems_semaphore_release>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
28a4: e1a0000a mov r0, sl
28a8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
00002284 <rtems_filesystem_prefix_separators>:
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
2284: e92d4070 push {r4, r5, r6, lr}
2288: e1a05000 mov r5, r0
/* * Eat any separators at start of the path. */ int stripped = 0; while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
228c: e5d00000 ldrb r0, [r0]
2290: e3510000 cmp r1, #0
2294: 13500000 cmpne r0, #0
2298: 03a04000 moveq r4, #0
229c: 13a04001 movne r4, #1
22a0: e1a06001 mov r6, r1
)
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
22a4: 13a04000 movne r4, #0
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
22a8: 1a000005 bne 22c4 <rtems_filesystem_prefix_separators+0x40>
22ac: ea000007 b 22d0 <rtems_filesystem_prefix_separators+0x4c> <== NOT EXECUTED
22b0: e5f50001 ldrb r0, [r5, #1]!
{
pathname++;
pathnamelen--;
stripped++;
22b4: e2844001 add r4, r4, #1
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
22b8: e1560004 cmp r6, r4
22bc: 13500000 cmpne r0, #0
22c0: 0a000002 beq 22d0 <rtems_filesystem_prefix_separators+0x4c>
22c4: eb0003c9 bl 31f0 <rtems_filesystem_is_separator>
22c8: e3500000 cmp r0, #0
22cc: 1afffff7 bne 22b0 <rtems_filesystem_prefix_separators+0x2c>
pathname++;
pathnamelen--;
stripped++;
}
return stripped;
}
22d0: e1a00004 mov r0, r4
22d4: e8bd8070 pop {r4, r5, r6, pc}
00002ebc <rtems_gxx_key_create>:
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
2ebc: e92d4070 push {r4, r5, r6, lr}
2ec0: e1a06000 mov r6, r0
* pointer to the buffer that will hold the value of the key itself. * We have to to this, because the others functions on this interface * deal with the value of the key, as used with the POSIX API. */ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
2ec4: e3a00008 mov r0, #8
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
2ec8: e1a05001 mov r5, r1
* pointer to the buffer that will hold the value of the key itself. * We have to to this, because the others functions on this interface * deal with the value of the key, as used with the POSIX API. */ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
2ecc: eb000107 bl 32f0 <malloc>
*key = new_key; new_key->val = NULL;
2ed0: e3a03000 mov r3, #0
* pointer to the buffer that will hold the value of the key itself. * We have to to this, because the others functions on this interface * deal with the value of the key, as used with the POSIX API. */ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
2ed4: e1a04000 mov r4, r0
*key = new_key;
2ed8: e5860000 str r0, [r6]
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
2edc: e1a01004 mov r1, r4
2ee0: e1a00003 mov r0, r3
2ee4: e1a02005 mov r2, r5
* deal with the value of the key, as used with the POSIX API. */ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) ); *key = new_key; new_key->val = NULL;
2ee8: e8840028 stm r4, {r3, r5}
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
2eec: eb000f66 bl 6c8c <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL )
2ef0: e3500000 cmp r0, #0
2ef4: 08bd8070 popeq {r4, r5, r6, pc}
return 0;
free( new_key );
2ef8: e1a00004 mov r0, r4 <== NOT EXECUTED
2efc: ebffff87 bl 2d20 <free> <== NOT EXECUTED
return -1;
2f00: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
2f04: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00002e3c <rtems_gxx_once>:
/* uncomment this if you need to debug this interface */
/*#define DEBUG_GXX_WRAPPERS 1*/
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))
{
2e3c: e92d4070 push {r4, r5, r6, lr}
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
2e40: e5903000 ldr r3, [r0]
2e44: e3530000 cmp r3, #0
/* uncomment this if you need to debug this interface */
/*#define DEBUG_GXX_WRAPPERS 1*/
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))
{
2e48: e24dd004 sub sp, sp, #4
2e4c: e1a04000 mov r4, r0
2e50: e1a05001 mov r5, r1
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
2e54: 0a000002 beq 2e64 <rtems_gxx_once+0x28>
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
if ( o == 0 )
(*func)();
}
return 0;
}
2e58: e3a00000 mov r0, #0
2e5c: e28dd004 add sp, sp, #4
2e60: e8bd8070 pop {r4, r5, r6, pc}
if ( *(volatile __gthread_once_t *)once == 0 ) {
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
2e64: e3a00c01 mov r0, #256 ; 0x100
2e68: e1a01000 mov r1, r0
2e6c: e1a0200d mov r2, sp
2e70: eb000f0e bl 6ab0 <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
2e74: e5943000 ldr r3, [r4]
2e78: e3530000 cmp r3, #0
if ( *(volatile __gthread_once_t *)once == 0 ) {
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
2e7c: e1a0600d mov r6, sp
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
2e80: 1a000008 bne 2ea8 <rtems_gxx_once+0x6c>
*(volatile __gthread_once_t *)once = 1;
2e84: e3a03001 mov r3, #1
2e88: e5843000 str r3, [r4]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2e8c: e3a01c01 mov r1, #256 ; 0x100
2e90: e1a0200d mov r2, sp
2e94: e59d0000 ldr r0, [sp]
2e98: eb000f04 bl 6ab0 <rtems_task_mode>
if ( o == 0 )
(*func)();
2e9c: e1a0e00f mov lr, pc
2ea0: e12fff15 bx r5
2ea4: eaffffeb b 2e58 <rtems_gxx_once+0x1c>
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
*(volatile __gthread_once_t *)once = 1;
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2ea8: e59d0000 ldr r0, [sp] <== NOT EXECUTED
2eac: e3a01c01 mov r1, #256 ; 0x100 <== NOT EXECUTED
2eb0: e1a0200d mov r2, sp <== NOT EXECUTED
2eb4: eb000efd bl 6ab0 <rtems_task_mode> <== NOT EXECUTED
2eb8: eaffffe6 b 2e58 <rtems_gxx_once+0x1c> <== NOT EXECUTED
000073c0 <rtems_io_register_driver>:
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
73c0: e59f3150 ldr r3, [pc, #336] ; 7518 <rtems_io_register_driver+0x158>
73c4: e593c000 ldr ip, [r3]
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
73c8: e59f314c ldr r3, [pc, #332] ; 751c <rtems_io_register_driver+0x15c>
if ( rtems_interrupt_is_in_progress() )
73cc: e35c0000 cmp ip, #0
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
73d0: e92d4030 push {r4, r5, lr}
73d4: e1a04000 mov r4, r0
rtems_device_major_number major_limit = _IO_Number_of_drivers;
73d8: e5930000 ldr r0, [r3]
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
73dc: 13a00012 movne r0, #18
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
73e0: 18bd8030 popne {r4, r5, pc}
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
73e4: e3520000 cmp r2, #0
73e8: 0a00003f beq 74ec <rtems_io_register_driver+0x12c>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
73ec: e3510000 cmp r1, #0
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
73f0: e5820000 str r0, [r2]
if ( driver_table == NULL )
73f4: 0a00003c beq 74ec <rtems_io_register_driver+0x12c>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
73f8: e591c000 ldr ip, [r1]
73fc: e35c0000 cmp ip, #0
7400: 0a000036 beq 74e0 <rtems_io_register_driver+0x120>
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
7404: e1500004 cmp r0, r4
7408: 9a000027 bls 74ac <rtems_io_register_driver+0xec>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
740c: e59f010c ldr r0, [pc, #268] ; 7520 <rtems_io_register_driver+0x160>
7410: e590c000 ldr ip, [r0]
7414: e28cc001 add ip, ip, #1
7418: e580c000 str ip, [r0]
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
741c: e3540000 cmp r4, #0
7420: 1a000023 bne 74b4 <rtems_io_register_driver+0xf4>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
7424: e593c000 ldr ip, [r3]
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
7428: e35c0000 cmp ip, #0
742c: 0a000030 beq 74f4 <rtems_io_register_driver+0x134>
7430: e59fe0ec ldr lr, [pc, #236] ; 7524 <rtems_io_register_driver+0x164>
7434: e59e3000 ldr r3, [lr]
7438: ea000003 b 744c <rtems_io_register_driver+0x8c>
743c: e2844001 add r4, r4, #1
7440: e15c0004 cmp ip, r4
7444: e2833018 add r3, r3, #24
7448: 9a000005 bls 7464 <rtems_io_register_driver+0xa4>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
744c: e5930000 ldr r0, [r3]
7450: e3500000 cmp r0, #0
7454: 1afffff8 bne 743c <rtems_io_register_driver+0x7c>
7458: e5930004 ldr r0, [r3, #4]
745c: e3500000 cmp r0, #0
7460: 1afffff5 bne 743c <rtems_io_register_driver+0x7c>
}
/* Assigns invalid value in case of failure */
*major = m;
if ( m != n )
7464: e15c0004 cmp ip, r4
7468: 1084c084 addne ip, r4, r4, lsl #1
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
746c: e5824000 str r4, [r2]
if ( m != n )
7470: 11a0c18c lslne ip, ip, #3
7474: 0a00001f beq 74f8 <rtems_io_register_driver+0x138>
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
7478: e59e5000 ldr r5, [lr]
747c: e1a0e001 mov lr, r1
7480: e8be000f ldm lr!, {r0, r1, r2, r3}
7484: e085c00c add ip, r5, ip
7488: e8ac000f stmia ip!, {r0, r1, r2, r3}
748c: e89e0003 ldm lr, {r0, r1}
7490: e88c0003 stm ip, {r0, r1}
_Thread_Enable_dispatch();
7494: eb0007a8 bl 933c <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
7498: e3a01000 mov r1, #0
749c: e1a00004 mov r0, r4
74a0: e1a02001 mov r2, r1
}
74a4: e8bd4030 pop {r4, r5, lr}
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
74a8: ea00216f b fa6c <rtems_io_initialize>
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
74ac: e3a0000a mov r0, #10
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
74b0: e8bd8030 pop {r4, r5, pc}
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
74b4: e59fe068 ldr lr, [pc, #104] ; 7524 <rtems_io_register_driver+0x164>
74b8: e084c084 add ip, r4, r4, lsl #1
74bc: e59e3000 ldr r3, [lr]
74c0: e1a0c18c lsl ip, ip, #3
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
74c4: e793000c ldr r0, [r3, ip]
74c8: e3500000 cmp r0, #0
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
74cc: e083300c add r3, r3, ip
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
74d0: 0a00000b beq 7504 <rtems_io_register_driver+0x144>
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
74d4: eb000798 bl 933c <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
74d8: e3a0000c mov r0, #12
74dc: e8bd8030 pop {r4, r5, pc}
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
74e0: e591c004 ldr ip, [r1, #4]
74e4: e35c0000 cmp ip, #0
74e8: 1affffc5 bne 7404 <rtems_io_register_driver+0x44>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
74ec: e3a00009 mov r0, #9
74f0: e8bd8030 pop {r4, r5, pc}
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
74f4: e5824000 str r4, [r2] <== NOT EXECUTED
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
74f8: eb00078f bl 933c <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
74fc: e3a00005 mov r0, #5
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
return sc;
7500: e8bd8030 pop {r4, r5, pc}
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
7504: e5933004 ldr r3, [r3, #4]
7508: e3530000 cmp r3, #0
750c: 1afffff0 bne 74d4 <rtems_io_register_driver+0x114>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
7510: e5824000 str r4, [r2]
7514: eaffffd7 b 7478 <rtems_io_register_driver+0xb8>
00002408 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
2408: e92d4010 push {r4, lr}
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
240c: e59f30b8 ldr r3, [pc, #184] ; 24cc <rtems_libio_init+0xc4>
2410: e5934000 ldr r4, [r3]
2414: e3540000 cmp r4, #0
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
2418: e24dd004 sub sp, sp, #4
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
241c: 0a000017 beq 2480 <rtems_libio_init+0x78>
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
2420: e1a00004 mov r0, r4
2424: e3a01038 mov r1, #56 ; 0x38
2428: ebffff42 bl 2138 <calloc>
242c: e59f309c ldr r3, [pc, #156] ; 24d0 <rtems_libio_init+0xc8>
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
2430: e3500000 cmp r0, #0
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
2434: e1a02000 mov r2, r0
2438: e5830000 str r0, [r3]
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
243c: 0a000020 beq 24c4 <rtems_libio_init+0xbc>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
2440: e59f308c ldr r3, [pc, #140] ; 24d4 <rtems_libio_init+0xcc>
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
2444: e3540001 cmp r4, #1
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
2448: e5830000 str r0, [r3]
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
244c: 9a000009 bls 2478 <rtems_libio_init+0x70>
* rtems_libio_init
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
2450: e2803038 add r3, r0, #56 ; 0x38
2454: e3a02001 mov r2, #1
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++)
iop->data1 = iop + 1;
2458: e2822001 add r2, r2, #1
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++)
245c: e1520004 cmp r2, r4
iop->data1 = iop + 1;
2460: e5033004 str r3, [r3, #-4]
2464: e2833038 add r3, r3, #56 ; 0x38
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++)
2468: 1afffffa bne 2458 <rtems_libio_init+0x50>
* rtems_libio_init
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
246c: e2422001 sub r2, r2, #1
2470: e0622182 rsb r2, r2, r2, lsl #3
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++)
2474: e0802182 add r2, r0, r2, lsl #3
iop->data1 = iop + 1;
iop->data1 = NULL;
2478: e3a03000 mov r3, #0
247c: e5823034 str r3, [r2, #52] ; 0x34
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
2480: e59fc050 ldr ip, [pc, #80] ; 24d8 <rtems_libio_init+0xd0>
2484: e59f0050 ldr r0, [pc, #80] ; 24dc <rtems_libio_init+0xd4>
2488: e3a01001 mov r1, #1
248c: e3a02054 mov r2, #84 ; 0x54
2490: e3a03000 mov r3, #0
2494: e58dc000 str ip, [sp]
2498: eb000cbd bl 5794 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
249c: e3500000 cmp r0, #0
24a0: 1a000006 bne 24c0 <rtems_libio_init+0xb8>
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
24a4: e59f3034 ldr r3, [pc, #52] ; 24e0 <rtems_libio_init+0xd8>
24a8: e5933000 ldr r3, [r3]
24ac: e3530000 cmp r3, #0
(* rtems_fs_init_helper)();
24b0: 11a0e00f movne lr, pc
24b4: 112fff13 bxne r3
}
24b8: e28dd004 add sp, sp, #4
24bc: e8bd8010 pop {r4, pc}
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
rtems_fatal_error_occurred( rc );
24c0: eb000ef5 bl 609c <rtems_fatal_error_occurred> <== NOT EXECUTED
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
24c4: e280001a add r0, r0, #26
24c8: eb000ef3 bl 609c <rtems_fatal_error_occurred>
0000a604 <rtems_libio_to_fcntl_flags>:
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
a604: e2002006 and r2, r0, #6
a608: e3520006 cmp r2, #6
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
a60c: e1a03000 mov r3, r0
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
a610: 03a00002 moveq r0, #2
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
a614: 0a000002 beq a624 <rtems_libio_to_fcntl_flags+0x20>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
a618: e3130002 tst r3, #2
fcntl_flags |= O_RDONLY;
a61c: 13a00000 movne r0, #0
{
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) {
a620: 0a000006 beq a640 <rtems_libio_to_fcntl_flags+0x3c>
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 ) {
a624: e3130001 tst r3, #1
fcntl_flags |= O_NONBLOCK;
a628: 13800901 orrne r0, r0, #16384 ; 0x4000
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
a62c: e3130c02 tst r3, #512 ; 0x200
fcntl_flags |= O_APPEND;
a630: 13800008 orrne r0, r0, #8
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
a634: e3130b01 tst r3, #1024 ; 0x400
fcntl_flags |= O_CREAT;
a638: 13800c02 orrne r0, r0, #512 ; 0x200
}
return fcntl_flags;
}
a63c: e12fff1e bx lr
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
a640: e3130004 tst r3, #4 <== NOT EXECUTED
a644: 03a00000 moveq r0, #0 <== NOT EXECUTED
a648: 13a00001 movne r0, #1 <== NOT EXECUTED
a64c: eafffff4 b a624 <rtems_libio_to_fcntl_flags+0x20> <== NOT EXECUTED
00005d04 <rtems_object_get_api_class_name>:
)
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
5d04: e3500001 cmp r0, #1
const char *rtems_object_get_api_class_name(
int the_api,
int the_class
)
{
5d08: e52de004 push {lr} ; (str lr, [sp, #-4]!)
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
5d0c: 0a00000d beq 5d48 <rtems_object_get_api_class_name+0x44>
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
5d10: e3500002 cmp r0, #2
5d14: 0a000004 beq 5d2c <rtems_object_get_api_class_name+0x28>
api_assoc = rtems_object_api_classic_assoc;
#ifdef RTEMS_POSIX_API
else if ( the_api == OBJECTS_POSIX_API )
5d18: e3500003 cmp r0, #3
api_assoc = rtems_object_api_posix_assoc;
5d1c: 059f003c ldreq r0, [pc, #60] ; 5d60 <rtems_object_get_api_class_name+0x5c>
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
api_assoc = rtems_object_api_classic_assoc;
#ifdef RTEMS_POSIX_API
else if ( the_api == OBJECTS_POSIX_API )
5d20: 0a000002 beq 5d30 <rtems_object_get_api_class_name+0x2c>
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
5d24: e59f0038 ldr r0, [pc, #56] ; 5d64 <rtems_object_get_api_class_name+0x60>
5d28: e49df004 pop {pc} ; (ldr pc, [sp], #4)
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
api_assoc = rtems_object_api_classic_assoc;
5d2c: e59f0034 ldr r0, [pc, #52] ; 5d68 <rtems_object_get_api_class_name+0x64>
else if ( the_api == OBJECTS_POSIX_API )
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
5d30: eb0013a9 bl abdc <rtems_assoc_ptr_by_local>
if ( class_assoc )
5d34: e3500000 cmp r0, #0
return class_assoc->name;
5d38: 15900000 ldrne r0, [r0]
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
if ( class_assoc )
5d3c: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
return class_assoc->name;
return "BAD CLASS";
5d40: e59f0024 ldr r0, [pc, #36] ; 5d6c <rtems_object_get_api_class_name+0x68>
}
5d44: e49df004 pop {pc} ; (ldr pc, [sp], #4)
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
5d48: e59f0020 ldr r0, [pc, #32] ; 5d70 <rtems_object_get_api_class_name+0x6c>
else if ( the_api == OBJECTS_POSIX_API )
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
5d4c: eb0013a2 bl abdc <rtems_assoc_ptr_by_local>
if ( class_assoc )
5d50: e3500000 cmp r0, #0
return class_assoc->name;
5d54: 15900000 ldrne r0, [r0]
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
if ( class_assoc )
5d58: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
5d5c: eafffff7 b 5d40 <rtems_object_get_api_class_name+0x3c> <== NOT EXECUTED
00001994 <rtems_print_buffer>:
void rtems_print_buffer(
const unsigned char *buffer,
int length
)
{
1994: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int i, mod, max;
if ( !length ) return;
1998: e3510000 cmp r1, #0
void rtems_print_buffer(
const unsigned char *buffer,
int length
)
{
199c: e24dd078 sub sp, sp, #120 ; 0x78
19a0: e1a0b000 mov fp, r0
int i, mod, max;
if ( !length ) return;
19a4: 0a000037 beq 1a88 <rtems_print_buffer+0xf4>
mod = length % 16;
19a8: e1a03fc1 asr r3, r1, #31
19ac: e1a03e23 lsr r3, r3, #28
19b0: e081a003 add sl, r1, r3
19b4: e20aa00f and sl, sl, #15
19b8: e063a00a rsb sl, r3, sl
max = length - mod;
19bc: e06a9001 rsb r9, sl, r1
for ( i=0 ; i<max ; i+=16 )
19c0: e3590000 cmp r9, #0
19c4: da00002d ble 1a80 <rtems_print_buffer+0xec>
19c8: e59f71f4 ldr r7, [pc, #500] ; 1bc4 <rtems_print_buffer+0x230>
19cc: e3a08000 mov r8, #0
19d0: e1a0400d mov r4, sp
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
19d4: e3a03000 mov r3, #0
19d8: e5cd3000 strb r3, [sp]
static inline void Dump_Line(
const unsigned char *buffer,
int length
);
void rtems_print_buffer(
19dc: e08b6008 add r6, fp, r8
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
19e0: e3a05000 mov r5, #0
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
19e4: e7d63005 ldrb r3, [r6, r5]
19e8: e1a0000d mov r0, sp
19ec: e59f11d4 ldr r1, [pc, #468] ; 1bc8 <rtems_print_buffer+0x234>
19f0: e1a0200d mov r2, sp
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
19f4: e2855001 add r5, r5, #1
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
19f8: eb00345f bl eb7c <sprintf>
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
19fc: e3550010 cmp r5, #16
1a00: 1afffff7 bne 19e4 <rtems_print_buffer+0x50>
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
1a04: e1a0000d mov r0, sp
1a08: eb003592 bl f058 <strlen>
1a0c: e59f11b8 ldr r1, [pc, #440] ; 1bcc <rtems_print_buffer+0x238>
1a10: e0840000 add r0, r4, r0
1a14: e3a02002 mov r2, #2
1a18: eb0033c6 bl e938 <memcpy>
for( i=0 ; i<length ; i++ )
1a1c: e3a05000 mov r5, #0
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
1a20: e7d63005 ldrb r3, [r6, r5]
1a24: e5972000 ldr r2, [r7]
1a28: e0822003 add r2, r2, r3
1a2c: e5d22001 ldrb r2, [r2, #1]
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
1a30: e3120097 tst r2, #151 ; 0x97
1a34: 03a0302e moveq r3, #46 ; 0x2e
1a38: e1a0000d mov r0, sp
1a3c: e59f118c ldr r1, [pc, #396] ; 1bd0 <rtems_print_buffer+0x23c>
1a40: e1a0200d mov r2, sp
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
1a44: e2855001 add r5, r5, #1
sprintf( line_buffer, "%s%c", line_buffer,
1a48: eb00344b bl eb7c <sprintf>
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
1a4c: e3550010 cmp r5, #16
1a50: 1afffff2 bne 1a20 <rtems_print_buffer+0x8c>
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
1a54: e1a0000d mov r0, sp
1a58: eb00357e bl f058 <strlen>
1a5c: e59f1170 ldr r1, [pc, #368] ; 1bd4 <rtems_print_buffer+0x240>
1a60: e3a02003 mov r2, #3
1a64: e0840000 add r0, r4, r0
1a68: eb0033b2 bl e938 <memcpy>
mod = length % 16;
max = length - mod;
for ( i=0 ; i<max ; i+=16 )
1a6c: e2888010 add r8, r8, #16
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
printk( line_buffer );
1a70: e1a0000d mov r0, sp
1a74: eb000646 bl 3394 <printk>
mod = length % 16;
max = length - mod;
for ( i=0 ; i<max ; i+=16 )
1a78: e1590008 cmp r9, r8
1a7c: caffffd4 bgt 19d4 <rtems_print_buffer+0x40>
Dump_Line( &buffer[ i ], 16 );
if ( mod )
1a80: e35a0000 cmp sl, #0
1a84: 1a000001 bne 1a90 <rtems_print_buffer+0xfc>
Dump_Line( &buffer[ max ], mod );
}
1a88: e28dd078 add sp, sp, #120 ; 0x78
1a8c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
1a90: e3a05000 mov r5, #0
for ( i=0 ; i<max ; i+=16 )
Dump_Line( &buffer[ i ], 16 );
if ( mod )
Dump_Line( &buffer[ max ], mod );
1a94: e08b9009 add r9, fp, r9
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
1a98: e5cd5000 strb r5, [sp]
1a9c: d1a0400d movle r4, sp
for( i=0 ; i<length ; i++ )
1aa0: da00000b ble 1ad4 <rtems_print_buffer+0x140>
1aa4: e1a0400d mov r4, sp
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
1aa8: e7d93005 ldrb r3, [r9, r5]
1aac: e1a0000d mov r0, sp
1ab0: e59f1110 ldr r1, [pc, #272] ; 1bc8 <rtems_print_buffer+0x234>
1ab4: e1a0200d mov r2, sp
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
1ab8: e2855001 add r5, r5, #1
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
1abc: eb00342e bl eb7c <sprintf>
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
1ac0: e15a0005 cmp sl, r5
1ac4: cafffff7 bgt 1aa8 <rtems_print_buffer+0x114>
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
1ac8: e35a000f cmp sl, #15
1acc: d1a0500a movle r5, sl
1ad0: ca000034 bgt 1ba8 <rtems_print_buffer+0x214>
strcat( line_buffer, " " );
1ad4: e1a0000d mov r0, sp
1ad8: eb00355e bl f058 <strlen>
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
1adc: e2855001 add r5, r5, #1
strcat( line_buffer, " " );
1ae0: e59f10f0 ldr r1, [pc, #240] ; 1bd8 <rtems_print_buffer+0x244>
1ae4: e0840000 add r0, r4, r0
1ae8: e3a02004 mov r2, #4
1aec: eb003391 bl e938 <memcpy>
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
1af0: e355000f cmp r5, #15
1af4: dafffff6 ble 1ad4 <rtems_print_buffer+0x140>
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
1af8: e1a0000d mov r0, sp
1afc: eb003555 bl f058 <strlen>
1b00: e59f10c4 ldr r1, [pc, #196] ; 1bcc <rtems_print_buffer+0x238>
1b04: e0840000 add r0, r4, r0
1b08: e3a02002 mov r2, #2
1b0c: eb003389 bl e938 <memcpy>
for( i=0 ; i<length ; i++ )
1b10: e35a0000 cmp sl, #0
1b14: d3a0a000 movle sl, #0
1b18: da000010 ble 1b60 <rtems_print_buffer+0x1cc>
1b1c: e59f70a0 ldr r7, [pc, #160] ; 1bc4 <rtems_print_buffer+0x230>
1b20: e3a05000 mov r5, #0
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
1b24: e7d93005 ldrb r3, [r9, r5]
1b28: e5972000 ldr r2, [r7]
1b2c: e0822003 add r2, r2, r3
1b30: e5d22001 ldrb r2, [r2, #1]
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
1b34: e3120097 tst r2, #151 ; 0x97
1b38: 03a0302e moveq r3, #46 ; 0x2e
1b3c: e1a0000d mov r0, sp
1b40: e59f1088 ldr r1, [pc, #136] ; 1bd0 <rtems_print_buffer+0x23c>
1b44: e1a0200d mov r2, sp
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
1b48: e2855001 add r5, r5, #1
sprintf( line_buffer, "%s%c", line_buffer,
1b4c: eb00340a bl eb7c <sprintf>
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
1b50: e15a0005 cmp sl, r5
1b54: cafffff2 bgt 1b24 <rtems_print_buffer+0x190>
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
1b58: e35a000f cmp sl, #15
1b5c: ca000008 bgt 1b84 <rtems_print_buffer+0x1f0>
strcat( line_buffer, " " );
1b60: e1a0000d mov r0, sp
1b64: eb00353b bl f058 <strlen>
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
1b68: e28aa001 add sl, sl, #1
strcat( line_buffer, " " );
1b6c: e59f1068 ldr r1, [pc, #104] ; 1bdc <rtems_print_buffer+0x248>
1b70: e0840000 add r0, r4, r0
1b74: e3a02002 mov r2, #2
1b78: eb00336e bl e938 <memcpy>
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
1b7c: e35a000f cmp sl, #15
1b80: dafffff6 ble 1b60 <rtems_print_buffer+0x1cc>
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
1b84: e1a0000d mov r0, sp
1b88: eb003532 bl f058 <strlen>
1b8c: e59f1040 ldr r1, [pc, #64] ; 1bd4 <rtems_print_buffer+0x240>
1b90: e0840000 add r0, r4, r0
1b94: e3a02003 mov r2, #3
1b98: eb003366 bl e938 <memcpy>
printk( line_buffer );
1b9c: e1a0000d mov r0, sp
1ba0: eb0005fb bl 3394 <printk>
1ba4: eaffffb7 b 1a88 <rtems_print_buffer+0xf4>
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
1ba8: e1a0000d mov r0, sp <== NOT EXECUTED
1bac: eb003529 bl f058 <strlen> <== NOT EXECUTED
1bb0: e59f1014 ldr r1, [pc, #20] ; 1bcc <rtems_print_buffer+0x238><== NOT EXECUTED
1bb4: e0840000 add r0, r4, r0 <== NOT EXECUTED
1bb8: e3a02002 mov r2, #2 <== NOT EXECUTED
1bbc: eb00335d bl e938 <memcpy> <== NOT EXECUTED
1bc0: eaffffd5 b 1b1c <rtems_print_buffer+0x188> <== NOT EXECUTED
00002560 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
2560: e92d4830 push {r4, r5, fp, lr}
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
2564: e59f4074 ldr r4, [pc, #116] ; 25e0 <rtems_stack_checker_is_blown+0x80>
2568: e5943004 ldr r3, [r4, #4]
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
256c: e59300bc ldr r0, [r3, #188] ; 0xbc
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
2570: e28db00c add fp, sp, #12
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
2574: e15b0000 cmp fp, r0
return false;
2578: 33a05000 movcc r5, #0
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
257c: 3a000004 bcc 2594 <rtems_stack_checker_is_blown+0x34>
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
2580: e59350b8 ldr r5, [r3, #184] ; 0xb8
2584: e0805005 add r5, r0, r5
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
2588: e15b0005 cmp fp, r5
258c: 83a05000 movhi r5, #0
2590: 93a05001 movls r5, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
2594: e59f3048 ldr r3, [pc, #72] ; 25e4 <rtems_stack_checker_is_blown+0x84>
2598: e5933008 ldr r3, [r3, #8]
259c: e3530000 cmp r3, #0
*/
bool rtems_stack_checker_is_blown( void )
{
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
bool sp_ok;
bool pattern_ok = true;
25a0: 03a01001 moveq r1, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
25a4: 0a000005 beq 25c0 <rtems_stack_checker_is_blown+0x60>
pattern_ok = (!memcmp(
25a8: e59f1038 ldr r1, [pc, #56] ; 25e8 <rtems_stack_checker_is_blown+0x88>
25ac: e2800008 add r0, r0, #8
25b0: e3a02010 mov r2, #16
25b4: eb003ba9 bl 11460 <memcmp>
25b8: e2701001 rsbs r1, r0, #1
25bc: 33a01000 movcc r1, #0
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
25c0: e3550000 cmp r5, #0
25c4: 0a000003 beq 25d8 <rtems_stack_checker_is_blown+0x78>
25c8: e3510000 cmp r1, #0
25cc: 0a000001 beq 25d8 <rtems_stack_checker_is_blown+0x78>
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
25d0: e3a00000 mov r0, #0
25d4: e8bd8830 pop {r4, r5, fp, pc}
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
25d8: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED
25dc: ebffff98 bl 2444 <Stack_check_report_blown_task> <== NOT EXECUTED
000024f8 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
24f8: e92d4810 push {r4, fp, lr}
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = Stack_check_Get_pattern_area(the_stack);
24fc: e59030bc ldr r3, [r0, #188] ; 0xbc
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
2500: e28db008 add fp, sp, #8
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
2504: e15b0003 cmp fp, r3
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
2508: e1a04000 mov r4, r0
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = Stack_check_Get_pattern_area(the_stack);
250c: e2830008 add r0, r3, #8
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
2510: 3a000003 bcc 2524 <rtems_stack_checker_switch_extension+0x2c>
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
2514: e59420b8 ldr r2, [r4, #184] ; 0xb8
2518: e0833002 add r3, r3, r2
251c: e15b0003 cmp fp, r3
2520: 9a000006 bls 2540 <rtems_stack_checker_switch_extension+0x48>
/*
* 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,
2524: e59f1030 ldr r1, [pc, #48] ; 255c <rtems_stack_checker_switch_extension+0x64><== NOT EXECUTED
2528: e3a02010 mov r2, #16 <== NOT EXECUTED
252c: eb003bcb bl 11460 <memcmp> <== NOT EXECUTED
2530: e2701001 rsbs r1, r0, #1 <== NOT EXECUTED
2534: 33a01000 movcc r1, #0 <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( running, pattern_ok );
2538: e1a00004 mov r0, r4
253c: ebffffc0 bl 2444 <Stack_check_report_blown_task>
/*
* 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,
2540: e59f1014 ldr r1, [pc, #20] ; 255c <rtems_stack_checker_switch_extension+0x64>
2544: e3a02010 mov r2, #16
2548: eb003bc4 bl 11460 <memcmp>
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
254c: e3500000 cmp r0, #0
2550: 08bd8810 popeq {r4, fp, pc}
2554: e3a01000 mov r1, #0
2558: eafffff6 b 2538 <rtems_stack_checker_switch_extension+0x40>
0000c054 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
c054: e92d41f0 push {r4, r5, r6, r7, r8, lr}
double result;
char *end;
if ( !n )
c058: e2514000 subs r4, r1, #0
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
c05c: e1a07000 mov r7, r0
c060: e24dd004 sub sp, sp, #4
c064: e1a08002 mov r8, r2
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
c068: 03a00009 moveq r0, #9
)
{
double result;
char *end;
if ( !n )
c06c: 0a000017 beq c0d0 <rtems_string_to_double+0x7c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
c070: eb000c6e bl f230 <__errno>
c074: e3a03000 mov r3, #0
c078: e5803000 str r3, [r0]
*n = 0;
c07c: e3a02000 mov r2, #0
c080: e3a03000 mov r3, #0
c084: e884000c stm r4, {r2, r3}
result = strtod( s, &end );
c088: e1a00007 mov r0, r7
c08c: e1a0100d mov r1, sp
c090: eb0017dd bl 1200c <strtod>
if ( endptr )
c094: e3580000 cmp r8, #0
*endptr = end;
c098: 159d3000 ldrne r3, [sp]
errno = 0;
*n = 0;
result = strtod( s, &end );
if ( endptr )
c09c: 059d3000 ldreq r3, [sp]
*endptr = end;
c0a0: 15883000 strne r3, [r8]
if ( end == s )
c0a4: e1570003 cmp r7, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
c0a8: e1a05000 mov r5, r0
c0ac: e1a06001 mov r6, r1
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
c0b0: 03a0000b moveq r0, #11
result = strtod( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
c0b4: 0a000005 beq c0d0 <rtems_string_to_double+0x7c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
c0b8: eb000c5c bl f230 <__errno>
c0bc: e5903000 ldr r3, [r0]
c0c0: e3530022 cmp r3, #34 ; 0x22
c0c4: 0a000003 beq c0d8 <rtems_string_to_double+0x84>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
c0c8: e8840060 stm r4, {r5, r6}
return RTEMS_SUCCESSFUL;
c0cc: e3a00000 mov r0, #0
}
c0d0: e28dd004 add sp, sp, #4
c0d4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
c0d8: e1a00005 mov r0, r5
c0dc: e1a01006 mov r1, r6
c0e0: e3a02000 mov r2, #0
c0e4: e3a03000 mov r3, #0
c0e8: ebffdd48 bl 3610 <__cmpdf2>
c0ec: e3500000 cmp r0, #0
c0f0: 0a00000e beq c130 <rtems_string_to_double+0xdc>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
c0f4: e3e03102 mvn r3, #-2147483648 ; 0x80000000
c0f8: e1a00005 mov r0, r5
c0fc: e1a01006 mov r1, r6
c100: e3e02000 mvn r2, #0
c104: e2433601 sub r3, r3, #1048576 ; 0x100000
c108: ebffdd3c bl 3600 <__gedf2>
c10c: e3500000 cmp r0, #0
c110: ca000006 bgt c130 <rtems_string_to_double+0xdc>
c114: e1a00005 mov r0, r5 <== NOT EXECUTED
c118: e1a01006 mov r1, r6 <== NOT EXECUTED
c11c: e3e02000 mvn r2, #0 <== NOT EXECUTED
c120: e3e03601 mvn r3, #1048576 ; 0x100000 <== NOT EXECUTED
c124: ebffdd37 bl 3608 <__ledf2> <== NOT EXECUTED
c128: e3500000 cmp r0, #0 <== NOT EXECUTED
c12c: aaffffe5 bge c0c8 <rtems_string_to_double+0x74> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
c130: e3a0000a mov r0, #10
c134: eaffffe5 b c0d0 <rtems_string_to_double+0x7c>
0000c138 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
c138: e92d40f0 push {r4, r5, r6, r7, lr}
float result;
char *end;
if ( !n )
c13c: e2515000 subs r5, r1, #0
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
c140: e1a04000 mov r4, r0
c144: e24dd004 sub sp, sp, #4
c148: e1a06002 mov r6, r2
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
c14c: 03a00009 moveq r0, #9
)
{
float result;
char *end;
if ( !n )
c150: 0a000015 beq c1ac <rtems_string_to_float+0x74>
return RTEMS_INVALID_ADDRESS;
errno = 0;
c154: eb000c35 bl f230 <__errno>
c158: e3a03000 mov r3, #0
c15c: e5803000 str r3, [r0]
*n = 0;
c160: e3a03000 mov r3, #0
c164: e5853000 str r3, [r5]
result = strtof( s, &end );
c168: e1a00004 mov r0, r4
c16c: e1a0100d mov r1, sp
c170: eb0017ac bl 12028 <strtof>
if ( endptr )
c174: e3560000 cmp r6, #0
*endptr = end;
c178: 159d3000 ldrne r3, [sp]
errno = 0;
*n = 0;
result = strtof( s, &end );
if ( endptr )
c17c: 059d3000 ldreq r3, [sp]
*endptr = end;
c180: 15863000 strne r3, [r6]
if ( end == s )
c184: e1540003 cmp r4, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtof( s, &end );
c188: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
c18c: 03a0000b moveq r0, #11
result = strtof( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
c190: 0a000005 beq c1ac <rtems_string_to_float+0x74>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
c194: eb000c25 bl f230 <__errno>
c198: e5903000 ldr r3, [r0]
c19c: e3530022 cmp r3, #34 ; 0x22
c1a0: 0a000003 beq c1b4 <rtems_string_to_float+0x7c>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
*n = result;
c1a4: e5857000 str r7, [r5]
return RTEMS_SUCCESSFUL;
c1a8: e3a00000 mov r0, #0
}
c1ac: e28dd004 add sp, sp, #4
c1b0: e8bd80f0 pop {r4, r5, r6, r7, pc}
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
c1b4: e1a00007 mov r0, r7
c1b8: e3a01000 mov r1, #0
c1bc: ebffdd5e bl 373c <__cmpsf2>
c1c0: e3500000 cmp r0, #0
c1c4: 0a00000a beq c1f4 <rtems_string_to_float+0xbc>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
c1c8: e3e01102 mvn r1, #-2147483648 ; 0x80000000
c1cc: e1a00007 mov r0, r7
c1d0: e2411502 sub r1, r1, #8388608 ; 0x800000
c1d4: ebffdd54 bl 372c <__gesf2>
c1d8: e3500000 cmp r0, #0
c1dc: ca000004 bgt c1f4 <rtems_string_to_float+0xbc>
c1e0: e1a00007 mov r0, r7 <== NOT EXECUTED
c1e4: e3e01502 mvn r1, #8388608 ; 0x800000 <== NOT EXECUTED
c1e8: ebffdd51 bl 3734 <__lesf2> <== NOT EXECUTED
c1ec: e3500000 cmp r0, #0 <== NOT EXECUTED
c1f0: aaffffeb bge c1a4 <rtems_string_to_float+0x6c> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
c1f4: e3a0000a mov r0, #10
c1f8: eaffffeb b c1ac <rtems_string_to_float+0x74>
0000c1fc <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
c1fc: e92d40f0 push {r4, r5, r6, r7, lr}
long result;
char *end;
if ( !n )
c200: e2516000 subs r6, r1, #0
const char *s,
int *n,
char **endptr,
int base
)
{
c204: e1a04000 mov r4, r0
c208: e24dd004 sub sp, sp, #4
c20c: e1a05002 mov r5, r2
c210: e1a07003 mov r7, r3
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
c214: 03a00009 moveq r0, #9
)
{
long result;
char *end;
if ( !n )
c218: 0a000015 beq c274 <rtems_string_to_int+0x78>
return RTEMS_INVALID_ADDRESS;
errno = 0;
c21c: eb000c03 bl f230 <__errno>
c220: e3a03000 mov r3, #0
c224: e5803000 str r3, [r0]
*n = 0;
result = strtol( s, &end, base );
c228: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
c22c: e5863000 str r3, [r6]
result = strtol( s, &end, base );
c230: e1a00004 mov r0, r4
c234: e1a0100d mov r1, sp
c238: eb0017fc bl 12230 <strtol>
if ( endptr )
c23c: e3550000 cmp r5, #0
*endptr = end;
c240: 159d3000 ldrne r3, [sp]
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
c244: 059d3000 ldreq r3, [sp]
*endptr = end;
c248: 15853000 strne r3, [r5]
if ( end == s )
c24c: e1540003 cmp r4, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
c250: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
c254: 03a0000b moveq r0, #11
result = strtol( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
c258: 0a000005 beq c274 <rtems_string_to_int+0x78>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
c25c: eb000bf3 bl f230 <__errno>
c260: e5903000 ldr r3, [r0]
c264: e3530022 cmp r3, #34 ; 0x22
c268: 0a000003 beq c27c <rtems_string_to_int+0x80>
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
c26c: e5867000 str r7, [r6]
return RTEMS_SUCCESSFUL;
c270: e3a00000 mov r0, #0
}
c274: e28dd004 add sp, sp, #4
c278: e8bd80f0 pop {r4, r5, r6, r7, pc}
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
c27c: e3770106 cmn r7, #-2147483647 ; 0x80000001
c280: 13570000 cmpne r7, #0
c284: 0a000001 beq c290 <rtems_string_to_int+0x94>
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
c288: e3570102 cmp r7, #-2147483648 ; 0x80000000 <== NOT EXECUTED
c28c: 1afffff6 bne c26c <rtems_string_to_int+0x70> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
c290: e3a0000a mov r0, #10
c294: eafffff6 b c274 <rtems_string_to_int+0x78>
0000c40c <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
c40c: e92d40f0 push {r4, r5, r6, r7, lr}
unsigned long result;
char *end;
if ( !n )
c410: e2516000 subs r6, r1, #0
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
c414: e1a04000 mov r4, r0
c418: e24dd004 sub sp, sp, #4
c41c: e1a05002 mov r5, r2
c420: e1a07003 mov r7, r3
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
c424: 03a00009 moveq r0, #9
)
{
unsigned long result;
char *end;
if ( !n )
c428: 0a000017 beq c48c <rtems_string_to_unsigned_char+0x80>
return RTEMS_INVALID_ADDRESS;
errno = 0;
c42c: eb000b7f bl f230 <__errno>
c430: e3a03000 mov r3, #0
c434: e5803000 str r3, [r0]
*n = 0;
result = strtoul( s, &end, base );
c438: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
c43c: e5c63000 strb r3, [r6]
result = strtoul( s, &end, base );
c440: e1a00004 mov r0, r4
c444: e1a0100d mov r1, sp
c448: eb0018a7 bl 126ec <strtoul>
if ( endptr )
c44c: e3550000 cmp r5, #0
*endptr = end;
c450: 159d3000 ldrne r3, [sp]
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
c454: 059d3000 ldreq r3, [sp]
*endptr = end;
c458: 15853000 strne r3, [r5]
if ( end == s )
c45c: e1540003 cmp r4, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
c460: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
c464: 03a0000b moveq r0, #11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
c468: 0a000007 beq c48c <rtems_string_to_unsigned_char+0x80>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
c46c: eb000b6f bl f230 <__errno>
c470: e5903000 ldr r3, [r0]
c474: e3530022 cmp r3, #34 ; 0x22
c478: 0a000005 beq c494 <rtems_string_to_unsigned_char+0x88>
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
c47c: e35700ff cmp r7, #255 ; 0xff
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
c480: 95c67000 strbls r7, [r6]
return RTEMS_SUCCESSFUL;
c484: 93a00000 movls r0, #0
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
c488: 8a000009 bhi c4b4 <rtems_string_to_unsigned_char+0xa8>
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
c48c: e28dd004 add sp, sp, #4
c490: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
c494: e2473001 sub r3, r7, #1 <== NOT EXECUTED
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
c498: e3730003 cmn r3, #3 <== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
c49c: 83a0000a movhi r0, #10 <== NOT EXECUTED
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
c4a0: 8afffff9 bhi c48c <rtems_string_to_unsigned_char+0x80> <== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
c4a4: e35700ff cmp r7, #255 ; 0xff <== NOT EXECUTED
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
c4a8: 95c67000 strbls r7, [r6] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
c4ac: 93a00000 movls r0, #0 <== NOT EXECUTED
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
c4b0: 9afffff5 bls c48c <rtems_string_to_unsigned_char+0x80> <== NOT EXECUTED
errno = ERANGE;
c4b4: eb000b5d bl f230 <__errno> <== NOT EXECUTED
c4b8: e3a03022 mov r3, #34 ; 0x22 <== NOT EXECUTED
c4bc: e5803000 str r3, [r0] <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
c4c0: e3a0000a mov r0, #10 <== NOT EXECUTED
c4c4: eafffff0 b c48c <rtems_string_to_unsigned_char+0x80> <== NOT EXECUTED
00001e54 <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
1e54: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1e58: e24ddf6a sub sp, sp, #424 ; 0x1a8
1e5c: e1a06001 mov r6, r1
1e60: e1a07002 mov r7, r2
1e64: e58d0014 str r0, [sp, #20]
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
1e68: eb0043bb bl 12d5c <strlen>
1e6c: e28d2e19 add r2, sp, #400 ; 0x190
1e70: e1a01000 mov r1, r0
1e74: e58d2008 str r2, [sp, #8]
1e78: e59d0014 ldr r0, [sp, #20]
1e7c: e3a02000 mov r2, #0
1e80: e28d3e19 add r3, sp, #400 ; 0x190
1e84: e58d2000 str r2, [sp]
1e88: eb0002c0 bl 2990 <rtems_filesystem_evaluate_path>
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
1e8c: e3500000 cmp r0, #0
return -1;
1e90: 13e02000 mvnne r2, #0
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
1e94: e58d0010 str r0, [sp, #16]
return -1;
1e98: 158d2010 strne r2, [sp, #16]
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
1e9c: 1a000032 bne 1f6c <rtems_tarfs_load+0x118>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
1ea0: e59d319c ldr r3, [sp, #412] ; 0x19c
1ea4: e59f21d4 ldr r2, [pc, #468] ; 2080 <rtems_tarfs_load+0x22c>
1ea8: e1530002 cmp r3, r2
1eac: 059da010 ldreq sl, [sp, #16]
1eb0: 1a00006b bne 2064 <rtems_tarfs_load+0x210>
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
1eb4: e28a4c02 add r4, sl, #512 ; 0x200
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
1eb8: e28d3f5f add r3, sp, #380 ; 0x17c
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
1ebc: e1540007 cmp r4, r7
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
1ec0: e28d5f46 add r5, sp, #280 ; 0x118
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
1ec4: e58d3004 str r3, [sp, #4]
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
1ec8: 8a000027 bhi 1f6c <rtems_tarfs_load+0x118>
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
1ecc: e086a00a add sl, r6, sl
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
1ed0: e28a0c01 add r0, sl, #256 ; 0x100
1ed4: e2800001 add r0, r0, #1
1ed8: e59f11a4 ldr r1, [pc, #420] ; 2084 <rtems_tarfs_load+0x230>
1edc: e3a02005 mov r2, #5
1ee0: eb0043b5 bl 12dbc <strncmp>
1ee4: e2508000 subs r8, r0, #0
1ee8: 1a00001f bne 1f6c <rtems_tarfs_load+0x118>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
1eec: e3a02063 mov r2, #99 ; 0x63
1ef0: e1a0100a mov r1, sl
1ef4: e1a00005 mov r0, r5
1ef8: eb004410 bl 12f40 <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
1efc: e5cd817b strb r8, [sp, #379] ; 0x17b
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
1f00: e3a01008 mov r1, #8
1f04: e28a0064 add r0, sl, #100 ; 0x64
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
1f08: e5dab09c ldrb fp, [sl, #156] ; 0x9c
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
1f0c: eb00202a bl 9fbc <_rtems_octal2ulong>
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
1f10: e3a0100c mov r1, #12
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
1f14: e1a09000 mov r9, r0
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
1f18: e28a007c add r0, sl, #124 ; 0x7c
1f1c: eb002026 bl 9fbc <_rtems_octal2ulong>
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
1f20: e3a01008 mov r1, #8
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
1f24: e1a08000 mov r8, r0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
1f28: e28a0094 add r0, sl, #148 ; 0x94
1f2c: eb002022 bl 9fbc <_rtems_octal2ulong>
1f30: e1a03000 mov r3, r0
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
1f34: e1a0000a mov r0, sl
1f38: e58d300c str r3, [sp, #12]
1f3c: eb00212b bl a3f0 <_rtems_tar_header_checksum>
1f40: e59d300c ldr r3, [sp, #12]
1f44: e1500003 cmp r0, r3
1f48: 1a000007 bne 1f6c <rtems_tarfs_load+0x118>
* 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) {
1f4c: e35b0035 cmp fp, #53 ; 0x35
1f50: 0a00001a beq 1fc0 <rtems_tarfs_load+0x16c>
* 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) {
1f54: e35b0030 cmp fp, #48 ; 0x30
1f58: 0a000006 beq 1f78 <rtems_tarfs_load+0x124>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
1f5c: e1a0a004 mov sl, r4
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
1f60: e28a4c02 add r4, sl, #512 ; 0x200
1f64: e1540007 cmp r4, r7
1f68: 9affffd7 bls 1ecc <rtems_tarfs_load+0x78>
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
1f6c: e59d0010 ldr r0, [sp, #16]
1f70: e28ddf6a add sp, sp, #424 ; 0x1a8
1f74: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
1f78: e59dc008 ldr ip, [sp, #8]
1f7c: e59de004 ldr lr, [sp, #4]
1f80: e8bc000f ldm ip!, {r0, r1, r2, r3}
1f84: e8ae000f stmia lr!, {r0, r1, r2, r3}
1f88: e59cc000 ldr ip, [ip]
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
1f8c: e1a00005 mov r0, r5
1f90: e28d1f5f add r1, sp, #380 ; 0x17c
1f94: e28d2f69 add r2, sp, #420 ; 0x1a4
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
1f98: e58ec000 str ip, [lr]
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
1f9c: eb002346 bl acbc <IMFS_evaluate_for_make>
1fa0: e250a000 subs sl, r0, #0
1fa4: 0a00001d beq 2020 <rtems_tarfs_load+0x1cc>
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
}
nblocks = (((file_size) + 511) & ~511) / 512;
1fa8: e2888f7f add r8, r8, #508 ; 0x1fc <== NOT EXECUTED
1fac: e2888003 add r8, r8, #3 <== NOT EXECUTED
1fb0: e1a084a8 lsr r8, r8, #9 <== NOT EXECUTED
offset += 512 * nblocks;
1fb4: e0844488 add r4, r4, r8, lsl #9 <== NOT EXECUTED
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
1fb8: e1a0a004 mov sl, r4
1fbc: eaffffe7 b 1f60 <rtems_tarfs_load+0x10c>
* - 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);
1fc0: e59d1014 ldr r1, [sp, #20]
1fc4: e28d0018 add r0, sp, #24
1fc8: eb00419f bl 1264c <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
1fcc: e28d0018 add r0, sp, #24
1fd0: eb004361 bl 12d5c <strlen>
1fd4: e28def6a add lr, sp, #424 ; 0x1a8
1fd8: e08e3000 add r3, lr, r0
1fdc: e5533191 ldrb r3, [r3, #-401] ; 0x191
1fe0: e353002f cmp r3, #47 ; 0x2f
1fe4: 0a000004 beq 1ffc <rtems_tarfs_load+0x1a8>
strcat(full_filename, "/");
1fe8: e28d2018 add r2, sp, #24 <== NOT EXECUTED
1fec: e0820000 add r0, r2, r0 <== NOT EXECUTED
1ff0: e59f1090 ldr r1, [pc, #144] ; 2088 <rtems_tarfs_load+0x234><== NOT EXECUTED
1ff4: e3a02002 mov r2, #2 <== NOT EXECUTED
1ff8: eb003e7c bl 119f0 <memcpy> <== NOT EXECUTED
strcat(full_filename, filename);
1ffc: e1a01005 mov r1, r5
2000: e28d0018 add r0, sp, #24
2004: eb0040d9 bl 12370 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
2008: e3a01f7f mov r1, #508 ; 0x1fc
200c: e28d0018 add r0, sp, #24
2010: e2811003 add r1, r1, #3
2014: eb0004c0 bl 331c <mkdir>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
2018: e1a0a004 mov sl, r4
201c: eaffffcf b 1f60 <rtems_tarfs_load+0x10c>
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
2020: e1a03b89 lsl r3, r9, #23
2024: e1a03ba3 lsr r3, r3, #23
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
2028: e3833902 orr r3, r3, #32768 ; 0x8000
202c: e3a01006 mov r1, #6
2030: e28d0f5f add r0, sp, #380 ; 0x17c
2034: e59d21a4 ldr r2, [sp, #420] ; 0x1a4
2038: e58da000 str sl, [sp]
203c: eb00216f bl a600 <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;
2040: e5808050 str r8, [r0, #80] ; 0x50
node->info.linearfile.direct = &tar_image[offset];
}
nblocks = (((file_size) + 511) & ~511) / 512;
2044: e2888f7f add r8, r8, #508 ; 0x1fc
2048: e2888003 add r8, r8, #3
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
204c: e0863004 add r3, r6, r4
}
nblocks = (((file_size) + 511) & ~511) / 512;
2050: e1a084a8 lsr r8, r8, #9
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
2054: e580a054 str sl, [r0, #84] ; 0x54
node->info.linearfile.direct = &tar_image[offset];
2058: e5803058 str r3, [r0, #88] ; 0x58
}
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
205c: e0844488 add r4, r4, r8, lsl #9
2060: eaffffd4 b 1fb8 <rtems_tarfs_load+0x164>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
2064: e59f2020 ldr r2, [pc, #32] ; 208c <rtems_tarfs_load+0x238>
2068: e1530002 cmp r3, r2
206c: 01a0a000 moveq sl, r0
2070: 0affff8f beq 1eb4 <rtems_tarfs_load+0x60>
return -1;
2074: e3e03000 mvn r3, #0
2078: e58d3010 str r3, [sp, #16]
207c: eaffffba b 1f6c <rtems_tarfs_load+0x118>
0000d9fc <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
d9fc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
da00: e2525000 subs r5, r2, #0
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
da04: e1a04000 mov r4, r0
da08: e1a06001 mov r6, r1
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
da0c: 03a00009 moveq r0, #9
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
da10: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
da14: e59f9148 ldr r9, [pc, #328] ; db64 <rtems_task_mode+0x168>
da18: e5997004 ldr r7, [r9, #4]
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
da1c: e5d7a074 ldrb sl, [r7, #116] ; 0x74
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
da20: e59780f8 ldr r8, [r7, #248] ; 0xf8
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
da24: e597307c ldr r3, [r7, #124] ; 0x7c
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
da28: e35a0000 cmp sl, #0
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;
da2c: e5d8b008 ldrb fp, [r8, #8]
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
da30: 03a0ac01 moveq sl, #256 ; 0x100
da34: 13a0a000 movne sl, #0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
da38: e3530000 cmp r3, #0
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
da3c: 138aac02 orrne sl, sl, #512 ; 0x200
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
da40: e35b0000 cmp fp, #0
da44: 03a0bb01 moveq fp, #1024 ; 0x400
da48: 13a0b000 movne fp, #0
old_mode |= _ISR_Get_level();
da4c: ebffeebe bl 954c <_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;
da50: e18bb000 orr fp, fp, r0
old_mode |= _ISR_Get_level();
da54: e18ba00a orr sl, fp, sl
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
da58: e3160c01 tst r6, #256 ; 0x100
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
old_mode |= _ISR_Get_level();
*previous_mode_set = old_mode;
da5c: e585a000 str sl, [r5]
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
da60: 0a000003 beq da74 <rtems_task_mode+0x78>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
da64: e3140c01 tst r4, #256 ; 0x100
da68: 13a03000 movne r3, #0
da6c: 03a03001 moveq r3, #1
da70: e5c73074 strb r3, [r7, #116] ; 0x74
if ( mask & RTEMS_TIMESLICE_MASK ) {
da74: e3160c02 tst r6, #512 ; 0x200
da78: 1a000028 bne db20 <rtems_task_mode+0x124>
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
da7c: e3160080 tst r6, #128 ; 0x80
da80: 1a00002f bne db44 <rtems_task_mode+0x148>
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
da84: e2166b01 ands r6, r6, #1024 ; 0x400
da88: 0a000012 beq dad8 <rtems_task_mode+0xdc>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
da8c: e3140b01 tst r4, #1024 ; 0x400
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 ) {
da90: e5d82008 ldrb r2, [r8, #8]
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
da94: 13a03000 movne r3, #0
da98: 03a03001 moveq r3, #1
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 ) {
da9c: e1520003 cmp r2, r3
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
daa0: 03a06000 moveq r6, #0
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
daa4: 0a00000b beq dad8 <rtems_task_mode+0xdc>
asr->is_enabled = is_asr_enabled;
daa8: e5c83008 strb r3, [r8, #8]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
daac: e10f3000 mrs r3, CPSR
dab0: e3832080 orr r2, r3, #128 ; 0x80
dab4: e129f002 msr CPSR_fc, r2
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
dab8: e5981018 ldr r1, [r8, #24]
information->signals_pending = information->signals_posted;
dabc: e5982014 ldr r2, [r8, #20]
information->signals_posted = _signals;
dac0: e5881014 str r1, [r8, #20]
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
dac4: e5882018 str r2, [r8, #24]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
dac8: e129f003 msr CPSR_fc, r3
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
dacc: e5986014 ldr r6, [r8, #20]
dad0: e3560000 cmp r6, #0
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
dad4: 13a06001 movne r6, #1
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
dad8: e59f3088 ldr r3, [pc, #136] ; db68 <rtems_task_mode+0x16c>
dadc: e5933000 ldr r3, [r3]
dae0: e3530003 cmp r3, #3
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
dae4: 13a00000 movne r0, #0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
dae8: 18bd8ff0 popne {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
Thread_Control *executing;
executing = _Thread_Executing;
if ( are_signals_pending ||
daec: e3560000 cmp r6, #0
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
daf0: e5993004 ldr r3, [r9, #4]
if ( are_signals_pending ||
daf4: 1a000015 bne db50 <rtems_task_mode+0x154>
daf8: e59f2064 ldr r2, [pc, #100] ; db64 <rtems_task_mode+0x168>
dafc: e5922008 ldr r2, [r2, #8]
db00: e1530002 cmp r3, r2
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
db04: 01a00006 moveq r0, r6
db08: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
db0c: e5d33074 ldrb r3, [r3, #116] ; 0x74
db10: e3530000 cmp r3, #0
db14: 1a00000d bne db50 <rtems_task_mode+0x154>
db18: e1a00006 mov r0, r6 <== NOT EXECUTED
}
db1c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
*/
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
db20: e2143c02 ands r3, r4, #512 ; 0x200
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
db24: 159f3040 ldrne r3, [pc, #64] ; db6c <rtems_task_mode+0x170>
db28: 15933000 ldrne r3, [r3]
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
db2c: 13a02001 movne r2, #1
db30: 1587207c strne r2, [r7, #124] ; 0x7c
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
db34: 15873078 strne r3, [r7, #120] ; 0x78
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
db38: 0587307c streq r3, [r7, #124] ; 0x7c
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
db3c: e3160080 tst r6, #128 ; 0x80
db40: 0affffcf beq da84 <rtems_task_mode+0x88>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
db44: e2040080 and r0, r4, #128 ; 0x80
db48: ebffee7a bl 9538 <_CPU_ISR_Set_level>
db4c: eaffffcc b da84 <rtems_task_mode+0x88>
_Thread_Dispatch_necessary = true;
db50: e3a03001 mov r3, #1
db54: e5c93010 strb r3, [r9, #16]
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
db58: ebffe8be bl 7e58 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
db5c: e3a00000 mov r0, #0
db60: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
000037b0 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
37b0: e92d4070 push {r4, r5, r6, lr}
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
37b4: e59f51a4 ldr r5, [pc, #420] ; 3960 <rtems_termios_close+0x1b0>
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
37b8: e5903000 ldr r3, [r0]
rtems_status_code sc;
sc = rtems_semaphore_obtain(
37bc: e3a01000 mov r1, #0
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
37c0: e1a06000 mov r6, r0
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
37c4: e1a02001 mov r2, r1
37c8: e5950000 ldr r0, [r5]
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
37cc: e5934034 ldr r4, [r3, #52] ; 0x34
rtems_status_code sc;
sc = rtems_semaphore_obtain(
37d0: eb000889 bl 59fc <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
37d4: e3500000 cmp r0, #0
37d8: 1a00005f bne 395c <rtems_termios_close+0x1ac>
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
37dc: e5943008 ldr r3, [r4, #8]
37e0: e2433001 sub r3, r3, #1
37e4: e3530000 cmp r3, #0
37e8: e5843008 str r3, [r4, #8]
37ec: 1a00002f bne 38b0 <rtems_termios_close+0x100>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
37f0: e59420cc ldr r2, [r4, #204] ; 0xcc
37f4: e59f3168 ldr r3, [pc, #360] ; 3964 <rtems_termios_close+0x1b4>
37f8: e0833282 add r3, r3, r2, lsl #5
37fc: e5931004 ldr r1, [r3, #4]
3800: e3510000 cmp r1, #0
3804: 0a00003e beq 3904 <rtems_termios_close+0x154>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
3808: e1a00004 mov r0, r4
380c: e1a0e00f mov lr, pc
3810: e12fff11 bx r1
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
3814: e59430b4 ldr r3, [r4, #180] ; 0xb4
3818: e3530002 cmp r3, #2
381c: 0a000044 beq 3934 <rtems_termios_close+0x184>
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
3820: e594309c ldr r3, [r4, #156] ; 0x9c
3824: e3530000 cmp r3, #0
(*tty->device.lastClose)(tty->major, tty->minor, arg);
3828: 1284000c addne r0, r4, #12
382c: 18900003 ldmne r0, {r0, r1}
3830: 11a02006 movne r2, r6
3834: 11a0e00f movne lr, pc
3838: 112fff13 bxne r3
if (tty->forw == NULL) {
383c: e5943000 ldr r3, [r4]
3840: e3530000 cmp r3, #0
3844: 0a000026 beq 38e4 <rtems_termios_close+0x134>
rtems_termios_ttyTail = tty->back;
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
} else {
tty->forw->back = tty->back;
3848: e5942004 ldr r2, [r4, #4]
384c: e5832004 str r2, [r3, #4]
3850: e5942004 ldr r2, [r4, #4]
}
if (tty->back == NULL) {
3854: e3520000 cmp r2, #0
3858: 0a00001b beq 38cc <rtems_termios_close+0x11c>
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
} else {
tty->back->forw = tty->forw;
385c: e5823000 str r3, [r2]
}
rtems_semaphore_delete (tty->isem);
3860: e5940014 ldr r0, [r4, #20]
3864: eb00083b bl 5958 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
3868: e5940018 ldr r0, [r4, #24]
386c: eb000839 bl 5958 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
3870: e594008c ldr r0, [r4, #140] ; 0x8c
3874: eb000837 bl 5958 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
3878: e59430a0 ldr r3, [r4, #160] ; 0xa0
387c: e3530000 cmp r3, #0
3880: 0a00000e beq 38c0 <rtems_termios_close+0x110>
3884: e59430b4 ldr r3, [r4, #180] ; 0xb4
3888: e3530002 cmp r3, #2
388c: 0a00000b beq 38c0 <rtems_termios_close+0x110>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
free (tty->rawInBuf.theBuf);
3890: e5940058 ldr r0, [r4, #88] ; 0x58
3894: ebfffa94 bl 22ec <free>
free (tty->rawOutBuf.theBuf);
3898: e594007c ldr r0, [r4, #124] ; 0x7c
389c: ebfffa92 bl 22ec <free>
free (tty->cbuf);
38a0: e594001c ldr r0, [r4, #28]
38a4: ebfffa90 bl 22ec <free>
free (tty);
38a8: e1a00004 mov r0, r4
38ac: ebfffa8e bl 22ec <free>
} rtems_semaphore_release (rtems_termios_ttyMutex);
38b0: e5950000 ldr r0, [r5]
38b4: eb000899 bl 5b20 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
38b8: e3a00000 mov r0, #0
38bc: e8bd8070 pop {r4, r5, r6, pc}
rtems_semaphore_delete (tty->isem);
rtems_semaphore_delete (tty->osem);
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
38c0: e5940068 ldr r0, [r4, #104] ; 0x68
38c4: eb000823 bl 5958 <rtems_semaphore_delete>
38c8: eafffff0 b 3890 <rtems_termios_close+0xe0>
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
38cc: e59f2094 ldr r2, [pc, #148] ; 3968 <rtems_termios_close+0x1b8>
if ( rtems_termios_ttyHead != NULL ) {
38d0: e3530000 cmp r3, #0
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
38d4: e5823000 str r3, [r2]
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
38d8: 13a02000 movne r2, #0
38dc: 15832004 strne r2, [r3, #4]
38e0: eaffffde b 3860 <rtems_termios_close+0xb0>
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
38e4: e5942004 ldr r2, [r4, #4]
38e8: e59f107c ldr r1, [pc, #124] ; 396c <rtems_termios_close+0x1bc>
if ( rtems_termios_ttyTail != NULL ) {
38ec: e3520000 cmp r2, #0
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
38f0: e5812000 str r2, [r1]
if ( rtems_termios_ttyTail != NULL ) {
38f4: 0afffff4 beq 38cc <rtems_termios_close+0x11c>
rtems_termios_ttyTail->forw = NULL;
38f8: e5823000 str r3, [r2]
38fc: e5943000 ldr r3, [r4]
3900: eaffffd5 b 385c <rtems_termios_close+0xac>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3904: e5940018 ldr r0, [r4, #24]
3908: e1a02001 mov r2, r1
390c: eb00083a bl 59fc <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
3910: e3500000 cmp r0, #0
3914: 1a000010 bne 395c <rtems_termios_close+0x1ac>
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
3918: e1a00004 mov r0, r4
391c: ebfffe4e bl 325c <drainOutput>
rtems_semaphore_release (tty->osem);
3920: e5940018 ldr r0, [r4, #24]
3924: eb00087d bl 5b20 <rtems_semaphore_release>
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
3928: e59430b4 ldr r3, [r4, #180] ; 0xb4
392c: e3530002 cmp r3, #2
3930: 1affffba bne 3820 <rtems_termios_close+0x70>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
3934: e59400c4 ldr r0, [r4, #196] ; 0xc4
3938: e3a01001 mov r1, #1
393c: eb000707 bl 5560 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
3940: e3500000 cmp r0, #0
3944: 1a000004 bne 395c <rtems_termios_close+0x1ac>
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
3948: e59400c8 ldr r0, [r4, #200] ; 0xc8
394c: e3a01001 mov r1, #1
3950: eb000702 bl 5560 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
3954: e3500000 cmp r0, #0
3958: 0affffb0 beq 3820 <rtems_termios_close+0x70>
rtems_fatal_error_occurred (sc);
395c: eb0009ce bl 609c <rtems_fatal_error_occurred> <== NOT EXECUTED
00004f64 <rtems_termios_dequeue_characters>:
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
4f64: e590c090 ldr ip, [r0, #144] ; 0x90
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
4f68: e59020b4 ldr r2, [r0, #180] ; 0xb4
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
4f6c: e08c1001 add r1, ip, r1
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
4f70: e3520002 cmp r2, #2
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
4f74: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
4f78: e5801090 str r1, [r0, #144] ; 0x90
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
4f7c: 0a00000c beq 4fb4 <rtems_termios_dequeue_characters+0x50>
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
4f80: e59030cc ldr r3, [r0, #204] ; 0xcc
4f84: e3530005 cmp r3, #5
4f88: 0a000001 beq 4f94 <rtems_termios_dequeue_characters+0x30>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
4f8c: e49de004 pop {lr} ; (ldr lr, [sp], #4)
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
4f90: eaffff55 b 4cec <rtems_termios_refill_transmitter>
if (tty->t_line == PPPDISC ) {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
4f94: e59f303c ldr r3, [pc, #60] ; 4fd8 <rtems_termios_dequeue_characters+0x74>
4f98: e59330b4 ldr r3, [r3, #180] ; 0xb4
4f9c: e3530000 cmp r3, #0
4fa0: 0a00000a beq 4fd0 <rtems_termios_dequeue_characters+0x6c>
rtems_termios_linesw[tty->t_line].l_start(tty);
4fa4: e1a0e00f mov lr, pc
4fa8: e12fff13 bx r3
}
return 0; /* nothing to output in IRQ... */
4fac: e3a00000 mov r0, #0
4fb0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
4fb4: e59000c8 ldr r0, [r0, #200] ; 0xc8
4fb8: e1a01002 mov r1, r2
4fbc: eb000167 bl 5560 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
4fc0: e2503000 subs r3, r0, #0
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
4fc4: 01a00003 moveq r0, r3
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
if (sc != RTEMS_SUCCESSFUL)
4fc8: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred (sc);
4fcc: eb000432 bl 609c <rtems_fatal_error_occurred> <== NOT EXECUTED
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
4fd0: e1a00003 mov r0, r3 <== NOT EXECUTED
}
return rtems_termios_refill_transmitter(tty);
}
4fd4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
0000496c <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)
{
496c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
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) {
4970: e59030cc ldr r3, [r0, #204] ; 0xcc
4974: e59f72e0 ldr r7, [pc, #736] ; 4c5c <rtems_termios_enqueue_raw_characters+0x2f0>
4978: e0873283 add r3, r7, r3, lsl #5
497c: e5939010 ldr r9, [r3, #16]
4980: e3590000 cmp r9, #0
* 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)
{
4984: e24dd008 sub sp, sp, #8
4988: e1a04000 mov r4, r0
498c: e1a05001 mov r5, r1
4990: e1a06002 mov r6, r2
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) {
4994: 0a00001e beq 4a14 <rtems_termios_enqueue_raw_characters+0xa8>
while (len--) {
4998: e3520000 cmp r2, #0
499c: 0a00000b beq 49d0 <rtems_termios_enqueue_raw_characters+0x64>
49a0: e3a08000 mov r8, #0
49a4: ea000002 b 49b4 <rtems_termios_enqueue_raw_characters+0x48>
49a8: e59430cc ldr r3, [r4, #204] ; 0xcc
49ac: e0873283 add r3, r7, r3, lsl #5
49b0: e5939010 ldr r9, [r3, #16]
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
49b4: e7d50008 ldrb r0, [r5, r8]
49b8: e1a01004 mov r1, r4
49bc: e2888001 add r8, r8, #1
49c0: e1a0e00f mov lr, pc
49c4: e12fff19 bx r9
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--) {
49c8: e1580006 cmp r8, r6
49cc: 1afffff5 bne 49a8 <rtems_termios_enqueue_raw_characters+0x3c>
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
49d0: e594a0e4 ldr sl, [r4, #228] ; 0xe4
49d4: e35a0000 cmp sl, #0
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
49d8: 13a0a000 movne sl, #0
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
49dc: 1a000009 bne 4a08 <rtems_termios_enqueue_raw_characters+0x9c>
49e0: e59430dc ldr r3, [r4, #220] ; 0xdc
49e4: e3530000 cmp r3, #0
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
49e8: 01a0a003 moveq sl, r3
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
49ec: 0a000005 beq 4a08 <rtems_termios_enqueue_raw_characters+0x9c>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
49f0: e2840030 add r0, r4, #48 ; 0x30
49f4: e59410e0 ldr r1, [r4, #224] ; 0xe0
49f8: e1a0e00f mov lr, pc
49fc: e12fff13 bx r3
tty->tty_rcvwakeup = 1;
4a00: e3a03001 mov r3, #1
4a04: e58430e4 str r3, [r4, #228] ; 0xe4
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
4a08: e1a0000a mov r0, sl
4a0c: e28dd008 add sp, sp, #8
4a10: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* 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);
4a14: e2803030 add r3, r0, #48 ; 0x30
4a18: e58d3000 str r3, [sp]
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
4a1c: e3560000 cmp r6, #0
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,
4a20: e280304a add r3, r0, #74 ; 0x4a
4a24: e58d3004 str r3, [sp, #4]
4a28: e1a0b009 mov fp, r9
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
4a2c: 0a000044 beq 4b44 <rtems_termios_enqueue_raw_characters+0x1d8>
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
4a30: e59430b8 ldr r3, [r4, #184] ; 0xb8
4a34: e3130c02 tst r3, #512 ; 0x200
}
return 0;
}
while (len--) {
c = *buf++;
4a38: e4d58001 ldrb r8, [r5], #1
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
4a3c: 0a000005 beq 4a58 <rtems_termios_enqueue_raw_characters+0xec>
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
4a40: e5d4304a ldrb r3, [r4, #74] ; 0x4a
4a44: e1530008 cmp r3, r8
4a48: 0a000058 beq 4bb0 <rtems_termios_enqueue_raw_characters+0x244>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
4a4c: e5d43049 ldrb r3, [r4, #73] ; 0x49
4a50: e1530008 cmp r3, r8
4a54: 0a000041 beq 4b60 <rtems_termios_enqueue_raw_characters+0x1f4>
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
4a58: e3590000 cmp r9, #0
4a5c: 1a000043 bne 4b70 <rtems_termios_enqueue_raw_characters+0x204>
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
4a60: e5940060 ldr r0, [r4, #96] ; 0x60
4a64: e5941064 ldr r1, [r4, #100] ; 0x64
4a68: e2800001 add r0, r0, #1
4a6c: eb003335 bl 11748 <__umodsi3>
4a70: e1a07000 mov r7, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
4a74: e10fa000 mrs sl, CPSR
4a78: e38a3080 orr r3, sl, #128 ; 0x80
4a7c: e129f003 msr CPSR_fc, r3
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
4a80: e594305c ldr r3, [r4, #92] ; 0x5c
4a84: e5940064 ldr r0, [r4, #100] ; 0x64
4a88: e0630000 rsb r0, r3, r0
% tty->rawInBuf.Size) > tty->highwater) &&
4a8c: e5941064 ldr r1, [r4, #100] ; 0x64
4a90: e0800007 add r0, r0, r7
4a94: eb00332b bl 11748 <__umodsi3>
}
} 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)
4a98: e59430c0 ldr r3, [r4, #192] ; 0xc0
4a9c: e1500003 cmp r0, r3
4aa0: 9a000010 bls 4ae8 <rtems_termios_enqueue_raw_characters+0x17c>
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
4aa4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== 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) &&
4aa8: e3130001 tst r3, #1 <== NOT EXECUTED
4aac: 1a00000d bne 4ae8 <rtems_termios_enqueue_raw_characters+0x17c><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
4ab0: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4ab4: e3833001 orr r3, r3, #1 <== NOT EXECUTED
4ab8: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
4abc: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4ac0: e3c33fff bic r3, r3, #1020 ; 0x3fc <== NOT EXECUTED
4ac4: e3c33001 bic r3, r3, #1 <== NOT EXECUTED
4ac8: e1a03a83 lsl r3, r3, #21 <== NOT EXECUTED
4acc: e1a03aa3 lsr r3, r3, #21 <== NOT EXECUTED
4ad0: e3530b01 cmp r3, #1024 ; 0x400 <== NOT EXECUTED
4ad4: 0a000047 beq 4bf8 <rtems_termios_enqueue_raw_characters+0x28c><== NOT EXECUTED
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
4ad8: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4adc: e2033f41 and r3, r3, #260 ; 0x104 <== NOT EXECUTED
4ae0: e3530c01 cmp r3, #256 ; 0x100 <== NOT EXECUTED
4ae4: 0a000052 beq 4c34 <rtems_termios_enqueue_raw_characters+0x2c8><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
4ae8: e129f00a msr CPSR_fc, sl
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
4aec: e594305c ldr r3, [r4, #92] ; 0x5c
4af0: e1530007 cmp r3, r7
dropped++;
4af4: 028bb001 addeq fp, fp, #1
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
4af8: 0a00000e beq 4b38 <rtems_termios_enqueue_raw_characters+0x1cc>
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
4afc: e5943058 ldr r3, [r4, #88] ; 0x58
4b00: e7c38007 strb r8, [r3, r7]
tty->rawInBuf.Tail = newTail;
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
4b04: e59430e4 ldr r3, [r4, #228] ; 0xe4
4b08: e3530000 cmp r3, #0
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
4b0c: e5847060 str r7, [r4, #96] ; 0x60
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
4b10: 1a000008 bne 4b38 <rtems_termios_enqueue_raw_characters+0x1cc>
4b14: e59430dc ldr r3, [r4, #220] ; 0xdc
4b18: e3530000 cmp r3, #0
4b1c: 0a000005 beq 4b38 <rtems_termios_enqueue_raw_characters+0x1cc>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
4b20: e59d0000 ldr r0, [sp] <== NOT EXECUTED
4b24: e59410e0 ldr r1, [r4, #224] ; 0xe0 <== NOT EXECUTED
4b28: e1a0e00f mov lr, pc <== NOT EXECUTED
4b2c: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
4b30: e3a03001 mov r3, #1 <== NOT EXECUTED
4b34: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
4b38: e2466001 sub r6, r6, #1
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
4b3c: e3560000 cmp r6, #0
4b40: 1affffba bne 4a30 <rtems_termios_enqueue_raw_characters+0xc4>
}
}
}
}
tty->rawInBufDropped += dropped;
4b44: e5943078 ldr r3, [r4, #120] ; 0x78
4b48: e083300b add r3, r3, fp
4b4c: e5843078 str r3, [r4, #120] ; 0x78
rtems_semaphore_release (tty->rawInBuf.Semaphore);
4b50: e5940068 ldr r0, [r4, #104] ; 0x68
4b54: e1a0a00b mov sl, fp
4b58: eb0003f0 bl 5b20 <rtems_semaphore_release>
return dropped;
4b5c: eaffffa9 b 4a08 <rtems_termios_enqueue_raw_characters+0x9c>
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
4b60: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4b64: e3c33010 bic r3, r3, #16 <== NOT EXECUTED
4b68: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
4b6c: e3a09001 mov r9, #1 <== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
4b70: e59430b8 ldr r3, [r4, #184] ; 0xb8
4b74: e2033030 and r3, r3, #48 ; 0x30
4b78: e3530020 cmp r3, #32
4b7c: 1affffed bne 4b38 <rtems_termios_enqueue_raw_characters+0x1cc>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
4b80: e10f7000 mrs r7, CPSR <== NOT EXECUTED
4b84: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED
4b88: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
4b8c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
4b90: e5942094 ldr r2, [r4, #148] ; 0x94 <== NOT EXECUTED
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
4b94: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
4b98: e3520000 cmp r2, #0 <== NOT EXECUTED
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
4b9c: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
4ba0: 1a00000c bne 4bd8 <rtems_termios_enqueue_raw_characters+0x26c><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
4ba4: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
4ba8: e2466001 sub r6, r6, #1 <== NOT EXECUTED
4bac: eaffffe2 b 4b3c <rtems_termios_enqueue_raw_characters+0x1d0><== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
4bb0: e5d42049 ldrb r2, [r4, #73] ; 0x49
4bb4: e1520003 cmp r2, r3
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
4bb8: 059430b8 ldreq r3, [r4, #184] ; 0xb8
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
4bbc: 159430b8 ldrne r3, [r4, #184] ; 0xb8
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
4bc0: 02233010 eoreq r3, r3, #16
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
4bc4: 13833010 orrne r3, r3, #16
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
4bc8: 058430b8 streq r3, [r4, #184] ; 0xb8
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
4bcc: 158430b8 strne r3, [r4, #184] ; 0xb8
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--) {
4bd0: e3a09001 mov r9, #1
4bd4: eaffffe5 b 4b70 <rtems_termios_enqueue_raw_characters+0x204>
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)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
4bd8: e5943084 ldr r3, [r4, #132] ; 0x84 <== 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)(
4bdc: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED
4be0: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
4be4: e0811003 add r1, r1, r3 <== NOT EXECUTED
4be8: e3a02001 mov r2, #1 <== NOT EXECUTED
4bec: e1a0e00f mov lr, pc <== NOT EXECUTED
4bf0: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
4bf4: eaffffea b 4ba4 <rtems_termios_enqueue_raw_characters+0x238><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
4bf8: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4bfc: e3130020 tst r3, #32 <== NOT EXECUTED
4c00: 1a000002 bne 4c10 <rtems_termios_enqueue_raw_characters+0x2a4><== NOT EXECUTED
4c04: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
4c08: e3530000 cmp r3, #0 <== NOT EXECUTED
4c0c: 1affffb5 bne 4ae8 <rtems_termios_enqueue_raw_characters+0x17c><== 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;
4c10: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4c14: e3833002 orr r3, r3, #2 <== NOT EXECUTED
4c18: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
4c1c: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
4c20: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
4c24: e3a02001 mov r2, #1 <== NOT EXECUTED
4c28: e1a0e00f mov lr, pc <== NOT EXECUTED
4c2c: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
4c30: eaffffac b 4ae8 <rtems_termios_enqueue_raw_characters+0x17c><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
4c34: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
4c38: e59430ac ldr r3, [r4, #172] ; 0xac <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
4c3c: e3822004 orr r2, r2, #4 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
4c40: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
4c44: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
4c48: 0affffa6 beq 4ae8 <rtems_termios_enqueue_raw_characters+0x17c><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
4c4c: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
4c50: e1a0e00f mov lr, pc <== NOT EXECUTED
4c54: e12fff13 bx r3 <== NOT EXECUTED
4c58: eaffffa2 b 4ae8 <rtems_termios_enqueue_raw_characters+0x17c><== NOT EXECUTED
00003988 <rtems_termios_ioctl>:
rtems_status_code
rtems_termios_ioctl (void *arg)
{
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
3988: e5902000 ldr r2, [r0]
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
398c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
3990: e5925034 ldr r5, [r2, #52] ; 0x34
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
3994: e3a03000 mov r3, #0
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
3998: e1a04000 mov r4, r0
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
399c: e580300c str r3, [r0, #12]
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
39a0: e1a01003 mov r1, r3
39a4: e5950018 ldr r0, [r5, #24]
39a8: e1a02003 mov r2, r3
rtems_status_code
rtems_termios_ioctl (void *arg)
{
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
39ac: e5947008 ldr r7, [r4, #8]
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
39b0: eb000811 bl 59fc <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
39b4: e2506000 subs r6, r0, #0
39b8: 1a00000e bne 39f8 <rtems_termios_ioctl+0x70>
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
39bc: e5943004 ldr r3, [r4, #4]
39c0: e3530004 cmp r3, #4
39c4: 0a000006 beq 39e4 <rtems_termios_ioctl+0x5c>
39c8: 8a00000d bhi 3a04 <rtems_termios_ioctl+0x7c>
39cc: e3530002 cmp r3, #2
39d0: 0a000020 beq 3a58 <rtems_termios_ioctl+0xd0>
39d4: 9a000087 bls 3bf8 <rtems_termios_ioctl+0x270>
if (tty->device.setAttributes)
(*tty->device.setAttributes)(tty->minor, &tty->termios);
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
39d8: e1a00005 mov r0, r5
39dc: ebfffe1e bl 325c <drainOutput>
break;
39e0: ea000002 b 39f0 <rtems_termios_ioctl+0x68>
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
39e4: e897000c ldm r7, {r2, r3}
39e8: e58520dc str r2, [r5, #220] ; 0xdc
39ec: e58530e0 str r3, [r5, #224] ; 0xe0
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
39f0: e5950018 ldr r0, [r5, #24]
39f4: eb000849 bl 5b20 <rtems_semaphore_release>
args->ioctl_return = sc;
39f8: e584600c str r6, [r4, #12]
return sc; }
39fc: e1a00006 mov r0, r6
3a00: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
3a04: e3a02a46 mov r2, #286720 ; 0x46000
3a08: e2822e67 add r2, r2, #1648 ; 0x670
3a0c: e282213d add r2, r2, #1073741839 ; 0x4000000f
3a10: e1530002 cmp r3, r2
3a14: 0a00006b beq 3bc8 <rtems_termios_ioctl+0x240>
3a18: 8a000082 bhi 3c28 <rtems_termios_ioctl+0x2a0>
3a1c: e3530005 cmp r3, #5
3a20: 0a0000a5 beq 3cbc <rtems_termios_ioctl+0x334>
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
3a24: e59520cc ldr r2, [r5, #204] ; 0xcc
3a28: e59f3334 ldr r3, [pc, #820] ; 3d64 <rtems_termios_ioctl+0x3dc>
3a2c: e0833282 add r3, r3, r2, lsl #5
3a30: e5933018 ldr r3, [r3, #24]
3a34: e3530000 cmp r3, #0
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
3a38: 03a0600a moveq r6, #10
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
3a3c: 0affffeb beq 39f0 <rtems_termios_ioctl+0x68>
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
3a40: e1a00005 mov r0, r5
3a44: e1a01004 mov r1, r4
3a48: e1a0e00f mov lr, pc
3a4c: e12fff13 bx r3
3a50: e1a06000 mov r6, r0
3a54: eaffffe5 b 39f0 <rtems_termios_ioctl+0x68>
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
3a58: e594e008 ldr lr, [r4, #8]
3a5c: e2857030 add r7, r5, #48 ; 0x30
3a60: e8be000f ldm lr!, {r0, r1, r2, r3}
3a64: e1a0c007 mov ip, r7
3a68: e8ac000f stmia ip!, {r0, r1, r2, r3}
3a6c: e8be000f ldm lr!, {r0, r1, r2, r3}
3a70: e8ac000f stmia ip!, {r0, r1, r2, r3}
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
3a74: e59520b8 ldr r2, [r5, #184] ; 0xb8
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
3a78: e59e3000 ldr r3, [lr]
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
3a7c: e3120c02 tst r2, #512 ; 0x200
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
3a80: e58c3000 str r3, [ip]
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
3a84: 0a000012 beq 3ad4 <rtems_termios_ioctl+0x14c>
!(tty->termios.c_iflag & IXON)) {
3a88: e5953030 ldr r3, [r5, #48] ; 0x30
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
3a8c: e3130b01 tst r3, #1024 ; 0x400
3a90: 1a00000f bne 3ad4 <rtems_termios_ioctl+0x14c>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
3a94: e59530b8 ldr r3, [r5, #184] ; 0xb8
3a98: e3c33e21 bic r3, r3, #528 ; 0x210
3a9c: e58530b8 str r3, [r5, #184] ; 0xb8
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
3aa0: e59530b8 ldr r3, [r5, #184] ; 0xb8
3aa4: e3130020 tst r3, #32
3aa8: 0a000009 beq 3ad4 <rtems_termios_ioctl+0x14c>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3aac: e10f8000 mrs r8, CPSR <== NOT EXECUTED
3ab0: e3883080 orr r3, r8, #128 ; 0x80 <== NOT EXECUTED
3ab4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
3ab8: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
3abc: e5952094 ldr r2, [r5, #148] ; 0x94 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
3ac0: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
3ac4: e3520000 cmp r2, #0 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
3ac8: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
3acc: 1a00009c bne 3d44 <rtems_termios_ioctl+0x3bc> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3ad0: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
3ad4: e59530b8 ldr r3, [r5, #184] ; 0xb8
3ad8: e3130b01 tst r3, #1024 ; 0x400
3adc: 0a000008 beq 3b04 <rtems_termios_ioctl+0x17c>
3ae0: e5953030 ldr r3, [r5, #48] ; 0x30
3ae4: e3130a01 tst r3, #4096 ; 0x1000
3ae8: 1a000005 bne 3b04 <rtems_termios_ioctl+0x17c>
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
3aec: e59530b8 ldr r3, [r5, #184] ; 0xb8
3af0: e3c33b01 bic r3, r3, #1024 ; 0x400
3af4: e58530b8 str r3, [r5, #184] ; 0xb8
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
3af8: e59530b8 ldr r3, [r5, #184] ; 0xb8
3afc: e3c33002 bic r3, r3, #2
3b00: e58530b8 str r3, [r5, #184] ; 0xb8
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
3b04: e59530b8 ldr r3, [r5, #184] ; 0xb8
3b08: e3130c01 tst r3, #256 ; 0x100
3b0c: 05952038 ldreq r2, [r5, #56] ; 0x38
3b10: 0a000012 beq 3b60 <rtems_termios_ioctl+0x1d8>
3b14: e5952038 ldr r2, [r5, #56] ; 0x38 <== NOT EXECUTED
3b18: e3520000 cmp r2, #0 <== NOT EXECUTED
3b1c: ba00007c blt 3d14 <rtems_termios_ioctl+0x38c> <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
3b20: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
3b24: e3c33c01 bic r3, r3, #256 ; 0x100 <== NOT EXECUTED
3b28: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
3b2c: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
3b30: e3130004 tst r3, #4 <== NOT EXECUTED
3b34: 0a000006 beq 3b54 <rtems_termios_ioctl+0x1cc> <== NOT EXECUTED
3b38: e59530b0 ldr r3, [r5, #176] ; 0xb0 <== NOT EXECUTED
3b3c: e3530000 cmp r3, #0 <== NOT EXECUTED
3b40: 0a000003 beq 3b54 <rtems_termios_ioctl+0x1cc> <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
3b44: e5950010 ldr r0, [r5, #16] <== NOT EXECUTED
3b48: e1a0e00f mov lr, pc <== NOT EXECUTED
3b4c: e12fff13 bx r3 <== NOT EXECUTED
3b50: e5952038 ldr r2, [r5, #56] ; 0x38 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
3b54: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
3b58: e3c33004 bic r3, r3, #4 <== NOT EXECUTED
3b5c: e58530b8 str r3, [r5, #184] ; 0xb8 <== 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) {
3b60: e3520000 cmp r2, #0
3b64: ba00006a blt 3d14 <rtems_termios_ioctl+0x38c>
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
3b68: e5953030 ldr r3, [r5, #48] ; 0x30
3b6c: e3130a01 tst r3, #4096 ; 0x1000
tty->flow_ctrl |= FL_MDXOF;
3b70: 159520b8 ldrne r2, [r5, #184] ; 0xb8
3b74: 13822b01 orrne r2, r2, #1024 ; 0x400
3b78: 158520b8 strne r2, [r5, #184] ; 0xb8
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
3b7c: e3130b01 tst r3, #1024 ; 0x400
tty->flow_ctrl |= FL_MDXON;
3b80: 159530b8 ldrne r3, [r5, #184] ; 0xb8
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) {
3b84: e595803c ldr r8, [r5, #60] ; 0x3c
if (tty->termios.c_iflag & IXOFF) {
tty->flow_ctrl |= FL_MDXOF;
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
tty->flow_ctrl |= FL_MDXON;
3b88: 13833c02 orrne r3, r3, #512 ; 0x200
3b8c: 158530b8 strne r3, [r5, #184] ; 0xb8
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) {
3b90: e2188002 ands r8, r8, #2
3b94: 0a00004c beq 3ccc <rtems_termios_ioctl+0x344>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
3b98: e3a03000 mov r3, #0
3b9c: e585306c str r3, [r5, #108] ; 0x6c
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
3ba0: e5853070 str r3, [r5, #112] ; 0x70
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
3ba4: e5853074 str r3, [r5, #116] ; 0x74
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
3ba8: e59530a8 ldr r3, [r5, #168] ; 0xa8
3bac: e3530000 cmp r3, #0
3bb0: 0affff8e beq 39f0 <rtems_termios_ioctl+0x68>
(*tty->device.setAttributes)(tty->minor, &tty->termios);
3bb4: e5950010 ldr r0, [r5, #16]
3bb8: e1a01007 mov r1, r7
3bbc: e1a0e00f mov lr, pc
3bc0: e12fff13 bx r3
3bc4: eaffff89 b 39f0 <rtems_termios_ioctl+0x68>
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
3bc8: e5952060 ldr r2, [r5, #96] ; 0x60 <== NOT EXECUTED
3bcc: e595305c ldr r3, [r5, #92] ; 0x5c <== NOT EXECUTED
if ( rawnc < 0 )
3bd0: e0523003 subs r3, r2, r3 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
3bd4: 45952064 ldrmi r2, [r5, #100] ; 0x64 <== NOT EXECUTED
3bd8: 40833002 addmi r3, r3, r2 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
3bdc: e2851020 add r1, r5, #32 <== NOT EXECUTED
3be0: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
3be4: e0412002 sub r2, r1, r2 <== NOT EXECUTED
3be8: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED
3bec: e0823003 add r3, r2, r3 <== NOT EXECUTED
3bf0: e5813000 str r3, [r1] <== NOT EXECUTED
}
break;
3bf4: eaffff7d b 39f0 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
3bf8: e3530001 cmp r3, #1
3bfc: 1affff88 bne 3a24 <rtems_termios_ioctl+0x9c>
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
3c00: e5947008 ldr r7, [r4, #8]
3c04: e285c030 add ip, r5, #48 ; 0x30
3c08: e8bc000f ldm ip!, {r0, r1, r2, r3}
3c0c: e1a0e007 mov lr, r7
3c10: e8ae000f stmia lr!, {r0, r1, r2, r3}
3c14: e8bc000f ldm ip!, {r0, r1, r2, r3}
3c18: e8ae000f stmia lr!, {r0, r1, r2, r3}
3c1c: e59c3000 ldr r3, [ip]
3c20: e58e3000 str r3, [lr]
break;
3c24: eaffff71 b 39f0 <rtems_termios_ioctl+0x68>
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
3c28: e3a02a47 mov r2, #290816 ; 0x47000
3c2c: e2822e41 add r2, r2, #1040 ; 0x410
3c30: e2822129 add r2, r2, #1073741834 ; 0x4000000a
3c34: e1530002 cmp r3, r2
3c38: 0a00001b beq 3cac <rtems_termios_ioctl+0x324>
3c3c: e3a02a47 mov r2, #290816 ; 0x47000
3c40: e2822e41 add r2, r2, #1040 ; 0x410
3c44: e282212e add r2, r2, #-2147483637 ; 0x8000000b
3c48: e1530002 cmp r3, r2
3c4c: 1affff74 bne 3a24 <rtems_termios_ioctl+0x9c>
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
3c50: e59f710c ldr r7, [pc, #268] ; 3d64 <rtems_termios_ioctl+0x3dc>
3c54: e59530cc ldr r3, [r5, #204] ; 0xcc
3c58: e0873283 add r3, r7, r3, lsl #5
3c5c: e5933004 ldr r3, [r3, #4]
3c60: e3530000 cmp r3, #0
3c64: 0a000003 beq 3c78 <rtems_termios_ioctl+0x2f0>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
3c68: e1a00005 mov r0, r5
3c6c: e1a0e00f mov lr, pc
3c70: e12fff13 bx r3
3c74: e1a06000 mov r6, r0
}
tty->t_line=*(int*)(args->buffer);
3c78: e5943008 ldr r3, [r4, #8]
3c7c: e5932000 ldr r2, [r3]
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
3c80: e7973282 ldr r3, [r7, r2, lsl #5]
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
3c84: e58520cc str r2, [r5, #204] ; 0xcc
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
3c88: e3530000 cmp r3, #0
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
tty->t_sc = NULL; /* ensure that no more valid data */
3c8c: e3a02000 mov r2, #0
3c90: e58520d0 str r2, [r5, #208] ; 0xd0
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
3c94: 0affff55 beq 39f0 <rtems_termios_ioctl+0x68>
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
3c98: e1a00005 mov r0, r5
3c9c: e1a0e00f mov lr, pc
3ca0: e12fff13 bx r3
3ca4: e1a06000 mov r6, r0
3ca8: eaffff50 b 39f0 <rtems_termios_ioctl+0x68>
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
3cac: e5943008 ldr r3, [r4, #8]
3cb0: e59520cc ldr r2, [r5, #204] ; 0xcc
3cb4: e5832000 str r2, [r3]
break;
3cb8: eaffff4c b 39f0 <rtems_termios_ioctl+0x68>
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
3cbc: e897000c ldm r7, {r2, r3}
3cc0: e58520d4 str r2, [r5, #212] ; 0xd4
3cc4: e58530d8 str r3, [r5, #216] ; 0xd8
break;
3cc8: eaffff48 b 39f0 <rtems_termios_ioctl+0x68>
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] *
3ccc: e5d5a046 ldrb sl, [r5, #70] ; 0x46
rtems_clock_get_ticks_per_second() / 10;
3cd0: eb00059d bl 534c <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] *
3cd4: e000009a mul r0, sl, r0
rtems_clock_get_ticks_per_second() / 10;
3cd8: e59f3088 ldr r3, [pc, #136] ; 3d68 <rtems_termios_ioctl+0x3e0>
3cdc: e0831390 umull r1, r3, r0, r3
if (tty->termios.c_cc[VTIME]) {
3ce0: e5d52046 ldrb r2, [r5, #70] ; 0x46
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
3ce4: e1a031a3 lsr r3, r3, #3
if (tty->termios.c_cc[VTIME]) {
3ce8: e3520000 cmp r2, #0
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] *
3cec: e5853054 str r3, [r5, #84] ; 0x54
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
3cf0: 0a00000b beq 3d24 <rtems_termios_ioctl+0x39c>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
3cf4: e5d52047 ldrb r2, [r5, #71] ; 0x47
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
3cf8: e3520000 cmp r2, #0
3cfc: 01a02003 moveq r2, r3
3d00: 13a02000 movne r2, #0
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
3d04: e585806c str r8, [r5, #108] ; 0x6c
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
3d08: e5853070 str r3, [r5, #112] ; 0x70
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
3d0c: e5852074 str r2, [r5, #116] ; 0x74
3d10: eaffffa4 b 3ba8 <rtems_termios_ioctl+0x220>
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
tty->flow_ctrl |= FL_MDRTS;
3d14: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
3d18: e3833c01 orr r3, r3, #256 ; 0x100 <== NOT EXECUTED
3d1c: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
3d20: eaffff90 b 3b68 <rtems_termios_ioctl+0x1e0> <== NOT EXECUTED
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
3d24: e5d53047 ldrb r3, [r5, #71] ; 0x47
3d28: e3530000 cmp r3, #0
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
3d2c: 03a03001 moveq r3, #1
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
3d30: 1585206c strne r2, [r5, #108] ; 0x6c
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
3d34: 15852070 strne r2, [r5, #112] ; 0x70
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
3d38: 15852074 strne r2, [r5, #116] ; 0x74
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
3d3c: 0585306c streq r3, [r5, #108] ; 0x6c
3d40: eaffff98 b 3ba8 <rtems_termios_ioctl+0x220>
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)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
3d44: e5953084 ldr r3, [r5, #132] ; 0x84 <== 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)(
3d48: e595107c ldr r1, [r5, #124] ; 0x7c <== NOT EXECUTED
3d4c: e5950010 ldr r0, [r5, #16] <== NOT EXECUTED
3d50: e0811003 add r1, r1, r3 <== NOT EXECUTED
3d54: e3a02001 mov r2, #1 <== NOT EXECUTED
3d58: e1a0e00f mov lr, pc <== NOT EXECUTED
3d5c: e595f0a4 ldr pc, [r5, #164] ; 0xa4 <== NOT EXECUTED
3d60: eaffff5a b 3ad0 <rtems_termios_ioctl+0x148> <== NOT EXECUTED
000032d8 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
32d8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
32dc: e59f74b4 ldr r7, [pc, #1204] ; 3798 <rtems_termios_open+0x4c0>
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
32e0: e1a06001 mov r6, r1
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
32e4: e3a01000 mov r1, #0
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
32e8: e24dd01c sub sp, sp, #28
32ec: e1a05000 mov r5, r0
32f0: e1a08002 mov r8, r2
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
32f4: e5970000 ldr r0, [r7]
32f8: e1a02001 mov r2, r1
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
32fc: e58d3014 str r3, [sp, #20]
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
3300: eb0009bd bl 59fc <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
3304: e250a000 subs sl, r0, #0
3308: 1a000021 bne 3394 <rtems_termios_open+0xbc>
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
330c: e59fb488 ldr fp, [pc, #1160] ; 379c <rtems_termios_open+0x4c4>
3310: e59b9000 ldr r9, [fp]
3314: e3590000 cmp r9, #0
3318: 0a00002d beq 33d4 <rtems_termios_open+0xfc>
331c: e1a04009 mov r4, r9
3320: ea000002 b 3330 <rtems_termios_open+0x58>
3324: e5944000 ldr r4, [r4]
3328: e3540000 cmp r4, #0
332c: 0a000028 beq 33d4 <rtems_termios_open+0xfc>
if ((tty->major == major) && (tty->minor == minor))
3330: e594300c ldr r3, [r4, #12]
3334: e1530005 cmp r3, r5
3338: 1afffff9 bne 3324 <rtems_termios_open+0x4c>
333c: e5943010 ldr r3, [r4, #16]
3340: e1530006 cmp r3, r6
3344: 1afffff6 bne 3324 <rtems_termios_open+0x4c>
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
if (!tty->refcount++) {
3348: e5943008 ldr r3, [r4, #8]
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
334c: e5981000 ldr r1, [r8]
if (!tty->refcount++) {
3350: e2832001 add r2, r3, #1
3354: e3530000 cmp r3, #0
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
3358: e5814034 str r4, [r1, #52] ; 0x34
if (!tty->refcount++) {
335c: e5842008 str r2, [r4, #8]
3360: 1a000009 bne 338c <rtems_termios_open+0xb4>
if (tty->device.firstOpen)
3364: e5943098 ldr r3, [r4, #152] ; 0x98
3368: e3530000 cmp r3, #0
(*tty->device.firstOpen)(major, minor, arg);
336c: 11a00005 movne r0, r5
3370: 11a01006 movne r1, r6
3374: 11a02008 movne r2, r8
3378: 11a0e00f movne lr, pc
337c: 112fff13 bxne r3
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
3380: e59430b4 ldr r3, [r4, #180] ; 0xb4
3384: e3530002 cmp r3, #2
3388: 0a000004 beq 33a0 <rtems_termios_open+0xc8>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
338c: e5970000 ldr r0, [r7]
3390: eb0009e2 bl 5b20 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
3394: e1a0000a mov r0, sl
3398: e28dd01c add sp, sp, #28
339c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_start(
33a0: e59400c4 ldr r0, [r4, #196] ; 0xc4
33a4: e59f13f4 ldr r1, [pc, #1012] ; 37a0 <rtems_termios_open+0x4c8>
33a8: e1a02004 mov r2, r4
33ac: eb000aaf bl 5e70 <rtems_task_start>
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
33b0: e3500000 cmp r0, #0
33b4: 1a0000da bne 3724 <rtems_termios_open+0x44c>
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
33b8: e59400c8 ldr r0, [r4, #200] ; 0xc8
33bc: e59f13e0 ldr r1, [pc, #992] ; 37a4 <rtems_termios_open+0x4cc>
33c0: e1a02004 mov r2, r4
33c4: eb000aa9 bl 5e70 <rtems_task_start>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
33c8: e3500000 cmp r0, #0
33cc: 0affffee beq 338c <rtems_termios_open+0xb4>
33d0: ea0000d3 b 3724 <rtems_termios_open+0x44c> <== NOT EXECUTED
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
33d4: e3a00001 mov r0, #1
33d8: e3a010e8 mov r1, #232 ; 0xe8
33dc: ebfffb55 bl 2138 <calloc>
if (tty == NULL) {
33e0: e3500000 cmp r0, #0
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
33e4: e58d0018 str r0, [sp, #24]
33e8: e1a04000 mov r4, r0
if (tty == NULL) {
33ec: 0a0000b7 beq 36d0 <rtems_termios_open+0x3f8>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
33f0: e59f03b0 ldr r0, [pc, #944] ; 37a8 <rtems_termios_open+0x4d0>
33f4: e59d1018 ldr r1, [sp, #24]
33f8: e5903000 ldr r3, [r0]
33fc: e5813064 str r3, [r1, #100] ; 0x64
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
3400: e5910064 ldr r0, [r1, #100] ; 0x64
3404: ebfffc92 bl 2654 <malloc>
3408: e59d2018 ldr r2, [sp, #24]
if (tty->rawInBuf.theBuf == NULL) {
340c: e3500000 cmp r0, #0
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
3410: e1a03000 mov r3, r0
3414: e5820058 str r0, [r2, #88] ; 0x58
if (tty->rawInBuf.theBuf == NULL) {
3418: 0a0000b0 beq 36e0 <rtems_termios_open+0x408>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
341c: e59fc384 ldr ip, [pc, #900] ; 37a8 <rtems_termios_open+0x4d0>
3420: e59de018 ldr lr, [sp, #24]
3424: e59c2004 ldr r2, [ip, #4]
3428: e58e2088 str r2, [lr, #136] ; 0x88
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
342c: e59e0088 ldr r0, [lr, #136] ; 0x88
3430: e58d300c str r3, [sp, #12]
3434: ebfffc86 bl 2654 <malloc>
3438: e1a02000 mov r2, r0
if (tty->rawOutBuf.theBuf == NULL) {
343c: e3500000 cmp r0, #0
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
3440: e59d0018 ldr r0, [sp, #24]
if (tty->rawOutBuf.theBuf == NULL) {
3444: e59d300c ldr r3, [sp, #12]
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
3448: e580207c str r2, [r0, #124] ; 0x7c
if (tty->rawOutBuf.theBuf == NULL) {
344c: 0a00009b beq 36c0 <rtems_termios_open+0x3e8>
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
3450: e59f1350 ldr r1, [pc, #848] ; 37a8 <rtems_termios_open+0x4d0>
3454: e5910008 ldr r0, [r1, #8]
3458: e58d2010 str r2, [sp, #16]
345c: e58d300c str r3, [sp, #12]
3460: ebfffc7b bl 2654 <malloc>
3464: e59dc018 ldr ip, [sp, #24]
if (tty->cbuf == NULL) {
3468: e3500000 cmp r0, #0
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
346c: e58c001c str r0, [ip, #28]
if (tty->cbuf == NULL) {
3470: e59d2010 ldr r2, [sp, #16]
3474: 0a00008e beq 36b4 <rtems_termios_open+0x3dc>
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
3478: e59de018 ldr lr, [sp, #24]
347c: e3a03000 mov r3, #0
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
3480: e1590003 cmp r9, r3
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
3484: e58e3004 str r3, [lr, #4]
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
3488: e58e30d4 str r3, [lr, #212] ; 0xd4
tty->tty_snd.sw_arg = NULL;
348c: e58e30d8 str r3, [lr, #216] ; 0xd8
tty->tty_rcv.sw_pfn = NULL;
3490: e58e30dc str r3, [lr, #220] ; 0xdc
tty->tty_rcv.sw_arg = NULL;
3494: e58e30e0 str r3, [lr, #224] ; 0xe0
tty->tty_rcvwakeup = 0;
3498: e58e30e4 str r3, [lr, #228] ; 0xe4
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
349c: e59f3308 ldr r3, [pc, #776] ; 37ac <rtems_termios_open+0x4d4>
34a0: e5932000 ldr r2, [r3]
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
34a4: e59d0018 ldr r0, [sp, #24]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
34a8: e59f12f8 ldr r1, [pc, #760] ; 37a8 <rtems_termios_open+0x4d0>
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
34ac: 1589e004 strne lr, [r9, #4]
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
34b0: e3520000 cmp r2, #0
rtems_termios_ttyTail = tty;
34b4: 05830000 streq r0, [r3]
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
34b8: e58b0000 str r0, [fp]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
34bc: e5d1000c ldrb r0, [r1, #12]
tty->tty_rcvwakeup = 0;
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
34c0: e58e9000 str r9, [lr]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
34c4: e59d2018 ldr r2, [sp, #24]
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
34c8: e59d9018 ldr r9, [sp, #24]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
34cc: e3800315 orr r0, r0, #1409286144 ; 0x54000000
34d0: e3800852 orr r0, r0, #5373952 ; 0x520000
34d4: e282c014 add ip, r2, #20
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
34d8: e5896010 str r6, [r9, #16]
tty->major = major;
34dc: e589500c str r5, [r9, #12]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
34e0: e3a03000 mov r3, #0
34e4: e3800c69 orr r0, r0, #26880 ; 0x6900
34e8: e3a01001 mov r1, #1
34ec: e3a02054 mov r2, #84 ; 0x54
34f0: e58dc000 str ip, [sp]
34f4: eb0008a6 bl 5794 <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)
34f8: e2503000 subs r3, r0, #0
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
34fc: e59f92a4 ldr r9, [pc, #676] ; 37a8 <rtems_termios_open+0x4d0>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
3500: 1a000087 bne 3724 <rtems_termios_open+0x44c>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'o', c),
3504: e5d9000c ldrb r0, [r9, #12]
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 (
3508: e59db018 ldr fp, [sp, #24]
350c: e3800315 orr r0, r0, #1409286144 ; 0x54000000
3510: e3800852 orr r0, r0, #5373952 ; 0x520000
3514: e28bc018 add ip, fp, #24
3518: e3a01001 mov r1, #1
351c: e3800c6f orr r0, r0, #28416 ; 0x6f00
3520: e3a02054 mov r2, #84 ; 0x54
3524: e58dc000 str ip, [sp]
3528: eb000899 bl 5794 <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)
352c: e2501000 subs r1, r0, #0
3530: 1a00007b bne 3724 <rtems_termios_open+0x44c>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'x', c),
3534: e5d9000c ldrb r0, [r9, #12]
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 (
3538: e59de018 ldr lr, [sp, #24]
353c: e3800315 orr r0, r0, #1409286144 ; 0x54000000
3540: e3800852 orr r0, r0, #5373952 ; 0x520000
3544: e28ec08c add ip, lr, #140 ; 0x8c
3548: e3800b1e orr r0, r0, #30720 ; 0x7800
354c: e3a02020 mov r2, #32
3550: e1a03001 mov r3, r1
3554: e58dc000 str ip, [sp]
3558: eb00088d bl 5794 <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)
355c: e250e000 subs lr, r0, #0
3560: 1a00006f bne 3724 <rtems_termios_open+0x44c>
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
3564: e59db014 ldr fp, [sp, #20]
3568: e8bb000f ldm fp!, {r0, r1, r2, r3}
356c: e58db014 str fp, [sp, #20]
3570: e59db018 ldr fp, [sp, #24]
3574: e28bc098 add ip, fp, #152 ; 0x98
3578: e8ac000f stmia ip!, {r0, r1, r2, r3}
357c: e59db014 ldr fp, [sp, #20]
3580: e89b000f ldm fp, {r0, r1, r2, r3}
3584: e88c000f stm ip, {r0, r1, r2, r3}
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
3588: e59dc018 ldr ip, [sp, #24]
358c: e59c30b4 ldr r3, [ip, #180] ; 0xb4
3590: e3530002 cmp r3, #2
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
3594: e58ce094 str lr, [ip, #148] ; 0x94
tty->device = *callbacks;
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
3598: 0a000062 beq 3728 <rtems_termios_open+0x450>
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
359c: e59d9018 ldr r9, [sp, #24]
35a0: e59930a0 ldr r3, [r9, #160] ; 0xa0
35a4: e3530000 cmp r3, #0
35a8: 0a00004f beq 36ec <rtems_termios_open+0x414>
35ac: e59930b4 ldr r3, [r9, #180] ; 0xb4
35b0: e3530002 cmp r3, #2
35b4: 0a00004c beq 36ec <rtems_termios_open+0x414>
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
35b8: e59d0018 ldr r0, [sp, #24]
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
35bc: e3a03000 mov r3, #0
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
35c0: e58030b8 str r3, [r0, #184] ; 0xb8
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
35c4: e59f11dc ldr r1, [pc, #476] ; 37a8 <rtems_termios_open+0x4d0>
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
35c8: e590b064 ldr fp, [r0, #100] ; 0x64
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
35cc: e5d1900c ldrb r9, [r1, #12]
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
35d0: e1a0b0ab lsr fp, fp, #1
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
35d4: e359007a cmp r9, #122 ; 0x7a
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
35d8: e58db008 str fp, [sp, #8]
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
35dc: e289b001 add fp, r9, #1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
35e0: e59d9018 ldr r9, [sp, #24]
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
35e4: e3a02c82 mov r2, #33280 ; 0x8200
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
35e8: e5c9304c strb r3, [r9, #76] ; 0x4c
tty->termios.c_cc[VEOL2] = '\000';
35ec: e5c93051 strb r3, [r9, #81] ; 0x51
tty->termios.c_cc[VSTART] = '\021';
35f0: e3a03011 mov r3, #17
35f4: e5c93049 strb r3, [r9, #73] ; 0x49
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
35f8: e282203b add r2, r2, #59 ; 0x3b
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
35fc: e3a03013 mov r3, #19
3600: e5c9304a strb r3, [r9, #74] ; 0x4a
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
3604: e589203c str r2, [r9, #60] ; 0x3c
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
3608: e3a0301a mov r3, #26
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
360c: e3a02003 mov r2, #3
3610: e5c92041 strb r2, [r9, #65] ; 0x41
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
3614: e5c9304b strb r3, [r9, #75] ; 0x4b
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
3618: e590e064 ldr lr, [r0, #100] ; 0x64
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
361c: e3a0201c mov r2, #28
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
3620: e3a03012 mov r3, #18
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
3624: e5c92042 strb r2, [r9, #66] ; 0x42
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
3628: e5c9304d strb r3, [r9, #77] ; 0x4d
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
362c: e3a0207f mov r2, #127 ; 0x7f
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
3630: e3a0300f mov r3, #15
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
3634: e5c92043 strb r2, [r9, #67] ; 0x43
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
3638: e5c9304e strb r3, [r9, #78] ; 0x4e
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
363c: e3a02015 mov r2, #21
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
3640: e3a03017 mov r3, #23
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
3644: e08ee08e add lr, lr, lr, lsl #1
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
3648: e5c92044 strb r2, [r9, #68] ; 0x44
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
364c: e5c9304f strb r3, [r9, #79] ; 0x4f
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
3650: e3a02004 mov r2, #4
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
3654: e3a03016 mov r3, #22
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
3658: e1a0e12e lsr lr, lr, #2
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
365c: e3a0cc25 mov ip, #9472 ; 0x2500
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
3660: e5c92045 strb r2, [r9, #69] ; 0x45
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
3664: e5c93050 strb r3, [r9, #80] ; 0x50
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
3668: e28cc002 add ip, ip, #2
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
366c: e58db014 str fp, [sp, #20]
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
3670: e589e0c0 str lr, [r9, #192] ; 0xc0
/*
* Bump name characer
*/
if (c++ == 'z')
3674: e59fe12c ldr lr, [pc, #300] ; 37a8 <rtems_termios_open+0x4d0>
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
3678: e3a00b06 mov r0, #6144 ; 0x1800
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
367c: e3a01e8b mov r1, #2224 ; 0x8b0
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
3680: e589c030 str ip, [r9, #48] ; 0x30
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
3684: e59db008 ldr fp, [sp, #8]
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
3688: e59dc014 ldr ip, [sp, #20]
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
368c: e2800005 add r0, r0, #5
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
3690: e281100d add r1, r1, #13
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
3694: 0282205d addeq r2, r2, #93 ; 0x5d
3698: 01a0300e moveq r3, lr
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
369c: e5cec00c strb ip, [lr, #12]
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
36a0: e5890034 str r0, [r9, #52] ; 0x34
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
36a4: e5891038 str r1, [r9, #56] ; 0x38
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
36a8: e589b0bc str fp, [r9, #188] ; 0xbc
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
36ac: 05c3200c strbeq r2, [r3, #12]
36b0: eaffff24 b 3348 <rtems_termios_open+0x70>
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
36b4: e1a00002 mov r0, r2 <== NOT EXECUTED
36b8: ebfffb0b bl 22ec <free> <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
36bc: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
36c0: e1a00003 mov r0, r3
36c4: ebfffb08 bl 22ec <free>
free(tty);
36c8: e59d0018 ldr r0, [sp, #24]
36cc: ebfffb06 bl 22ec <free>
rtems_semaphore_release (rtems_termios_ttyMutex);
36d0: e5970000 ldr r0, [r7]
36d4: eb000911 bl 5b20 <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
36d8: e3a0a01a mov sl, #26
36dc: eaffff2c b 3394 <rtems_termios_open+0xbc>
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
if (tty->rawInBuf.theBuf == NULL) {
free(tty);
36e0: e1a00002 mov r0, r2
36e4: ebfffb00 bl 22ec <free>
36e8: eafffff8 b 36d0 <rtems_termios_open+0x3f8>
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'r', c),
36ec: e59fb0b4 ldr fp, [pc, #180] ; 37a8 <rtems_termios_open+0x4d0>
36f0: e5db000c ldrb r0, [fp, #12]
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
36f4: e59de018 ldr lr, [sp, #24]
36f8: e3800315 orr r0, r0, #1409286144 ; 0x54000000
36fc: e3a01000 mov r1, #0
3700: e3800852 orr r0, r0, #5373952 ; 0x520000
3704: e28ec068 add ip, lr, #104 ; 0x68
3708: e3800c72 orr r0, r0, #29184 ; 0x7200
370c: e3a02024 mov r2, #36 ; 0x24
3710: e1a03001 mov r3, r1
3714: e58dc000 str ip, [sp]
3718: eb00081d bl 5794 <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)
371c: e3500000 cmp r0, #0
3720: 0affffa4 beq 35b8 <rtems_termios_open+0x2e0>
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
3724: eb000a5c bl 609c <rtems_fatal_error_occurred>
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
rtems_build_name ('T', 'x', 'T', c),
3728: e5d9000c ldrb r0, [r9, #12]
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
372c: e3800315 orr r0, r0, #1409286144 ; 0x54000000
3730: e380071e orr r0, r0, #7864320 ; 0x780000
3734: e28cc0c8 add ip, ip, #200 ; 0xc8
3738: e3800b15 orr r0, r0, #21504 ; 0x5400
373c: e3a0100a mov r1, #10
3740: e3a02b01 mov r2, #1024 ; 0x400
3744: e3a03c05 mov r3, #1280 ; 0x500
3748: e58de000 str lr, [sp]
374c: e58dc004 str ip, [sp, #4]
3750: eb00091c bl 5bc8 <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)
3754: e250e000 subs lr, r0, #0
3758: 1afffff1 bne 3724 <rtems_termios_open+0x44c>
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
rtems_build_name ('R', 'x', 'T', c),
375c: e5d9000c ldrb r0, [r9, #12]
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
3760: e59d2018 ldr r2, [sp, #24]
3764: e3800452 orr r0, r0, #1375731712 ; 0x52000000
3768: e380071e orr r0, r0, #7864320 ; 0x780000
376c: e282c0c4 add ip, r2, #196 ; 0xc4
3770: e3800b15 orr r0, r0, #21504 ; 0x5400
3774: e3a01009 mov r1, #9
3778: e3a02b01 mov r2, #1024 ; 0x400
377c: e3a03c05 mov r3, #1280 ; 0x500
3780: e58de000 str lr, [sp]
3784: e58dc004 str ip, [sp, #4]
3788: eb00090e bl 5bc8 <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)
378c: e3500000 cmp r0, #0
3790: 0affff81 beq 359c <rtems_termios_open+0x2c4>
3794: eaffffe2 b 3724 <rtems_termios_open+0x44c> <== NOT EXECUTED
00003d6c <rtems_termios_puts>:
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
3d6c: e59230b4 ldr r3, [r2, #180] ; 0xb4
3d70: e3530000 cmp r3, #0
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
3d74: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
3d78: e1a04002 mov r4, r2
3d7c: e1a0a000 mov sl, r0
3d80: e1a08001 mov r8, r1
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
3d84: 0a000038 beq 3e6c <rtems_termios_puts+0x100>
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
3d88: e3510000 cmp r1, #0
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
3d8c: e5927080 ldr r7, [r2, #128] ; 0x80
while (len) {
3d90: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc}
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
3d94: e3a06002 mov r6, #2
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
}
tty->rawOutBufState = rob_busy;
3d98: e3a09001 mov r9, #1
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
3d9c: e5941088 ldr r1, [r4, #136] ; 0x88
3da0: e2870001 add r0, r7, #1
3da4: eb003667 bl 11748 <__umodsi3>
3da8: e1a07000 mov r7, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3dac: e10f3000 mrs r3, CPSR
3db0: e3832080 orr r2, r3, #128 ; 0x80
3db4: e129f002 msr CPSR_fc, r2
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
3db8: e5945084 ldr r5, [r4, #132] ; 0x84
3dbc: e1550000 cmp r5, r0
3dc0: 1a00000d bne 3dfc <rtems_termios_puts+0x90>
tty->rawOutBufState = rob_wait;
3dc4: e5846094 str r6, [r4, #148] ; 0x94
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3dc8: e129f003 msr CPSR_fc, r3
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
3dcc: e3a01000 mov r1, #0
3dd0: e594008c ldr r0, [r4, #140] ; 0x8c
3dd4: e1a02001 mov r2, r1
3dd8: eb000707 bl 59fc <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
3ddc: e3500000 cmp r0, #0
3de0: 1a000027 bne 3e84 <rtems_termios_puts+0x118>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3de4: e10f3000 mrs r3, CPSR
3de8: e3832080 orr r2, r3, #128 ; 0x80
3dec: e129f002 msr CPSR_fc, r2
* 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) {
3df0: e5942084 ldr r2, [r4, #132] ; 0x84
3df4: e1520005 cmp r2, r5
3df8: 0afffff1 beq 3dc4 <rtems_termios_puts+0x58>
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++;
3dfc: e4da1001 ldrb r1, [sl], #1
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
3e00: e1a05003 mov r5, r3
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++;
3e04: e594207c ldr r2, [r4, #124] ; 0x7c
3e08: e5943080 ldr r3, [r4, #128] ; 0x80
3e0c: e7c21003 strb r1, [r2, r3]
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
3e10: e5943094 ldr r3, [r4, #148] ; 0x94
3e14: e3530000 cmp r3, #0
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
3e18: e5847080 str r7, [r4, #128] ; 0x80
if (tty->rawOutBufState == rob_idle) {
3e1c: 1a000006 bne 3e3c <rtems_termios_puts+0xd0>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
3e20: e59430b8 ldr r3, [r4, #184] ; 0xb8
3e24: e3130010 tst r3, #16
3e28: 0a000007 beq 3e4c <rtems_termios_puts+0xe0>
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
3e2c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3e30: e3833020 orr r3, r3, #32 <== NOT EXECUTED
3e34: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
3e38: e5849094 str r9, [r4, #148] ; 0x94
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3e3c: e129f005 msr CPSR_fc, r5
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
3e40: e2588001 subs r8, r8, #1
3e44: 1affffd4 bne 3d9c <rtems_termios_puts+0x30>
3e48: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
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,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
3e4c: e5943084 ldr r3, [r4, #132] ; 0x84
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,
3e50: e594107c ldr r1, [r4, #124] ; 0x7c
3e54: e5940010 ldr r0, [r4, #16]
3e58: e0811003 add r1, r1, r3
3e5c: e3a02001 mov r2, #1
3e60: e1a0e00f mov lr, pc
3e64: e594f0a4 ldr pc, [r4, #164] ; 0xa4
3e68: eafffff2 b 3e38 <rtems_termios_puts+0xcc>
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);
3e6c: e5920010 ldr r0, [r2, #16]
3e70: e1a0100a mov r1, sl
3e74: e1a02008 mov r2, r8
3e78: e1a0e00f mov lr, pc
3e7c: e594f0a4 ldr pc, [r4, #164] ; 0xa4
return;
3e80: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
3e84: eb000884 bl 609c <rtems_fatal_error_occurred> <== NOT EXECUTED
000045a4 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
45a4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
45a8: e5903000 ldr r3, [r0]
45ac: e5934034 ldr r4, [r3, #52] ; 0x34
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
45b0: e3a01000 mov r1, #0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
45b4: e1a09000 mov r9, r0
45b8: e24dd008 sub sp, sp, #8
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
45bc: e5940014 ldr r0, [r4, #20]
45c0: e1a02001 mov r2, r1
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
45c4: e5998010 ldr r8, [r9, #16]
char *buffer = args->buffer;
45c8: e599a00c ldr sl, [r9, #12]
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
45cc: eb00050a bl 59fc <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
45d0: e3500000 cmp r0, #0
45d4: e58d0000 str r0, [sp]
45d8: 1a00000e bne 4618 <rtems_termios_read+0x74>
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
45dc: e59420cc ldr r2, [r4, #204] ; 0xcc
45e0: e59f3370 ldr r3, [pc, #880] ; 4958 <rtems_termios_read+0x3b4>
45e4: e0833282 add r3, r3, r2, lsl #5
45e8: e5933008 ldr r3, [r3, #8]
45ec: e3530000 cmp r3, #0
45f0: 0a00000b beq 4624 <rtems_termios_read+0x80>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
45f4: e1a00004 mov r0, r4
45f8: e1a01009 mov r1, r9
45fc: e1a0e00f mov lr, pc
4600: e12fff13 bx r3
tty->tty_rcvwakeup = 0;
4604: e3a03000 mov r3, #0
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
4608: e58d0000 str r0, [sp]
tty->tty_rcvwakeup = 0;
460c: e58430e4 str r3, [r4, #228] ; 0xe4
rtems_semaphore_release (tty->isem);
4610: e5940014 ldr r0, [r4, #20]
4614: eb000541 bl 5b20 <rtems_semaphore_release>
} args->bytes_moved = args->count - count; tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); return sc; }
4618: e59d0000 ldr r0, [sp]
461c: e28dd008 add sp, sp, #8
4620: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
4624: e5942024 ldr r2, [r4, #36] ; 0x24
4628: e5943020 ldr r3, [r4, #32]
462c: e1520003 cmp r2, r3
4630: 0a000018 beq 4698 <rtems_termios_read+0xf4>
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
4634: e3580000 cmp r8, #0
4638: 0a00000e beq 4678 <rtems_termios_read+0xd4>
463c: e2842020 add r2, r4, #32
4640: e892000c ldm r2, {r2, r3}
4644: e1530002 cmp r3, r2
4648: ba000003 blt 465c <rtems_termios_read+0xb8>
464c: ea000009 b 4678 <rtems_termios_read+0xd4> <== NOT EXECUTED
4650: e5942020 ldr r2, [r4, #32]
4654: e1520003 cmp r2, r3
4658: da000006 ble 4678 <rtems_termios_read+0xd4>
*buffer++ = tty->cbuf[tty->cindex++];
465c: e594201c ldr r2, [r4, #28]
4660: e7d22003 ldrb r2, [r2, r3]
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
4664: e2588001 subs r8, r8, #1
*buffer++ = tty->cbuf[tty->cindex++];
4668: e2833001 add r3, r3, #1
466c: e4ca2001 strb r2, [sl], #1
4670: e5843024 str r3, [r4, #36] ; 0x24
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
4674: 1afffff5 bne 4650 <rtems_termios_read+0xac>
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
4678: e5993010 ldr r3, [r9, #16]
467c: e0688003 rsb r8, r8, r3
tty->tty_rcvwakeup = 0;
4680: e3a03000 mov r3, #0
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
4684: e5898018 str r8, [r9, #24]
tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem);
4688: e5940014 ldr r0, [r4, #20]
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
tty->tty_rcvwakeup = 0;
468c: e58430e4 str r3, [r4, #228] ; 0xe4
rtems_semaphore_release (tty->isem);
4690: eb000522 bl 5b20 <rtems_semaphore_release>
return sc;
4694: eaffffdf b 4618 <rtems_termios_read+0x74>
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
4698: e59430a0 ldr r3, [r4, #160] ; 0xa0
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
469c: e59d1000 ldr r1, [sp]
tty->read_start_column = tty->column;
46a0: e5942028 ldr r2, [r4, #40] ; 0x28
if (tty->device.pollRead != NULL &&
46a4: e3530000 cmp r3, #0
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
46a8: e5841020 str r1, [r4, #32]
46ac: e5841024 str r1, [r4, #36] ; 0x24
tty->read_start_column = tty->column;
46b0: e584202c str r2, [r4, #44] ; 0x2c
if (tty->device.pollRead != NULL &&
46b4: 0a000002 beq 46c4 <rtems_termios_read+0x120>
46b8: e59420b4 ldr r2, [r4, #180] ; 0xb4
46bc: e3520000 cmp r2, #0
46c0: 0a000068 beq 4868 <rtems_termios_read+0x2c4>
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)(
46c4: e2843049 add r3, r4, #73 ; 0x49
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
46c8: e3a0bc02 mov fp, #512 ; 0x200
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
46cc: e5946074 ldr r6, [r4, #116] ; 0x74
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
46d0: e59f7284 ldr r7, [pc, #644] ; 495c <rtems_termios_read+0x3b8>
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)(
46d4: e58d3004 str r3, [sp, #4]
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
rtems_status_code sc;
int wait = (int)1;
46d8: e3a05001 mov r5, #1
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
46dc: e28bb002 add fp, fp, #2
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
46e0: e594205c ldr r2, [r4, #92] ; 0x5c
46e4: e5943060 ldr r3, [r4, #96] ; 0x60
46e8: e1520003 cmp r2, r3
46ec: 0a000048 beq 4814 <rtems_termios_read+0x270>
(tty->ccount < (CBUFSIZE-1))) {
46f0: e5972008 ldr r2, [r7, #8]
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
46f4: e5943020 ldr r3, [r4, #32]
(tty->ccount < (CBUFSIZE-1))) {
46f8: e2422001 sub r2, r2, #1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
46fc: e1520003 cmp r2, r3
4700: ca00000f bgt 4744 <rtems_termios_read+0x1a0>
4704: ea000042 b 4814 <rtems_termios_read+0x270> <== NOT EXECUTED
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
4708: e1a00006 mov r0, r6
470c: e1a01004 mov r1, r4
4710: ebffff57 bl 4474 <siproc>
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
4714: e594205c ldr r2, [r4, #92] ; 0x5c
4718: e5943060 ldr r3, [r4, #96] ; 0x60
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
471c: e3500000 cmp r0, #0
4720: 13a05000 movne r5, #0
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
4724: e1520003 cmp r2, r3
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
4728: e5946070 ldr r6, [r4, #112] ; 0x70
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
472c: 0a000038 beq 4814 <rtems_termios_read+0x270>
(tty->ccount < (CBUFSIZE-1))) {
4730: e5973008 ldr r3, [r7, #8]
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
4734: e5942020 ldr r2, [r4, #32]
(tty->ccount < (CBUFSIZE-1))) {
4738: e2433001 sub r3, r3, #1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
473c: e1520003 cmp r2, r3
4740: aa000033 bge 4814 <rtems_termios_read+0x270>
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
4744: e594005c ldr r0, [r4, #92] ; 0x5c
4748: e5941064 ldr r1, [r4, #100] ; 0x64
474c: e2800001 add r0, r0, #1
4750: eb0033fc bl 11748 <__umodsi3>
c = tty->rawInBuf.theBuf[newHead];
4754: e5943058 ldr r3, [r4, #88] ; 0x58
4758: e7d36000 ldrb r6, [r3, r0]
tty->rawInBuf.Head = newHead;
475c: e584005c str r0, [r4, #92] ; 0x5c
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
4760: e5943060 ldr r3, [r4, #96] ; 0x60
4764: e5942064 ldr r2, [r4, #100] ; 0x64
4768: e0823003 add r3, r2, r3
% tty->rawInBuf.Size)
476c: e0600003 rsb r0, r0, r3
4770: e5941064 ldr r1, [r4, #100] ; 0x64
4774: eb0033f3 bl 11748 <__umodsi3>
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)
4778: e59430bc ldr r3, [r4, #188] ; 0xbc
477c: e1500003 cmp r0, r3
4780: 2a000014 bcs 47d8 <rtems_termios_read+0x234>
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
4784: e59430b8 ldr r3, [r4, #184] ; 0xb8
4788: e3c33001 bic r3, r3, #1
478c: e58430b8 str r3, [r4, #184] ; 0xb8
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
4790: e59430b8 ldr r3, [r4, #184] ; 0xb8
4794: e3c33f7f bic r3, r3, #508 ; 0x1fc
4798: e3c33001 bic r3, r3, #1
479c: e1a03b03 lsl r3, r3, #22
47a0: e1a03b23 lsr r3, r3, #22
47a4: e153000b cmp r3, fp
47a8: 0a000022 beq 4838 <rtems_termios_read+0x294>
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
47ac: e59430b8 ldr r3, [r4, #184] ; 0xb8
47b0: e3130c01 tst r3, #256 ; 0x100
47b4: 0a000007 beq 47d8 <rtems_termios_read+0x234>
tty->flow_ctrl &= ~FL_IRTSOFF;
47b8: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
47bc: e59430b0 ldr r3, [r4, #176] ; 0xb0 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
47c0: e3c22004 bic r2, r2, #4 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
47c4: e3530000 cmp r3, #0 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
47c8: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
tty->device.startRemoteTx(tty->minor);
47cc: 15940010 ldrne r0, [r4, #16] <== NOT EXECUTED
47d0: 11a0e00f movne lr, pc <== NOT EXECUTED
47d4: 112fff13 bxne r3 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
47d8: e594303c ldr r3, [r4, #60] ; 0x3c
47dc: e3130002 tst r3, #2
47e0: 1affffc8 bne 4708 <rtems_termios_read+0x164>
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
47e4: e1a00006 mov r0, r6 <== NOT EXECUTED
47e8: e1a01004 mov r1, r4 <== NOT EXECUTED
47ec: ebffff20 bl 4474 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
47f0: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED
47f4: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
wait = 0;
47f8: e1520003 cmp r2, r3 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
47fc: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED
4800: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
4804: a3a05000 movge r5, #0 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
4808: e1520003 cmp r2, r3 <== NOT EXECUTED
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
480c: e5946070 ldr r6, [r4, #112] ; 0x70 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
4810: 1affffc6 bne 4730 <rtems_termios_read+0x18c> <== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
4814: e3550000 cmp r5, #0
4818: 0affff85 beq 4634 <rtems_termios_read+0x90>
sc = rtems_semaphore_obtain(
481c: e2840068 add r0, r4, #104 ; 0x68
4820: e8900003 ldm r0, {r0, r1}
4824: e1a02006 mov r2, r6
4828: eb000473 bl 59fc <rtems_semaphore_obtain>
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
482c: e3500000 cmp r0, #0
4830: 0affffaa beq 46e0 <rtems_termios_read+0x13c>
4834: eaffff7e b 4634 <rtems_termios_read+0x90> <== NOT EXECUTED
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
4838: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
483c: e3530000 cmp r3, #0 <== NOT EXECUTED
4840: 0a000002 beq 4850 <rtems_termios_read+0x2ac> <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
4844: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4848: e3130020 tst r3, #32 <== NOT EXECUTED
484c: 0affffd6 beq 47ac <rtems_termios_read+0x208> <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
4850: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
4854: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
4858: e3a02001 mov r2, #1 <== NOT EXECUTED
485c: e1a0e00f mov lr, pc <== NOT EXECUTED
4860: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
4864: eaffffdb b 47d8 <rtems_termios_read+0x234> <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
4868: e594203c ldr r2, [r4, #60] ; 0x3c
486c: e3120002 tst r2, #2
4870: 0a00000b beq 48a4 <rtems_termios_read+0x300>
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
4874: e5940010 ldr r0, [r4, #16]
4878: e1a0e00f mov lr, pc
487c: e12fff13 bx r3
if (n < 0) {
4880: e3500000 cmp r0, #0
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
4884: e1a01004 mov r1, r4
4888: e20000ff and r0, r0, #255 ; 0xff
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
488c: ba00002d blt 4948 <rtems_termios_read+0x3a4>
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
4890: ebfffef7 bl 4474 <siproc>
4894: e3500000 cmp r0, #0
4898: 1affff65 bne 4634 <rtems_termios_read+0x90>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
489c: e59430a0 ldr r3, [r4, #160] ; 0xa0
48a0: eafffff3 b 4874 <rtems_termios_read+0x2d0>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
48a4: eb0002b0 bl 536c <rtems_clock_get_ticks_since_boot>
48a8: e1a05000 mov r5, r0
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
48ac: e5940010 ldr r0, [r4, #16]
48b0: e1a0e00f mov lr, pc
48b4: e594f0a0 ldr pc, [r4, #160] ; 0xa0
if (n < 0) {
48b8: e3500000 cmp r0, #0
48bc: ba00000c blt 48f4 <rtems_termios_read+0x350>
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
48c0: e20000ff and r0, r0, #255 ; 0xff
48c4: e1a01004 mov r1, r4
48c8: ebfffee9 bl 4474 <siproc>
if (tty->ccount >= tty->termios.c_cc[VMIN])
48cc: e5d43047 ldrb r3, [r4, #71] ; 0x47
48d0: e5942020 ldr r2, [r4, #32]
48d4: e1520003 cmp r2, r3
48d8: aaffff55 bge 4634 <rtems_termios_read+0x90>
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
48dc: e3530000 cmp r3, #0
48e0: 0afffff1 beq 48ac <rtems_termios_read+0x308>
48e4: e5d43046 ldrb r3, [r4, #70] ; 0x46
48e8: e3530000 cmp r3, #0
48ec: 0affffee beq 48ac <rtems_termios_read+0x308>
48f0: eaffffeb b 48a4 <rtems_termios_read+0x300>
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
48f4: e5d43047 ldrb r3, [r4, #71] ; 0x47
48f8: e3530000 cmp r3, #0
48fc: 0a000008 beq 4924 <rtems_termios_read+0x380>
if (tty->termios.c_cc[VTIME] && tty->ccount) {
4900: e5d43046 ldrb r3, [r4, #70] ; 0x46
4904: e3530000 cmp r3, #0
4908: 0a000002 beq 4918 <rtems_termios_read+0x374>
490c: e5943020 ldr r3, [r4, #32]
4910: e3530000 cmp r3, #0
4914: 1a000005 bne 4930 <rtems_termios_read+0x38c>
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
4918: e3a00001 mov r0, #1
491c: eb00056d bl 5ed8 <rtems_task_wake_after>
4920: eaffffe1 b 48ac <rtems_termios_read+0x308>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
4924: e5d43046 ldrb r3, [r4, #70] ; 0x46 <== NOT EXECUTED
4928: e3530000 cmp r3, #0 <== NOT EXECUTED
492c: 0affff40 beq 4634 <rtems_termios_read+0x90> <== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
4930: eb00028d bl 536c <rtems_clock_get_ticks_since_boot>
if ((now - then) > tty->vtimeTicks) {
4934: e5943054 ldr r3, [r4, #84] ; 0x54
4938: e0650000 rsb r0, r5, r0
493c: e1500003 cmp r0, r3
4940: 9afffff4 bls 4918 <rtems_termios_read+0x374>
4944: eaffff3a b 4634 <rtems_termios_read+0x90>
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
rtems_task_wake_after (1);
4948: e3a00001 mov r0, #1
494c: eb000561 bl 5ed8 <rtems_task_wake_after>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
4950: e59430a0 ldr r3, [r4, #160] ; 0xa0
4954: eaffffc6 b 4874 <rtems_termios_read+0x2d0>
00004cec <rtems_termios_refill_transmitter>:
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
4cec: e59030b8 ldr r3, [r0, #184] ; 0xb8
4cf0: e3c33fff bic r3, r3, #1020 ; 0x3fc
4cf4: e1a03a83 lsl r3, r3, #21
4cf8: e3a02b01 mov r2, #1024 ; 0x400
4cfc: e1a03aa3 lsr r3, r3, #21
4d00: e2822001 add r2, r2, #1
4d04: e1530002 cmp r3, r2
* 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)
{
4d08: e92d4070 push {r4, r5, r6, lr}
4d0c: e1a04000 mov r4, r0
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
4d10: 0a000048 beq 4e38 <rtems_termios_refill_transmitter+0x14c>
tty->flow_ctrl |= FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
4d14: e59030b8 ldr r3, [r0, #184] ; 0xb8
4d18: e2033003 and r3, r3, #3
4d1c: e3530002 cmp r3, #2
4d20: 0a000056 beq 4e80 <rtems_termios_refill_transmitter+0x194>
tty->flow_ctrl &= ~FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
4d24: e5902080 ldr r2, [r0, #128] ; 0x80
4d28: e5903084 ldr r3, [r0, #132] ; 0x84
4d2c: e1520003 cmp r2, r3
4d30: 0a00002a beq 4de0 <rtems_termios_refill_transmitter+0xf4>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
4d34: e10f3000 mrs r3, CPSR
4d38: e3832080 orr r2, r3, #128 ; 0x80
4d3c: e129f002 msr CPSR_fc, r2
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
4d40: e3a02000 mov r2, #0
}
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
4d44: e5900090 ldr r0, [r0, #144] ; 0x90
tty->t_dqlen = 0;
4d48: e5842090 str r2, [r4, #144] ; 0x90
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
4d4c: e129f003 msr CPSR_fc, r3
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
4d50: e5943084 ldr r3, [r4, #132] ; 0x84
4d54: e5941088 ldr r1, [r4, #136] ; 0x88
4d58: e0800003 add r0, r0, r3
4d5c: eb003279 bl 11748 <__umodsi3>
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
4d60: e5943094 ldr r3, [r4, #148] ; 0x94
4d64: e3530002 cmp r3, #2
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
4d68: e1a05000 mov r5, r0
tty->rawOutBuf.Tail = newTail;
4d6c: e5840084 str r0, [r4, #132] ; 0x84
if (tty->rawOutBufState == rob_wait) {
4d70: 0a00002d beq 4e2c <rtems_termios_refill_transmitter+0x140>
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
if (newTail == tty->rawOutBuf.Head) {
4d74: e5943080 ldr r3, [r4, #128] ; 0x80
4d78: e1530005 cmp r3, r5
4d7c: 0a00001f beq 4e00 <rtems_termios_refill_transmitter+0x114>
if ( tty->tty_snd.sw_pfn != NULL) {
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
4d80: e59430b8 ldr r3, [r4, #184] ; 0xb8
4d84: e2033e21 and r3, r3, #528 ; 0x210
4d88: e3530e21 cmp r3, #528 ; 0x210
4d8c: 0a00004d beq 4ec8 <rtems_termios_refill_transmitter+0x1dc>
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
4d90: e5943080 ldr r3, [r4, #128] ; 0x80
4d94: e1550003 cmp r5, r3
nToSend = tty->rawOutBuf.Size - newTail;
4d98: 85946088 ldrhi r6, [r4, #136] ; 0x88
else
nToSend = tty->rawOutBuf.Head - newTail;
4d9c: 95946080 ldrls r6, [r4, #128] ; 0x80
/* 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)) {
4da0: e59430b8 ldr r3, [r4, #184] ; 0xb8
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
4da4: 80656006 rsbhi r6, r5, r6
else
nToSend = tty->rawOutBuf.Head - newTail;
4da8: 90656006 rsbls r6, r5, r6
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
4dac: e594107c ldr r1, [r4, #124] ; 0x7c
else
nToSend = tty->rawOutBuf.Head - newTail;
/* 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)) {
4db0: e3130c06 tst r3, #1536 ; 0x600
4db4: 13a06001 movne r6, #1
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
4db8: e3a03001 mov r3, #1
nToSend = tty->rawOutBuf.Head - newTail;
/* 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)) {
nToSend = 1;
4dbc: e1a02006 mov r2, r6
}
tty->rawOutBufState = rob_busy; /*apm*/
4dc0: e5843094 str r3, [r4, #148] ; 0x94
(*tty->device.write)(
4dc4: e5940010 ldr r0, [r4, #16]
4dc8: e0811005 add r1, r1, r5
4dcc: e1a0e00f mov lr, pc
4dd0: e594f0a4 ldr pc, [r4, #164] ; 0xa4
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
4dd4: e5845084 str r5, [r4, #132] ; 0x84
} return nToSend; }
4dd8: e1a00006 mov r0, r6
4ddc: e8bd8070 pop {r4, r5, r6, pc}
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
4de0: e5903094 ldr r3, [r0, #148] ; 0x94
4de4: e3530002 cmp r3, #2
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
4de8: 13a06000 movne r6, #0
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
4dec: 1afffff9 bne 4dd8 <rtems_termios_refill_transmitter+0xec>
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
4df0: e590008c ldr r0, [r0, #140] ; 0x8c <== NOT EXECUTED
4df4: eb000349 bl 5b20 <rtems_semaphore_release> <== NOT EXECUTED
}
return 0;
4df8: e3a06000 mov r6, #0 <== NOT EXECUTED
4dfc: eafffff5 b 4dd8 <rtems_termios_refill_transmitter+0xec> <== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
4e00: e59430d4 ldr r3, [r4, #212] ; 0xd4
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
4e04: e3a06000 mov r6, #0
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
4e08: e1530006 cmp r3, r6
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
4e0c: e5846094 str r6, [r4, #148] ; 0x94
nToSend = 0;
4e10: 01a06003 moveq r6, r3
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
4e14: 0affffee beq 4dd4 <rtems_termios_refill_transmitter+0xe8>
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
4e18: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED
4e1c: e59410d8 ldr r1, [r4, #216] ; 0xd8 <== NOT EXECUTED
4e20: e1a0e00f mov lr, pc <== NOT EXECUTED
4e24: e12fff13 bx r3 <== NOT EXECUTED
4e28: eaffffe9 b 4dd4 <rtems_termios_refill_transmitter+0xe8> <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
4e2c: e594008c ldr r0, [r4, #140] ; 0x8c
4e30: eb00033a bl 5b20 <rtems_semaphore_release>
4e34: eaffffce b 4d74 <rtems_termios_refill_transmitter+0x88>
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
4e38: e284104a add r1, r4, #74 ; 0x4a <== NOT EXECUTED
4e3c: e3a02001 mov r2, #1 <== NOT EXECUTED
4e40: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
4e44: e1a0e00f mov lr, pc <== NOT EXECUTED
4e48: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
4e4c: e10f3000 mrs r3, CPSR <== NOT EXECUTED
4e50: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
4e54: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->t_dqlen--;
4e58: e5941090 ldr r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
4e5c: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
4e60: e2411001 sub r1, r1, #1 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
4e64: e3822002 orr r2, r2, #2 <== NOT EXECUTED
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
4e68: e5841090 str r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
4e6c: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
4e70: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
4e74: e3a06001 mov r6, #1 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
4e78: e1a00006 mov r0, r6 <== NOT EXECUTED
4e7c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* 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);
4e80: e2841049 add r1, r4, #73 ; 0x49 <== NOT EXECUTED
4e84: e3a02001 mov r2, #1 <== NOT EXECUTED
4e88: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
4e8c: e1a0e00f mov lr, pc <== NOT EXECUTED
4e90: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
4e94: e10f3000 mrs r3, CPSR <== NOT EXECUTED
4e98: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
4e9c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->t_dqlen--;
4ea0: e5941090 ldr r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
4ea4: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
4ea8: e2411001 sub r1, r1, #1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
4eac: e3c22002 bic r2, r2, #2 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
4eb0: e5841090 str r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
4eb4: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
4eb8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
4ebc: e3a06001 mov r6, #1 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
4ec0: e1a00006 mov r0, r6 <== NOT EXECUTED
4ec4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
4ec8: e10f3000 mrs r3, CPSR <== NOT EXECUTED
4ecc: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
4ed0: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
tty->flow_ctrl |= FL_OSTOP;
4ed4: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
4ed8: e3822020 orr r2, r2, #32 <== NOT EXECUTED
4edc: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
4ee0: e3a02001 mov r2, #1 <== NOT EXECUTED
4ee4: e5842094 str r2, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
4ee8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 0;
4eec: e3a06000 mov r6, #0 <== NOT EXECUTED
4ef0: eaffffb7 b 4dd4 <rtems_termios_refill_transmitter+0xe8> <== NOT EXECUTED
00004c60 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
4c60: e92d40f0 push {r4, r5, r6, r7, lr}
4c64: e24dd008 sub sp, sp, #8
4c68: e1a04000 mov r4, r0
4c6c: e28d7007 add r7, sp, #7
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
4c70: e3a06000 mov r6, #0
4c74: ea000005 b 4c90 <rtems_termios_rxdaemon+0x30>
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
4c78: e5940010 ldr r0, [r4, #16]
4c7c: e1a0e00f mov lr, pc
4c80: e594f0a0 ldr pc, [r4, #160] ; 0xa0
if (c != EOF) {
4c84: e3700001 cmn r0, #1
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
4c88: e1a03000 mov r3, r0
if (c != EOF) {
4c8c: 1a000010 bne 4cd4 <rtems_termios_rxdaemon+0x74>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
4c90: e1a0300d mov r3, sp
4c94: e3a01002 mov r1, #2
4c98: e3a02000 mov r2, #0
4c9c: e3a00003 mov r0, #3
4ca0: eb0001d1 bl 53ec <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) {
4ca4: e59d3000 ldr r3, [sp]
4ca8: e3130001 tst r3, #1
4cac: 0afffff1 beq 4c78 <rtems_termios_rxdaemon+0x18>
tty->rxTaskId = 0;
4cb0: e58460c4 str r6, [r4, #196] ; 0xc4 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
4cb4: e1a00006 mov r0, r6 <== NOT EXECUTED
4cb8: eb000411 bl 5d04 <rtems_task_delete> <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
4cbc: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
4cc0: e1a0e00f mov lr, pc <== NOT EXECUTED
4cc4: e594f0a0 ldr pc, [r4, #160] ; 0xa0 <== NOT EXECUTED
if (c != EOF) {
4cc8: e3700001 cmn r0, #1 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
4ccc: e1a03000 mov r3, r0 <== NOT EXECUTED
if (c != EOF) {
4cd0: 0affffee beq 4c90 <rtems_termios_rxdaemon+0x30> <== NOT EXECUTED
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
4cd4: e1a00004 mov r0, r4
4cd8: e1a01007 mov r1, r7
4cdc: e3a02001 mov r2, #1
c = tty->device.pollRead(tty->minor);
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
4ce0: e5cd3007 strb r3, [sp, #7]
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
4ce4: ebffff20 bl 496c <rtems_termios_enqueue_raw_characters>
4ce8: eaffffe8 b 4c90 <rtems_termios_rxdaemon+0x30>
00004ef4 <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
4ef4: e92d40f0 push {r4, r5, r6, r7, lr}
4ef8: e59f6060 ldr r6, [pc, #96] ; 4f60 <rtems_termios_txdaemon+0x6c>
4efc: e24dd004 sub sp, sp, #4
4f00: e1a04000 mov r4, r0
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
4f04: e3a07000 mov r7, #0
4f08: ea000008 b 4f30 <rtems_termios_txdaemon+0x3c>
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
4f0c: e59430cc ldr r3, [r4, #204] ; 0xcc
4f10: e0863283 add r3, r6, r3, lsl #5
4f14: e5933014 ldr r3, [r3, #20]
4f18: e3530000 cmp r3, #0
rtems_termios_linesw[tty->t_line].l_start(tty);
4f1c: e1a00004 mov r0, r4
4f20: 11a0e00f movne lr, pc
4f24: 112fff13 bxne r3
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
4f28: e1a00004 mov r0, r4
4f2c: ebffff6e bl 4cec <rtems_termios_refill_transmitter>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
4f30: e1a0300d mov r3, sp
4f34: e3a01002 mov r1, #2
4f38: e3a02000 mov r2, #0
4f3c: e3a00003 mov r0, #3
4f40: eb000129 bl 53ec <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) {
4f44: e59d3000 ldr r3, [sp]
4f48: e3130001 tst r3, #1
4f4c: 0affffee beq 4f0c <rtems_termios_txdaemon+0x18>
tty->txTaskId = 0;
4f50: e58470c8 str r7, [r4, #200] ; 0xc8 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
4f54: e1a00007 mov r0, r7 <== NOT EXECUTED
4f58: eb000369 bl 5d04 <rtems_task_delete> <== NOT EXECUTED
4f5c: eaffffea b 4f0c <rtems_termios_txdaemon+0x18> <== NOT EXECUTED
000044d4 <rtems_termios_write>:
rtems_status_code
rtems_termios_write (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
44d4: e5903000 ldr r3, [r0]
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
44d8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
44dc: e5934034 ldr r4, [r3, #52] ; 0x34
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
44e0: e3a01000 mov r1, #0
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
44e4: e1a05000 mov r5, r0
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
44e8: e1a02001 mov r2, r1
44ec: e5940018 ldr r0, [r4, #24]
44f0: eb000541 bl 59fc <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
44f4: e2506000 subs r6, r0, #0
44f8: 1a00000c bne 4530 <rtems_termios_write+0x5c>
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
44fc: e59420cc ldr r2, [r4, #204] ; 0xcc
4500: e59f3098 ldr r3, [pc, #152] ; 45a0 <rtems_termios_write+0xcc>
4504: e0833282 add r3, r3, r2, lsl #5
4508: e593300c ldr r3, [r3, #12]
450c: e3530000 cmp r3, #0
4510: 0a000008 beq 4538 <rtems_termios_write+0x64>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
4514: e1a00004 mov r0, r4
4518: e1a01005 mov r1, r5
451c: e1a0e00f mov lr, pc
4520: e12fff13 bx r3
4524: e1a06000 mov r6, r0
rtems_semaphore_release (tty->osem);
4528: e5940018 ldr r0, [r4, #24]
452c: eb00057b bl 5b20 <rtems_semaphore_release>
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
}
rtems_semaphore_release (tty->osem);
return sc;
}
4530: e1a00006 mov r0, r6
4534: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
4538: e5943034 ldr r3, [r4, #52] ; 0x34
453c: e3130001 tst r3, #1
4540: 0a000011 beq 458c <rtems_termios_write+0xb8>
uint32_t count = args->count;
4544: e5958010 ldr r8, [r5, #16]
char *buffer = args->buffer;
while (count--)
4548: e3580000 cmp r8, #0
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
454c: e595a00c ldr sl, [r5, #12]
while (count--)
4550: 01a03006 moveq r3, r6
4554: 0a000007 beq 4578 <rtems_termios_write+0xa4>
4558: e1a07006 mov r7, r6
oproc (*buffer++, tty);
455c: e7da0007 ldrb r0, [sl, r7]
4560: e1a01004 mov r1, r4
4564: e2877001 add r7, r7, #1
4568: ebfffe46 bl 3e88 <oproc>
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
456c: e1570008 cmp r7, r8
4570: 1afffff9 bne 455c <rtems_termios_write+0x88>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
4574: e5953010 ldr r3, [r5, #16]
4578: e5853018 str r3, [r5, #24]
} rtems_semaphore_release (tty->osem);
457c: e5940018 ldr r0, [r4, #24]
4580: eb000566 bl 5b20 <rtems_semaphore_release>
return sc; }
4584: e1a00006 mov r0, r6
4588: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
458c: e285000c add r0, r5, #12 <== NOT EXECUTED
4590: e8900003 ldm r0, {r0, r1} <== NOT EXECUTED
4594: e1a02004 mov r2, r4 <== NOT EXECUTED
4598: ebfffdf3 bl 3d6c <rtems_termios_puts> <== NOT EXECUTED
459c: eafffff4 b 4574 <rtems_termios_write+0xa0> <== NOT EXECUTED
00006dd0 <rtems_verror>:
{
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
6dd0: e3100202 tst r0, #536870912 ; 0x20000000
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
6dd4: e92d41f0 push {r4, r5, r6, r7, r8, lr}
6dd8: e1a04000 mov r4, r0
6ddc: e1a08001 mov r8, r1
6de0: e1a06002 mov r6, r2
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
6de4: 0a00000d beq 6e20 <rtems_verror+0x50>
if (rtems_panic_in_progress++)
6de8: e59f212c ldr r2, [pc, #300] ; 6f1c <rtems_verror+0x14c>
6dec: e5921000 ldr r1, [r2]
6df0: e2813001 add r3, r1, #1
6df4: e3510000 cmp r1, #0
6df8: e5823000 str r3, [r2]
6dfc: 0a000004 beq 6e14 <rtems_verror+0x44>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
6e00: e59f3118 ldr r3, [pc, #280] ; 6f20 <rtems_verror+0x150> <== NOT EXECUTED
6e04: e5931000 ldr r1, [r3] <== NOT EXECUTED
6e08: e2811001 add r1, r1, #1 <== NOT EXECUTED
6e0c: e5831000 str r1, [r3] <== NOT EXECUTED
RTEMS_COMPILER_MEMORY_BARRIER();
6e10: e5923000 ldr r3, [r2] <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
6e14: e3530002 cmp r3, #2
return 0;
6e18: c3a06000 movgt r6, #0
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)
6e1c: ca000024 bgt 6eb4 <rtems_verror+0xe4>
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
6e20: e59f50fc ldr r5, [pc, #252] ; 6f24 <rtems_verror+0x154>
6e24: e5953000 ldr r3, [r5]
6e28: e5930008 ldr r0, [r3, #8]
6e2c: eb003307 bl 13a50 <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
6e30: e2147101 ands r7, r4, #1073741824 ; 0x40000000
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
6e34: e3c44207 bic r4, r4, #1879048192 ; 0x70000000
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
6e38: 1a00002a bne 6ee8 <rtems_verror+0x118>
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
6e3c: e5953000 ldr r3, [r5]
6e40: e1a02006 mov r2, r6
6e44: e1a01008 mov r1, r8
6e48: e593000c ldr r0, [r3, #12]
6e4c: eb004e3c bl 1a744 <vfprintf>
if (status)
6e50: e3540000 cmp r4, #0
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
6e54: e1a06000 mov r6, r0
if (status)
6e58: 1a000017 bne 6ebc <rtems_verror+0xec>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
6e5c: e3570000 cmp r7, #0
6e60: 0a00000b beq 6e94 <rtems_verror+0xc4>
if ((local_errno > 0) && *strerror(local_errno))
6e64: da000004 ble 6e7c <rtems_verror+0xac>
6e68: e1a00007 mov r0, r7
6e6c: eb0036e0 bl 149f4 <strerror>
6e70: e5d03000 ldrb r3, [r0]
6e74: e3530000 cmp r3, #0
6e78: 1a00001d bne 6ef4 <rtems_verror+0x124>
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
6e7c: e5953000 ldr r3, [r5]
6e80: e59f10a0 ldr r1, [pc, #160] ; 6f28 <rtems_verror+0x158>
6e84: e593000c ldr r0, [r3, #12]
6e88: e1a02007 mov r2, r7
6e8c: eb0033d5 bl 13de8 <fprintf>
6e90: e0866000 add r6, r6, r0
}
chars_written += fprintf(stderr, "\n");
6e94: e5953000 ldr r3, [r5]
6e98: e59f108c ldr r1, [pc, #140] ; 6f2c <rtems_verror+0x15c>
6e9c: e593000c ldr r0, [r3, #12]
6ea0: eb0033d0 bl 13de8 <fprintf>
(void) fflush(stderr);
6ea4: e5953000 ldr r3, [r5]
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
6ea8: e0806006 add r6, r0, r6
(void) fflush(stderr);
6eac: e593000c ldr r0, [r3, #12]
6eb0: eb0032e6 bl 13a50 <fflush>
return chars_written;
}
6eb4: e1a00006 mov r0, r6
6eb8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
6ebc: e59f3060 ldr r3, [pc, #96] ; 6f24 <rtems_verror+0x154>
6ec0: e5933000 ldr r3, [r3]
6ec4: e1a00004 mov r0, r4
6ec8: e593400c ldr r4, [r3, #12]
6ecc: ebffffbb bl 6dc0 <rtems_status_text>
6ed0: e59f1058 ldr r1, [pc, #88] ; 6f30 <rtems_verror+0x160>
6ed4: e1a02000 mov r2, r0
6ed8: e1a00004 mov r0, r4
6edc: eb0033c1 bl 13de8 <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
6ee0: e0866000 add r6, r6, r0
6ee4: eaffffdc b 6e5c <rtems_verror+0x8c>
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
6ee8: eb0031e1 bl 13674 <__errno>
6eec: e5907000 ldr r7, [r0]
6ef0: eaffffd1 b 6e3c <rtems_verror+0x6c>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
if ((local_errno > 0) && *strerror(local_errno))
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
6ef4: e5953000 ldr r3, [r5]
6ef8: e1a00007 mov r0, r7
6efc: e593400c ldr r4, [r3, #12]
6f00: eb0036bb bl 149f4 <strerror>
6f04: e59f1028 ldr r1, [pc, #40] ; 6f34 <rtems_verror+0x164>
6f08: e1a02000 mov r2, r0
6f0c: e1a00004 mov r0, r4
6f10: eb0033b4 bl 13de8 <fprintf>
6f14: e0866000 add r6, r6, r0
6f18: eaffffdd b 6e94 <rtems_verror+0xc4>
00002a1c <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
2a1c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int c; unsigned int i = 0; unsigned int limit = INT_MAX; int sign = 0;
2a20: e3a06000 mov r6, #0
int d;
for (;;) {
c = getc(fp);
2a24: e59f90f8 ldr r9, [pc, #248] ; 2b24 <scanInt+0x108>
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
2a28: e59f80f8 ldr r8, [pc, #248] ; 2b28 <scanInt+0x10c>
return 0;
d = c - '0';
if ((i > (limit / 10))
2a2c: e59fa0f8 ldr sl, [pc, #248] ; 2b2c <scanInt+0x110>
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
2a30: e1a04000 mov r4, r0
2a34: e1a0b001 mov fp, r1
int c; unsigned int i = 0; unsigned int limit = INT_MAX;
2a38: e3e07102 mvn r7, #-2147483648 ; 0x80000000
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
2a3c: e1a05006 mov r5, r6
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2a40: e5943004 ldr r3, [r4, #4]
2a44: e2433001 sub r3, r3, #1
2a48: e3530000 cmp r3, #0
2a4c: e5843004 str r3, [r4, #4]
2a50: ba00001d blt 2acc <scanInt+0xb0>
2a54: e5943000 ldr r3, [r4]
2a58: e4d30001 ldrb r0, [r3], #1
if (c == ':')
2a5c: e350003a cmp r0, #58 ; 0x3a
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2a60: e5843000 str r3, [r4]
if (c == ':')
2a64: 0a00001d beq 2ae0 <scanInt+0xc4>
break;
if (sign == 0) {
2a68: e3560000 cmp r6, #0
2a6c: 1a000004 bne 2a84 <scanInt+0x68>
if (c == '-') {
2a70: e350002d cmp r0, #45 ; 0x2d
sign = -1;
limit++;
2a74: 02877001 addeq r7, r7, #1
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
2a78: 03e06000 mvneq r6, #0
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
2a7c: 0affffef beq 2a40 <scanInt+0x24>
sign = -1;
limit++;
continue;
}
sign = 1;
2a80: e3a06001 mov r6, #1
}
if (!isdigit(c))
2a84: e5983000 ldr r3, [r8]
2a88: e0833000 add r3, r3, r0
2a8c: e5d33001 ldrb r3, [r3, #1]
2a90: e2133004 ands r3, r3, #4
2a94: 0a00001e beq 2b14 <scanInt+0xf8>
return 0;
d = c - '0';
if ((i > (limit / 10))
2a98: e083279a umull r2, r3, sl, r7
2a9c: e15501a3 cmp r5, r3, lsr #3
2aa0: 8a000019 bhi 2b0c <scanInt+0xf0>
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
2aa4: e2400030 sub r0, r0, #48 ; 0x30
2aa8: 11a03105 lslne r3, r5, #2
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
2aac: 0a000011 beq 2af8 <scanInt+0xdc>
return 0;
i = i * 10 + d;
2ab0: e0835005 add r5, r3, r5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2ab4: e5943004 ldr r3, [r4, #4]
2ab8: e2433001 sub r3, r3, #1
2abc: e3530000 cmp r3, #0
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
2ac0: e0805085 add r5, r0, r5, lsl #1
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2ac4: e5843004 str r3, [r4, #4]
2ac8: aaffffe1 bge 2a54 <scanInt+0x38>
2acc: e5990000 ldr r0, [r9] <== NOT EXECUTED
2ad0: e1a01004 mov r1, r4 <== NOT EXECUTED
2ad4: eb00368c bl 1050c <__srget_r> <== NOT EXECUTED
if (c == ':')
2ad8: e350003a cmp r0, #58 ; 0x3a <== NOT EXECUTED
2adc: 1affffe1 bne 2a68 <scanInt+0x4c> <== NOT EXECUTED
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
2ae0: e3560000 cmp r6, #0
2ae4: 0a00000c beq 2b1c <scanInt+0x100>
return 0;
*val = i * sign;
2ae8: e0050596 mul r5, r6, r5
return 1;
2aec: e3a00001 mov r0, #1
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
*val = i * sign;
2af0: e58b5000 str r5, [fp]
return 1;
2af4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
2af8: e1a03105 lsl r3, r5, #2
2afc: e0832005 add r2, r3, r5
2b00: e0472082 sub r2, r7, r2, lsl #1
2b04: e1500002 cmp r0, r2
2b08: 9affffe8 bls 2ab0 <scanInt+0x94>
return 0;
2b0c: e3a00000 mov r0, #0
2b10: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
continue;
}
sign = 1;
}
if (!isdigit(c))
return 0;
2b14: e1a00003 mov r0, r3
2b18: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
2b1c: e1a00006 mov r0, r6 <== NOT EXECUTED
*val = i * sign; return 1; }
2b20: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00002c24 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
2c24: e92d41f0 push {r4, r5, r6, r7, r8, lr}
2c28: e24dd014 sub sp, sp, #20
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2c2c: e28d5008 add r5, sp, #8
2c30: e28d4004 add r4, sp, #4
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
2c34: e58d2008 str r2, [sp, #8]
2c38: e58d3004 str r3, [sp, #4]
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2c3c: e3a06000 mov r6, #0
2c40: e1a02005 mov r2, r5
2c44: e1a03004 mov r3, r4
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
2c48: e1a07000 mov r7, r0
2c4c: e1a08001 mov r8, r1
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2c50: e58d6000 str r6, [sp]
2c54: ebffffb5 bl 2b30 <scanString>
2c58: e3500000 cmp r0, #0
2c5c: 1a000001 bne 2c68 <scangr+0x44>
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
return 1;
}
2c60: e28dd014 add sp, sp, #20
2c64: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
2c68: e1a00007 mov r0, r7
2c6c: e2881004 add r1, r8, #4
2c70: e1a02005 mov r2, r5
2c74: e1a03004 mov r3, r4
2c78: e58d6000 str r6, [sp]
2c7c: ebffffab bl 2b30 <scanString>
2c80: e3500000 cmp r0, #0
2c84: 0afffff5 beq 2c60 <scangr+0x3c>
|| !scanInt(fp, &grgid)
2c88: e1a00007 mov r0, r7
2c8c: e28d1010 add r1, sp, #16
2c90: ebffff61 bl 2a1c <scanInt>
2c94: e3500000 cmp r0, #0
2c98: 0afffff0 beq 2c60 <scangr+0x3c>
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
2c9c: e3a06001 mov r6, #1
2ca0: e1a00007 mov r0, r7
2ca4: e28d100c add r1, sp, #12
2ca8: e1a02005 mov r2, r5
2cac: e1a03004 mov r3, r4
2cb0: e58d6000 str r6, [sp]
2cb4: ebffff9d bl 2b30 <scanString>
2cb8: e3500000 cmp r0, #0
2cbc: 0affffe7 beq 2c60 <scangr+0x3c>
return 0;
grp->gr_gid = grgid;
2cc0: e1dd31b0 ldrh r3, [sp, #16]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2cc4: e59d100c ldr r1, [sp, #12]
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
grp->gr_gid = grgid;
2cc8: e1c830b8 strh r3, [r8, #8]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2ccc: e5d13000 ldrb r3, [r1]
2cd0: e3530000 cmp r3, #0
2cd4: 03a06017 moveq r6, #23
2cd8: 0a000007 beq 2cfc <scangr+0xd8>
2cdc: e1a02001 mov r2, r1
if(*cp == ',')
2ce0: e353002c cmp r3, #44 ; 0x2c
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2ce4: e5f23001 ldrb r3, [r2, #1]!
if(*cp == ',')
memcount++;
2ce8: 02866001 addeq r6, r6, #1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2cec: e3530000 cmp r3, #0
2cf0: 1afffffa bne 2ce0 <scangr+0xbc>
2cf4: e1a06106 lsl r6, r6, #2
2cf8: e2866013 add r6, r6, #19
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
2cfc: e59d3004 ldr r3, [sp, #4]
2d00: e1530006 cmp r3, r6
return 0;
2d04: 33a00000 movcc r0, #0
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
2d08: 3affffd4 bcc 2c60 <scangr+0x3c>
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
2d0c: e59d0008 ldr r0, [sp, #8]
2d10: e280000f add r0, r0, #15
2d14: e3c0000f bic r0, r0, #15
2d18: e588000c str r0, [r8, #12]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
2d1c: e5801000 str r1, [r0]
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2d20: e59d200c ldr r2, [sp, #12]
2d24: e5d23000 ldrb r3, [r2]
2d28: e3530000 cmp r3, #0
2d2c: 0a000010 beq 2d74 <scangr+0x150>
}
/*
* Extract a single group record from the database
*/
static int scangr(
2d30: e2822001 add r2, r2, #1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2d34: e3a01001 mov r1, #1
if(*cp == ',') {
*cp = '\0';
2d38: e3a00000 mov r0, #0
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
if(*cp == ',') {
2d3c: e353002c cmp r3, #44 ; 0x2c
*cp = '\0';
2d40: 05420001 strbeq r0, [r2, #-1]
grp->gr_mem[memcount++] = cp + 1;
2d44: 0598300c ldreq r3, [r8, #12]
2d48: 07832101 streq r2, [r3, r1, lsl #2]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2d4c: e4d23001 ldrb r3, [r2], #1
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
2d50: 02811001 addeq r1, r1, #1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2d54: e3530000 cmp r3, #0
2d58: 1afffff7 bne 2d3c <scangr+0x118>
2d5c: e598000c ldr r0, [r8, #12]
2d60: e1a01101 lsl r1, r1, #2
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
2d64: e3a03000 mov r3, #0
2d68: e7803001 str r3, [r0, r1]
return 1;
2d6c: e3a00001 mov r0, #1
2d70: eaffffba b 2c60 <scangr+0x3c>
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2d74: e3a01004 mov r1, #4 <== NOT EXECUTED
2d78: eafffff9 b 2d64 <scangr+0x140> <== NOT EXECUTED
00008af8 <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
8af8: e92d4010 push {r4, lr}
8afc: e24dd004 sub sp, sp, #4
8b00: e1a04000 mov r4, r0
* * 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 );
8b04: e1a00001 mov r0, r1
8b08: e1a0100d mov r1, sp
8b0c: eb0016a0 bl e594 <_POSIX_Absolute_timeout_to_ticks>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
8b10: e3500003 cmp r0, #3
8b14: 0a000005 beq 8b30 <sem_timedwait+0x38>
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
8b18: e1a00004 mov r0, r4 <== NOT EXECUTED
8b1c: e3a01000 mov r1, #0 <== NOT EXECUTED
8b20: e59d2000 ldr r2, [sp] <== NOT EXECUTED
8b24: eb0019b6 bl f204 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
8b28: e28dd004 add sp, sp, #4
8b2c: e8bd8010 pop {r4, pc}
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
8b30: e1a00004 mov r0, r4
8b34: e3a01001 mov r1, #1
8b38: e59d2000 ldr r2, [sp]
8b3c: eb0019b0 bl f204 <_POSIX_Semaphore_Wait_support>
8b40: eafffff8 b 8b28 <sem_timedwait+0x30>
00006340 <sigaction>:
struct sigaction *oact
)
{
ISR_Level level;
if ( oact )
6340: e2523000 subs r3, r2, #0
*oact = _POSIX_signals_Vectors[ sig ];
6344: 159f20c4 ldrne r2, [pc, #196] ; 6410 <sigaction+0xd0>
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
6348: e92d4070 push {r4, r5, r6, lr}
634c: e1a05001 mov r5, r1
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
6350: 10801080 addne r1, r0, r0, lsl #1
6354: 10822101 addne r2, r2, r1, lsl #2
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
6358: e1a04000 mov r4, r0
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
635c: 18920007 ldmne r2, {r0, r1, r2}
6360: 18830007 stmne r3, {r0, r1, r2}
if ( !sig )
6364: e3540000 cmp r4, #0
6368: 0a000023 beq 63fc <sigaction+0xbc>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
636c: e2443001 sub r3, r4, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
6370: e353001f cmp r3, #31
6374: 8a000020 bhi 63fc <sigaction+0xbc>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
6378: e3540009 cmp r4, #9
637c: 0a00001e beq 63fc <sigaction+0xbc>
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
6380: e3550000 cmp r5, #0
6384: 0a00001a beq 63f4 <sigaction+0xb4>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
6388: e10f6000 mrs r6, CPSR
638c: e3863080 orr r3, r6, #128 ; 0x80
6390: e129f003 msr CPSR_fc, r3
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
6394: e5953008 ldr r3, [r5, #8]
6398: e3530000 cmp r3, #0
639c: 0a000009 beq 63c8 <sigaction+0x88>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
63a0: e1a00004 mov r0, r4
63a4: eb001773 bl c178 <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
63a8: e59f3060 ldr r3, [pc, #96] ; 6410 <sigaction+0xd0>
63ac: e8950007 ldm r5, {r0, r1, r2}
63b0: e0844084 add r4, r4, r4, lsl #1
63b4: e0834104 add r4, r3, r4, lsl #2
63b8: e8840007 stm r4, {r0, r1, r2}
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
63bc: e129f006 msr CPSR_fc, r6
* 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;
63c0: e3a00000 mov r0, #0
63c4: e8bd8070 pop {r4, r5, r6, pc}
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
63c8: e0844084 add r4, r4, r4, lsl #1
63cc: e59f3040 ldr r3, [pc, #64] ; 6414 <sigaction+0xd4>
63d0: e1a04104 lsl r4, r4, #2
63d4: e0833004 add r3, r3, r4
63d8: e8930007 ldm r3, {r0, r1, r2}
63dc: e59f302c ldr r3, [pc, #44] ; 6410 <sigaction+0xd0>
63e0: e0834004 add r4, r3, r4
63e4: e8840007 stm r4, {r0, r1, r2}
63e8: e129f006 msr CPSR_fc, r6
* 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;
63ec: e3a00000 mov r0, #0
63f0: e8bd8070 pop {r4, r5, r6, pc}
63f4: e1a00005 mov r0, r5 <== NOT EXECUTED
}
63f8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
rtems_set_errno_and_return_minus_one( EINVAL );
63fc: eb00238f bl f240 <__errno>
6400: e3a03016 mov r3, #22
6404: e5803000 str r3, [r0]
6408: e3e00000 mvn r0, #0
640c: e8bd8070 pop {r4, r5, r6, pc}
00008938 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
8938: e92d4010 push {r4, lr}
893c: e1a04001 mov r4, r1
int status;
status = sigtimedwait( set, NULL, NULL );
8940: e3a01000 mov r1, #0
8944: e1a02001 mov r2, r1
8948: ebffff7f bl 874c <sigtimedwait>
if ( status != -1 ) {
894c: e3700001 cmn r0, #1
8950: 0a000005 beq 896c <sigwait+0x34>
if ( sig )
8954: e3540000 cmp r4, #0
*sig = status;
8958: 15840000 strne r0, [r4]
return 0;
895c: 13a00000 movne r0, #0
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
8960: 18bd8010 popne {r4, pc}
*sig = status;
return 0;
8964: e1a00004 mov r0, r4 <== NOT EXECUTED
}
return errno;
}
8968: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( sig )
*sig = status;
return 0;
}
return errno;
896c: eb0022ef bl 11530 <__errno>
8970: e5900000 ldr r0, [r0]
8974: e8bd8010 pop {r4, pc}
00004474 <siproc>:
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
4474: e591303c ldr r3, [r1, #60] ; 0x3c
4478: e3c33f61 bic r3, r3, #388 ; 0x184
447c: e3c33003 bic r3, r3, #3
4480: e1a03a03 lsl r3, r3, #20
4484: e1a03a23 lsr r3, r3, #20
4488: e3530000 cmp r3, #0
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
448c: e92d4030 push {r4, r5, lr}
4490: e1a04001 mov r4, r1
4494: e1a05000 mov r5, r0
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
4498: 1a000001 bne 44a4 <siproc+0x30>
}
else {
i = iproc (c, tty);
}
return i;
}
449c: e8bd4030 pop {r4, r5, lr} <== 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);
44a0: eaffff7f b 42a4 <iproc> <== NOT EXECUTED
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
44a4: e3a01000 mov r1, #0
44a8: e1a02001 mov r2, r1
44ac: e5940018 ldr r0, [r4, #24]
44b0: eb000551 bl 59fc <rtems_semaphore_obtain>
i = iproc (c, tty);
44b4: e1a01004 mov r1, r4
44b8: e1a00005 mov r0, r5
44bc: ebffff78 bl 42a4 <iproc>
44c0: e1a05000 mov r5, r0
rtems_semaphore_release (tty->osem);
44c4: e5940018 ldr r0, [r4, #24]
44c8: eb000594 bl 5b20 <rtems_semaphore_release>
}
else {
i = iproc (c, tty);
}
return i;
}
44cc: e1a00005 mov r0, r5
44d0: e8bd8030 pop {r4, r5, pc}
00006170 <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
6170: e92d40f0 push {r4, r5, r6, r7, lr}
6174: e24dd030 sub sp, sp, #48 ; 0x30
6178: e1a07000 mov r7, r0
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
617c: ebfff448 bl 32a4 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
6180: e2505000 subs r5, r0, #0
6184: 1a000039 bne 6270 <unlink+0x100>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
6188: e28d4018 add r4, sp, #24
618c: e1a00007 mov r0, r7
6190: e28d102c add r1, sp, #44 ; 0x2c
6194: e1a02004 mov r2, r4
6198: ebfff85e bl 4318 <rtems_filesystem_get_start_loc>
const char *name; rtems_filesystem_location_info_t parentloc; rtems_filesystem_location_info_t loc; int i; int result; bool free_parentloc = false;
619c: e1a06005 mov r6, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
61a0: e1a0e004 mov lr, r4
61a4: e8be000f ldm lr!, {r0, r1, r2, r3}
61a8: e28dc004 add ip, sp, #4
61ac: e8ac000f stmia ip!, {r0, r1, r2, r3}
name = path + parentpathlen;
61b0: e0875005 add r5, r7, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
61b4: e59e3000 ldr r3, [lr]
name = path + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
61b8: e1a00005 mov r0, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
61bc: e58c3000 str r3, [ip]
name = path + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
61c0: eb00334e bl 12f00 <strlen>
61c4: e1a01000 mov r1, r0
61c8: e1a00005 mov r0, r5
61cc: ebfff443 bl 32e0 <rtems_filesystem_prefix_separators>
61d0: e0857000 add r7, r5, r0
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
61d4: e1a00007 mov r0, r7
61d8: eb003348 bl 12f00 <strlen>
61dc: e28d5004 add r5, sp, #4
61e0: e1a01000 mov r1, r0
61e4: e3a02000 mov r2, #0
61e8: e1a00007 mov r0, r7
61ec: e1a03005 mov r3, r5
61f0: e58d2000 str r2, [sp]
61f4: ebfff3f8 bl 31dc <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
61f8: e3500000 cmp r0, #0
61fc: 1a000013 bne 6250 <unlink+0xe0>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
6200: e1a00005 mov r0, r5
6204: e59d3010 ldr r3, [sp, #16]
6208: e1a0e00f mov lr, pc
620c: e593f010 ldr pc, [r3, #16]
6210: e3500001 cmp r0, #1
6214: 0a000021 beq 62a0 <unlink+0x130>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( EISDIR );
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
6218: e1a01005 mov r1, r5
621c: e59d3010 ldr r3, [sp, #16]
6220: e1a00004 mov r0, r4
6224: e1a0e00f mov lr, pc
6228: e593f00c ldr pc, [r3, #12]
622c: e1a07000 mov r7, r0
rtems_filesystem_freenode( &loc );
6230: e1a00005 mov r0, r5
6234: ebfff43e bl 3334 <rtems_filesystem_freenode>
if ( free_parentloc )
6238: e3560000 cmp r6, #0
rtems_filesystem_freenode( &parentloc );
623c: 11a00004 movne r0, r4
6240: 1bfff43b blne 3334 <rtems_filesystem_freenode>
return result;
}
6244: e1a00007 mov r0, r7
6248: e28dd030 add sp, sp, #48 ; 0x30
624c: e8bd80f0 pop {r4, r5, r6, r7, pc}
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 )
6250: e3560000 cmp r6, #0
6254: 1a000001 bne 6260 <unlink+0xf0>
rtems_filesystem_freenode( &parentloc );
return -1;
6258: e3e07000 mvn r7, #0 <== NOT EXECUTED
625c: eafffff8 b 6244 <unlink+0xd4> <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
6260: e1a00004 mov r0, r4
6264: ebfff432 bl 3334 <rtems_filesystem_freenode>
return -1;
6268: e3e07000 mvn r7, #0
626c: eafffff4 b 6244 <unlink+0xd4>
parentpathlen = rtems_filesystem_dirname ( path );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( path, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
6270: e3a03000 mov r3, #0
6274: e28d4018 add r4, sp, #24
6278: e58d3000 str r3, [sp]
627c: e3a02002 mov r2, #2
6280: e1a00007 mov r0, r7
6284: e1a01005 mov r1, r5
6288: e1a03004 mov r3, r4
628c: ebfff3ee bl 324c <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
6290: e3500000 cmp r0, #0
6294: 1affffef bne 6258 <unlink+0xe8>
return -1;
free_parentloc = true;
6298: e3a06001 mov r6, #1
629c: eaffffbf b 61a0 <unlink+0x30>
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_filesystem_freenode( &loc );
62a0: e1a00005 mov r0, r5
62a4: ebfff422 bl 3334 <rtems_filesystem_freenode>
if ( free_parentloc )
62a8: e3560000 cmp r6, #0
rtems_filesystem_freenode( &parentloc );
62ac: 11a00004 movne r0, r4
62b0: 1bfff41f blne 3334 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EISDIR );
62b4: eb002f52 bl 12004 <__errno>
62b8: e3a03015 mov r3, #21
62bc: e5803000 str r3, [r0]
62c0: e3e07000 mvn r7, #0
62c4: eaffffde b 6244 <unlink+0xd4>
00006338 <unmount>:
*/
int unmount(
const char *path
)
{
6338: e92d4070 push {r4, r5, r6, lr}
633c: e24dd018 sub sp, sp, #24
6340: e1a05000 mov r5, r0
* 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 ) )
6344: eb002803 bl 10358 <strlen>
6348: e28d4004 add r4, sp, #4
634c: e1a01000 mov r1, r0
6350: e3a0c001 mov ip, #1
6354: e1a00005 mov r0, r5
6358: e3a02000 mov r2, #0
635c: e1a03004 mov r3, r4
6360: e58dc000 str ip, [sp]
6364: ebfff327 bl 3008 <rtems_filesystem_evaluate_path>
6368: e3500000 cmp r0, #0
636c: 1a00001a bne 63dc <unmount+0xa4>
return -1;
mt_entry = loc.mt_entry;
6370: e59d5014 ldr r5, [sp, #20]
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
6374: e59d3004 ldr r3, [sp, #4]
6378: e595201c ldr r2, [r5, #28]
637c: e1520003 cmp r2, r3
6380: 1a00002d bne 643c <unmount+0x104>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
6384: e1a00004 mov r0, r4
6388: ebfff358 bl 30f0 <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 )
638c: e59f30f8 ldr r3, [pc, #248] ; 648c <unmount+0x154>
6390: e5933000 ldr r3, [r3]
6394: e5933014 ldr r3, [r3, #20]
6398: e1530005 cmp r3, r5
639c: 0a00002d beq 6458 <unmount+0x120>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
63a0: e59f00e8 ldr r0, [pc, #232] ; 6490 <unmount+0x158>
63a4: e595102c ldr r1, [r5, #44] ; 0x2c
63a8: ebfff5af bl 3a6c <rtems_filesystem_mount_iterate>
63ac: e3500000 cmp r0, #0
63b0: 1a000028 bne 6458 <unmount+0x120>
* 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 )
63b4: e1a00005 mov r0, r5
63b8: ebfff446 bl 34d8 <rtems_libio_is_open_files_in_fs>
63bc: e3500001 cmp r0, #1
63c0: 0a000024 beq 6458 <unmount+0x120>
* 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 )
63c4: e5953014 ldr r3, [r5, #20]
63c8: e1a00005 mov r0, r5
63cc: e1a0e00f mov lr, pc
63d0: e593f028 ldr pc, [r3, #40] ; 0x28
63d4: e2506000 subs r6, r0, #0
63d8: 0a000002 beq 63e8 <unmount+0xb0>
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
rtems_fatal_error_occurred( 0 );
return -1;
63dc: e3e00000 mvn r0, #0
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
63e0: e28dd018 add sp, sp, #24
63e4: e8bd8070 pop {r4, r5, r6, pc}
* 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){
63e8: e5953028 ldr r3, [r5, #40] ; 0x28
63ec: e1a00005 mov r0, r5
63f0: e1a0e00f mov lr, pc
63f4: e593f02c ldr pc, [r3, #44] ; 0x2c
63f8: e2504000 subs r4, r0, #0
63fc: 1a00001a bne 646c <unmount+0x134>
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 );
6400: e59f608c ldr r6, [pc, #140] ; 6494 <unmount+0x15c>
6404: e1a01004 mov r1, r4
6408: e1a02004 mov r2, r4
640c: e5960000 ldr r0, [r6]
6410: eb00028c bl 6e48 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
6414: e1a00005 mov r0, r5
6418: eb0004f2 bl 77e8 <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
641c: e5960000 ldr r0, [r6]
6420: eb0002d1 bl 6f6c <rtems_semaphore_release>
/*
* 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 );
6424: e2850008 add r0, r5, #8
6428: ebfff330 bl 30f0 <rtems_filesystem_freenode>
free( mt_entry );
642c: e1a00005 mov r0, r5
6430: ebfff333 bl 3104 <free>
return 0;
6434: e1a00004 mov r0, r4
6438: eaffffe8 b 63e0 <unmount+0xa8>
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
rtems_filesystem_freenode( &loc );
643c: e1a00004 mov r0, r4
6440: ebfff32a bl 30f0 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EACCES );
6444: eb00224b bl ed78 <__errno>
6448: e3a0300d mov r3, #13
644c: e5803000 str r3, [r0]
6450: e3e00000 mvn r0, #0
6454: eaffffe1 b 63e0 <unmount+0xa8>
* 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 )
rtems_set_errno_and_return_minus_one( EBUSY );
6458: eb002246 bl ed78 <__errno>
645c: e3a03010 mov r3, #16
6460: e5803000 str r3, [r0]
6464: e3e00000 mvn r0, #0
6468: eaffffdc b 63e0 <unmount+0xa8>
* 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 )
646c: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
6470: e1a00005 mov r0, r5 <== NOT EXECUTED
6474: e1a0e00f mov lr, pc <== NOT EXECUTED
6478: e593f020 ldr pc, [r3, #32] <== NOT EXECUTED
647c: e3500000 cmp r0, #0 <== NOT EXECUTED
6480: 0affffd5 beq 63dc <unmount+0xa4> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
6484: e1a00006 mov r0, r6 <== NOT EXECUTED
6488: eb0003ff bl 748c <rtems_fatal_error_occurred> <== NOT EXECUTED
00004fdc <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
4fdc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
4fe0: e1a0a000 mov sl, r0
for (; *fmt != '\0'; fmt++) {
4fe4: e5d00000 ldrb r0, [r0]
*/
void vprintk(
const char *fmt,
va_list ap
)
{
4fe8: e24dd01c sub sp, sp, #28
for (; *fmt != '\0'; fmt++) {
4fec: e3500000 cmp r0, #0
*/
void vprintk(
const char *fmt,
va_list ap
)
{
4ff0: e58d1000 str r1, [sp]
for (; *fmt != '\0'; fmt++) {
4ff4: 0a00006e beq 51b4 <vprintk+0x1d8>
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
BSP_output_char(*fmt);
4ff8: e59f8340 ldr r8, [pc, #832] ; 5340 <vprintk+0x364>
* console is not yet initialized or in ISR's. * * Arguments: * as in printf: fmt - format string, ... - unnamed arguments. */ void vprintk(
4ffc: e28db008 add fp, sp, #8
bool minus = false;
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
5000: e3500025 cmp r0, #37 ; 0x25
5004: 1a00006d bne 51c0 <vprintk+0x1e4>
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
5008: e5fa3001 ldrb r3, [sl, #1]!
500c: e3530030 cmp r3, #48 ; 0x30
lead = '0';
fmt++;
5010: 05fa3001 ldrbeq r3, [sl, #1]!
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
5014: 03a02030 moveq r2, #48 ; 0x30
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
5018: 13a02020 movne r2, #32
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
501c: 058d2004 streq r2, [sp, #4]
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
5020: 158d2004 strne r2, [sp, #4]
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
5024: e353002d cmp r3, #45 ; 0x2d
minus = true;
fmt++;
5028: 05fa3001 ldrbeq r3, [sl, #1]!
}
while (*fmt >= '0' && *fmt <= '9' ) {
502c: e2432030 sub r2, r3, #48 ; 0x30
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
5030: 03a09001 moveq r9, #1
{
for (; *fmt != '\0'; fmt++) {
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
5034: 13a09000 movne r9, #0
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
5038: e3520009 cmp r2, #9
503c: 83a06000 movhi r6, #0
5040: 8a000009 bhi 506c <vprintk+0x90>
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
5044: e28a2001 add r2, sl, #1
5048: e3a06000 mov r6, #0
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
504c: e0866106 add r6, r6, r6, lsl #2
width += ((unsigned) *fmt - '0');
5050: e0836086 add r6, r3, r6, lsl #1
5054: e1a0a002 mov sl, r2
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
5058: e4d23001 ldrb r3, [r2], #1
505c: e2431030 sub r1, r3, #48 ; 0x30
5060: e3510009 cmp r1, #9
width *= 10;
width += ((unsigned) *fmt - '0');
5064: e2466030 sub r6, r6, #48 ; 0x30
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
5068: 9afffff7 bls 504c <vprintk+0x70>
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
506c: e353006c cmp r3, #108 ; 0x6c
lflag = true;
c = *++fmt;
5070: 05fa3001 ldrbeq r3, [sl, #1]!
}
if ( c == 'c' ) {
5074: e3530063 cmp r3, #99 ; 0x63
5078: 0a00008c beq 52b0 <vprintk+0x2d4>
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
BSP_output_char(chr);
continue;
}
if ( c == 's' ) {
507c: e3530073 cmp r3, #115 ; 0x73
5080: 0a000054 beq 51d8 <vprintk+0x1fc>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
5084: e353006f cmp r3, #111 ; 0x6f
5088: 1353004f cmpne r3, #79 ; 0x4f
base = 8; sign = false;
508c: 03a03000 moveq r3, #0
5090: 03a09008 moveq r9, #8
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
5094: 0a000009 beq 50c0 <vprintk+0xe4>
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
5098: e3530069 cmp r3, #105 ; 0x69
509c: 13530049 cmpne r3, #73 ; 0x49
50a0: 0a000004 beq 50b8 <vprintk+0xdc>
c == 'd' || c == 'D' ) {
50a4: e3530064 cmp r3, #100 ; 0x64
50a8: 13530044 cmpne r3, #68 ; 0x44
50ac: 13a01000 movne r1, #0
50b0: 03a01001 moveq r1, #1
50b4: 1a000087 bne 52d8 <vprintk+0x2fc>
base = 10; sign = true;
50b8: e3a03001 mov r3, #1
50bc: e3a0900a mov r9, #10
} else {
BSP_output_char(c);
continue;
}
printNum(
50c0: e59d2000 ldr r2, [sp]
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
50c4: e3530000 cmp r3, #0
} else {
BSP_output_char(c);
continue;
}
printNum(
50c8: e5927000 ldr r7, [r2]
lflag ? va_arg(ap, long) : (long) va_arg(ap, int),
50cc: e2822004 add r2, r2, #4
50d0: e58d2000 str r2, [sp]
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
50d4: 0a000001 beq 50e0 <vprintk+0x104>
50d8: e3570000 cmp r7, #0
50dc: ba000090 blt 5324 <vprintk+0x348>
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
50e0: e1a00007 mov r0, r7
50e4: e1a01009 mov r1, r9
50e8: eb003150 bl 11630 <__aeabi_uidiv>
50ec: e3500000 cmp r0, #0
50f0: e1a04000 mov r4, r0
50f4: e1a05000 mov r5, r0
50f8: 01a04007 moveq r4, r7
50fc: 03a07001 moveq r7, #1
5100: 0a000010 beq 5148 <vprintk+0x16c>
5104: e20930ff and r3, r9, #255 ; 0xff
5108: e1a02007 mov r2, r7
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
510c: e3a05000 mov r5, #0
5110: e1a07003 mov r7, r3
5114: ea000001 b 5120 <vprintk+0x144>
while ((n = unsigned_num / base) > 0) {
5118: e1a02004 mov r2, r4
511c: e1a04000 mov r4, r0
toPrint[count++] = (char) (unsigned_num - (n * base));
5120: e0030794 mul r3, r4, r7
5124: e0633002 rsb r3, r3, r2
5128: e7cb3005 strb r3, [fp, r5]
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
512c: e1a00004 mov r0, r4
5130: e1a01009 mov r1, r9
5134: eb00313d bl 11630 <__aeabi_uidiv>
5138: e3500000 cmp r0, #0
toPrint[count++] = (char) (unsigned_num - (n * base));
513c: e2855001 add r5, r5, #1
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
5140: 1afffff4 bne 5118 <vprintk+0x13c>
5144: e2857001 add r7, r5, #1
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
5148: e28d301c add r3, sp, #28
514c: e0835005 add r5, r3, r5
for (n=maxwidth ; n > count; n-- )
5150: e1570006 cmp r7, r6
count = 0;
while ((n = unsigned_num / base) > 0) {
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
5154: e5454014 strb r4, [r5, #-20]
for (n=maxwidth ; n > count; n-- )
5158: 2a000006 bcs 5178 <vprintk+0x19c>
515c: e59d4004 ldr r4, [sp, #4]
BSP_output_char(lead);
5160: e1a00004 mov r0, r4
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
5164: e2466001 sub r6, r6, #1
BSP_output_char(lead);
5168: e1a0e00f mov lr, pc
516c: e598f000 ldr pc, [r8]
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
5170: e1570006 cmp r7, r6
5174: 3afffff9 bcc 5160 <vprintk+0x184>
BSP_output_char(lead);
for (n = 0; n < count; n++) {
5178: e3570000 cmp r7, #0
517c: 0a000009 beq 51a8 <vprintk+0x1cc>
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
5180: e08b5007 add r5, fp, r7
5184: e3a04000 mov r4, #0
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)])]);
5188: e5753001 ldrb r3, [r5, #-1]!
518c: e59f21b0 ldr r2, [pc, #432] ; 5344 <vprintk+0x368>
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
5190: e2844001 add r4, r4, #1
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
5194: e7d20003 ldrb r0, [r2, r3]
5198: e1a0e00f mov lr, pc
519c: e598f000 ldr pc, [r8]
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
51a0: e1570004 cmp r7, r4
51a4: 8afffff7 bhi 5188 <vprintk+0x1ac>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
51a8: e5fa0001 ldrb r0, [sl, #1]!
51ac: e3500000 cmp r0, #0
51b0: 1affff92 bne 5000 <vprintk+0x24>
sign,
width,
lead
);
}
}
51b4: e28dd01c add sp, sp, #28
51b8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
} else if ( c == 'x' || c == 'X' ) {
base = 16; sign = false;
} else if ( c == 'p' ) {
base = 16; sign = false; lflag = true;
} else {
BSP_output_char(c);
51bc: e1a00003 mov r0, r3
51c0: e1a0e00f mov lr, pc
51c4: e598f000 ldr pc, [r8]
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
51c8: e5fa0001 ldrb r0, [sl, #1]!
51cc: e3500000 cmp r0, #0
51d0: 1affff8a bne 5000 <vprintk+0x24>
51d4: eafffff6 b 51b4 <vprintk+0x1d8>
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
51d8: e59d2000 ldr r2, [sp]
51dc: e5925000 ldr r5, [r2]
if ( str == NULL ) {
str = "";
51e0: e59f3160 ldr r3, [pc, #352] ; 5348 <vprintk+0x36c>
51e4: e3550000 cmp r5, #0
51e8: 01a05003 moveq r5, r3
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
51ec: e5d54000 ldrb r4, [r5]
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
51f0: e2822004 add r2, r2, #4
if ( str == NULL ) {
str = "";
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
51f4: e3540000 cmp r4, #0
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
51f8: e58d2000 str r2, [sp]
if ( str == NULL ) {
str = "";
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
51fc: 0a000005 beq 5218 <vprintk+0x23c>
5200: e1a03005 mov r3, r5
5204: e3a04000 mov r4, #0
5208: e5f32001 ldrb r2, [r3, #1]!
520c: e3520000 cmp r2, #0
5210: e2844001 add r4, r4, #1
5214: 1afffffb bne 5208 <vprintk+0x22c>
;
/* leading spaces */
if ( !minus )
5218: e3590000 cmp r9, #0
521c: 1a000008 bne 5244 <vprintk+0x268>
for ( i=len ; i<width ; i++ )
5220: e1540006 cmp r4, r6
5224: 2a000006 bcs 5244 <vprintk+0x268>
5228: e1a07004 mov r7, r4
BSP_output_char(' ');
522c: e3a00020 mov r0, #32
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
5230: e2877001 add r7, r7, #1
BSP_output_char(' ');
5234: e1a0e00f mov lr, pc
5238: e598f000 ldr pc, [r8]
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
523c: e1570006 cmp r7, r6
5240: 3afffff9 bcc 522c <vprintk+0x250>
BSP_output_char(' ');
/* no width option */
if (width == 0) {
5244: e3560000 cmp r6, #0
5248: 1a000002 bne 5258 <vprintk+0x27c>
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
524c: e3540000 cmp r4, #0
5250: 0a000008 beq 5278 <vprintk+0x29c>
5254: e1a06004 mov r6, r4
5258: e5d50000 ldrb r0, [r5]
525c: e3500000 cmp r0, #0
5260: 0a000004 beq 5278 <vprintk+0x29c>
BSP_output_char(*str);
5264: e1a0e00f mov lr, pc
5268: e598f000 ldr pc, [r8]
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
526c: e5f50001 ldrb r0, [r5, #1]!
5270: e3500000 cmp r0, #0
5274: 1afffffa bne 5264 <vprintk+0x288>
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
5278: e3590000 cmp r9, #0
527c: 0affffc9 beq 51a8 <vprintk+0x1cc>
for ( i=len ; i<width ; i++ )
5280: e1540006 cmp r4, r6
5284: 2affffc7 bcs 51a8 <vprintk+0x1cc>
BSP_output_char(' ');
5288: e3a00020 mov r0, #32
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
528c: e2844001 add r4, r4, #1
BSP_output_char(' ');
5290: e1a0e00f mov lr, pc
5294: e598f000 ldr pc, [r8]
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
5298: e1540006 cmp r4, r6
529c: 3afffff9 bcc 5288 <vprintk+0x2ac>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
52a0: e5fa0001 ldrb r0, [sl, #1]!
52a4: e3500000 cmp r0, #0
52a8: 1affff54 bne 5000 <vprintk+0x24>
52ac: eaffffc0 b 51b4 <vprintk+0x1d8> <== NOT EXECUTED
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
52b0: e59d3000 ldr r3, [sp]
52b4: e2834004 add r4, r3, #4
BSP_output_char(chr);
52b8: e5d30000 ldrb r0, [r3]
52bc: e1a0e00f mov lr, pc
52c0: e598f000 ldr pc, [r8]
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
52c4: e58d4000 str r4, [sp]
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
52c8: e5fa0001 ldrb r0, [sl, #1]!
52cc: e3500000 cmp r0, #0
52d0: 1affff4a bne 5000 <vprintk+0x24>
52d4: eaffffb6 b 51b4 <vprintk+0x1d8> <== NOT EXECUTED
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
52d8: e3530075 cmp r3, #117 ; 0x75
52dc: 13530055 cmpne r3, #85 ; 0x55
52e0: 13a00000 movne r0, #0
52e4: 03a00001 moveq r0, #1
base = 10; sign = false;
52e8: 01a03001 moveq r3, r1
52ec: 03a0900a moveq r9, #10
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
52f0: 0affff72 beq 50c0 <vprintk+0xe4>
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
52f4: e3530078 cmp r3, #120 ; 0x78
52f8: 13530058 cmpne r3, #88 ; 0x58
52fc: 13a01000 movne r1, #0
5300: 03a01001 moveq r1, #1
base = 16; sign = false;
5304: 01a03000 moveq r3, r0
5308: 03a09010 moveq r9, #16
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
530c: 0affff6b beq 50c0 <vprintk+0xe4>
base = 16; sign = false;
} else if ( c == 'p' ) {
5310: e3530070 cmp r3, #112 ; 0x70
5314: 1affffa8 bne 51bc <vprintk+0x1e0>
base = 16; sign = false; lflag = true;
5318: e1a03001 mov r3, r1
531c: e3a09010 mov r9, #16
5320: eaffff66 b 50c0 <vprintk+0xe4>
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
BSP_output_char('-');
5324: e3a0002d mov r0, #45 ; 0x2d
5328: e1a0e00f mov lr, pc
532c: e598f000 ldr pc, [r8]
unsigned_num = (unsigned long) -num;
if (maxwidth) maxwidth--;
5330: e3560000 cmp r6, #0
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
BSP_output_char('-');
unsigned_num = (unsigned long) -num;
5334: e2677000 rsb r7, r7, #0
if (maxwidth) maxwidth--;
5338: 12466001 subne r6, r6, #1
533c: eaffff67 b 50e0 <vprintk+0x104>
000067e0 <writev>:
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
67e0: e59f315c ldr r3, [pc, #348] ; 6944 <writev+0x164>
67e4: e5933000 ldr r3, [r3]
67e8: e1500003 cmp r0, r3
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
67ec: e92d41f0 push {r4, r5, r6, r7, r8, lr}
67f0: e1a05002 mov r5, r2
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
67f4: 2a00004b bcs 6928 <writev+0x148>
iop = rtems_libio_iop( fd );
67f8: e59f3148 ldr r3, [pc, #328] ; 6948 <writev+0x168>
67fc: e5933000 ldr r3, [r3]
6800: e0600180 rsb r0, r0, r0, lsl #3
6804: e0838180 add r8, r3, r0, lsl #3
rtems_libio_check_is_open( iop );
6808: e5983014 ldr r3, [r8, #20]
680c: e3130c01 tst r3, #256 ; 0x100
6810: 0a000044 beq 6928 <writev+0x148>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
6814: e3130004 tst r3, #4
6818: 0a00003c beq 6910 <writev+0x130>
/*
* Argument validation on IO vector
*/
if ( !iov )
681c: e3510000 cmp r1, #0
6820: 0a00003a beq 6910 <writev+0x130>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
6824: e3520000 cmp r2, #0
6828: da000038 ble 6910 <writev+0x130>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
682c: e3520b01 cmp r2, #1024 ; 0x400
6830: ca000036 bgt 6910 <writev+0x130>
rtems_set_errno_and_return_minus_one( EINVAL );
6834: e1a04001 mov r4, r1
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
6838: e3a0cc7f mov ip, #32512 ; 0x7f00
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
683c: e3a01000 mov r1, #0
6840: e1a02004 mov r2, r4
6844: e3a06001 mov r6, #1
6848: e1a07001 mov r7, r1
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
684c: e28cc0ff add ip, ip, #255 ; 0xff
6850: ea000000 b 6858 <writev+0x78>
if ( iov[v].iov_len )
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
6854: e1a07003 mov r7, r3
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
6858: e5923000 ldr r3, [r2]
685c: e3530000 cmp r3, #0
* 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++ ) {
6860: e2811001 add r1, r1, #1
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
6864: 0a000029 beq 6910 <writev+0x130>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
6868: e5920004 ldr r0, [r2, #4]
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
686c: e0873000 add r3, r7, r0
*/
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
6870: e3500000 cmp r0, #0
6874: 13a06000 movne r6, #0
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
6878: e1570003 cmp r7, r3
687c: d153000c cmple r3, ip
6880: d3a07000 movle r7, #0
6884: c3a07001 movgt r7, #1
6888: ca000020 bgt 6910 <writev+0x130>
* 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++ ) {
688c: e1550001 cmp r5, r1
6890: e2822008 add r2, r2, #8
6894: caffffee bgt 6854 <writev+0x74>
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
6898: e3560000 cmp r6, #0
689c: 1a00001f bne 6920 <writev+0x140>
68a0: e1a07006 mov r7, r6
68a4: ea000003 b 68b8 <writev+0xd8>
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
68a8: e2866001 add r6, r6, #1
68ac: e1550006 cmp r5, r6
68b0: e2844008 add r4, r4, #8
68b4: da000019 ble 6920 <writev+0x140>
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
68b8: e5942004 ldr r2, [r4, #4]
68bc: e3520000 cmp r2, #0
68c0: 0afffff8 beq 68a8 <writev+0xc8>
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
68c4: e5941000 ldr r1, [r4]
68c8: e5983020 ldr r3, [r8, #32]
68cc: e1a00008 mov r0, r8
68d0: e1a0e00f mov lr, pc
68d4: e593f00c ldr pc, [r3, #12]
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
68d8: e3500000 cmp r0, #0
68dc: ba000016 blt 693c <writev+0x15c>
return -1;
if ( bytes > 0 ) {
68e0: 0a000006 beq 6900 <writev+0x120>
iop->offset += bytes;
68e4: e288300c add r3, r8, #12
68e8: e893000c ldm r3, {r2, r3}
68ec: e0922000 adds r2, r2, r0
68f0: e0a33fc0 adc r3, r3, r0, asr #31
68f4: e588200c str r2, [r8, #12]
68f8: e5883010 str r3, [r8, #16]
total += bytes;
68fc: e0877000 add r7, r7, r0
}
if (bytes != iov[ v ].iov_len)
6900: e5943004 ldr r3, [r4, #4]
6904: e1500003 cmp r0, r3
6908: 0affffe6 beq 68a8 <writev+0xc8>
690c: ea000003 b 6920 <writev+0x140> <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
6910: eb0021ae bl efd0 <__errno>
6914: e3a03016 mov r3, #22
6918: e5803000 str r3, [r0]
691c: e3e07000 mvn r7, #0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
6920: e1a00007 mov r0, r7
6924: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
6928: eb0021a8 bl efd0 <__errno>
692c: e3a03009 mov r3, #9
6930: e5803000 str r3, [r0]
6934: e3e07000 mvn r7, #0
6938: eafffff8 b 6920 <writev+0x140>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
693c: e3e07000 mvn r7, #0 <== NOT EXECUTED
6940: eafffff6 b 6920 <writev+0x140> <== NOT EXECUTED