3000948c <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 ) {
3000948c: e5903000 ldr r3, [r0]
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
30009490: e5902010 ldr r2, [r0, #16]
switch( node->type ) {
30009494: 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;
30009498: e5922034 ldr r2, [r2, #52] ; 0x34
switch( node->type ) {
3000949c: e2433001 sub r3, r3, #1 300094a0: e3530006 cmp r3, #6 300094a4: 979ff103 ldrls pc, [pc, r3, lsl #2]
300094a8: ea000008 b 300094d0 <IMFS_Set_handlers+0x44> <== NOT EXECUTED 300094ac: 300094f8 .word 0x300094f8 <== NOT EXECUTED 300094b0: 30009508 .word 0x30009508 <== NOT EXECUTED 300094b4: 300094e8 .word 0x300094e8 <== NOT EXECUTED 300094b8: 300094e8 .word 0x300094e8 <== NOT EXECUTED 300094bc: 300094d8 .word 0x300094d8 <== NOT EXECUTED 300094c0: 300094d8 .word 0x300094d8 <== NOT EXECUTED 300094c4: 300094c8 .word 0x300094c8 <== NOT EXECUTED
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
300094c8: e5923010 ldr r3, [r2, #16] 300094cc: e5803008 str r3, [r0, #8]
break;
}
return 0;
}
300094d0: e3a00000 mov r0, #0 300094d4: 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;
300094d8: e5923008 ldr r3, [r2, #8] 300094dc: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
300094e0: e3a00000 mov r0, #0 300094e4: 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;
300094e8: e59f3028 ldr r3, [pc, #40] ; 30009518 <IMFS_Set_handlers+0x8c> 300094ec: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
300094f0: e3a00000 mov r0, #0 300094f4: 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;
300094f8: e592300c ldr r3, [r2, #12] 300094fc: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
30009500: e3a00000 mov r0, #0 30009504: e12fff1e bx lr
switch( node->type ) {
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
30009508: e59f300c ldr r3, [pc, #12] ; 3000951c <IMFS_Set_handlers+0x90> 3000950c: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
30009510: e3a00000 mov r0, #0 30009514: e12fff1e bx lr
300095d4 <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
300095d4: 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 ) ) {
300095d8: e3d25007 bics r5, r2, #7
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
300095dc: e24dd040 sub sp, sp, #64 ; 0x40 300095e0: e58d2000 str r2, [sp] 300095e4: e1a0a000 mov sl, r0 300095e8: e1a04001 mov r4, r1 300095ec: 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 ) ) {
300095f0: 1a000081 bne 300097fc <IMFS_eval_path+0x228>
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
300095f4: e5936000 ldr r6, [r3] 300095f8: e28d8004 add r8, sp, #4 300095fc: 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 );
30009600: e1a02008 mov r2, r8 30009604: e1a03009 mov r3, r9 30009608: e08a0005 add r0, sl, r5 3000960c: e1a01004 mov r1, r4 30009610: eb0001e1 bl 30009d9c <IMFS_get_token>
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
30009614: e5973000 ldr r3, [r7]
* 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 );
30009618: e1a0b000 mov fp, r0
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
3000961c: e3530000 cmp r3, #0
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
30009620: e59d203c ldr r2, [sp, #60] ; 0x3c
i += len;
if ( !pathloc->node_access )
30009624: 0a00004e beq 30009764 <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 )
30009628: 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;
3000962c: e0624004 rsb r4, r2, r4
i += len;
30009630: 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 )
30009634: 1a00000f bne 30009678 <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 ) {
30009638: e593204c ldr r2, [r3, #76] ; 0x4c 3000963c: e3520001 cmp r2, #1
30009640: 0a000068 beq 300097e8 <IMFS_eval_path+0x214>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
30009644: e1a00007 mov r0, r7 30009648: ebffff8f bl 3000948c <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
3000964c: e59d1000 ldr r1, [sp]
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
30009650: e1a06000 mov r6, r0
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
30009654: e1a00007 mov r0, r7 30009658: ebffffb0 bl 30009520 <IMFS_evaluate_permission> 3000965c: e3500000 cmp r0, #0
30009660: 1a000036 bne 30009740 <IMFS_eval_path+0x16c>
rtems_set_errno_and_return_minus_one( EACCES );
30009664: eb001163 bl 3000dbf8 <__errno> 30009668: e3a0300d mov r3, #13 3000966c: e5803000 str r3, [r0] 30009670: e3e06000 mvn r6, #0 30009674: ea000031 b 30009740 <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 )
30009678: e596104c ldr r1, [r6, #76] ; 0x4c 3000967c: e3510001 cmp r1, #1
30009680: 0a000031 beq 3000974c <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 ) {
30009684: 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;
30009688: e1a06003 mov r6, r3
switch( type ) {
3000968c: 0a000006 beq 300096ac <IMFS_eval_path+0xd8>
30009690: e35b0004 cmp fp, #4
30009694: 0a000025 beq 30009730 <IMFS_eval_path+0x15c>
30009698: e35b0002 cmp fp, #2
3000969c: 0a000013 beq 300096f0 <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) ) {
300096a0: e35b0004 cmp fp, #4
300096a4: 1affffd5 bne 30009600 <IMFS_eval_path+0x2c>
300096a8: eaffffe2 b 30009638 <IMFS_eval_path+0x64> <== NOT EXECUTED
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
300096ac: e593304c ldr r3, [r3, #76] ; 0x4c 300096b0: e3530003 cmp r3, #3
300096b4: 0a00002f beq 30009778 <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 ) {
300096b8: e3530004 cmp r3, #4
300096bc: 0a000058 beq 30009824 <IMFS_eval_path+0x250>
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
300096c0: e3530001 cmp r3, #1
300096c4: 1a000051 bne 30009810 <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 ) {
300096c8: e596e05c ldr lr, [r6, #92] ; 0x5c 300096cc: e35e0000 cmp lr, #0
300096d0: 1a000047 bne 300097f4 <IMFS_eval_path+0x220>
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
300096d4: e1a00006 mov r0, r6 300096d8: e1a01008 mov r1, r8 300096dc: eb00018b bl 30009d10 <IMFS_find_match_in_dir>
if ( !node )
300096e0: e2506000 subs r6, r0, #0
300096e4: 0a00001e beq 30009764 <IMFS_eval_path+0x190>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
300096e8: e5876000 str r6, [r7] 300096ec: eaffffc3 b 30009600 <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 )
300096f0: e59f1154 ldr r1, [pc, #340] ; 3000984c <IMFS_eval_path+0x278> 300096f4: e5912000 ldr r2, [r1] 300096f8: e5922018 ldr r2, [r2, #24] 300096fc: e1520003 cmp r2, r3
30009700: 0affffbe beq 30009600 <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) {
30009704: e597e010 ldr lr, [r7, #16]
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
30009708: e59e201c ldr r2, [lr, #28] 3000970c: e1520003 cmp r2, r3
30009710: 0a00001e beq 30009790 <IMFS_eval_path+0x1bc>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
30009714: e5936008 ldr r6, [r3, #8] 30009718: e3560000 cmp r6, #0
3000971c: 1afffff1 bne 300096e8 <IMFS_eval_path+0x114>
rtems_set_errno_and_return_minus_one( ENOENT );
30009720: eb001134 bl 3000dbf8 <__errno> 30009724: e3e06000 mvn r6, #0 30009728: e580b000 str fp, [r0] 3000972c: ea000003 b 30009740 <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 );
30009730: eb001130 bl 3000dbf8 <__errno> 30009734: e3a0305b mov r3, #91 ; 0x5b 30009738: e5803000 str r3, [r0] 3000973c: e3e06000 mvn r6, #0
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
30009740: e1a00006 mov r0, r6
30009744: e28dd040 add sp, sp, #64 ; 0x40
30009748: 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 ) )
3000974c: e1a00007 mov r0, r7 30009750: ebffff72 bl 30009520 <IMFS_evaluate_permission> 30009754: e3500000 cmp r0, #0
30009758: 0affffc1 beq 30009664 <IMFS_eval_path+0x90>
3000975c: e5973000 ldr r3, [r7] 30009760: eaffffc7 b 30009684 <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 );
30009764: eb001123 bl 3000dbf8 <__errno> 30009768: e3a03002 mov r3, #2 3000976c: e5803000 str r3, [r0] 30009770: e3e06000 mvn r6, #0 30009774: eafffff1 b 30009740 <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 );
30009778: e1a00007 mov r0, r7 3000977c: e3a01000 mov r1, #0 30009780: ebffff80 bl 30009588 <IMFS_evaluate_hard_link>
node = pathloc->node_access;
30009784: e5976000 ldr r6, [r7] 30009788: e596304c ldr r3, [r6, #76] ; 0x4c 3000978c: eaffffcb b 300096c0 <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;
30009790: 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;
30009794: e28d6028 add r6, sp, #40 ; 0x28
30009798: e8be000f ldm lr!, {r0, r1, r2, r3}
3000979c: e8a6000f stmia r6!, {r0, r1, r2, r3}
*pathloc = newloc;
300097a0: e28dc028 add ip, sp, #40 ; 0x28
300097a4: 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;
300097a8: e59ec000 ldr ip, [lr]
*pathloc = newloc;
300097ac: e1a0e007 mov lr, r7
300097b0: e8ae000f stmia lr!, {r0, r1, r2, r3}
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
300097b4: 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;
300097b8: e58ec000 str ip, [lr]
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
300097bc: 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;
300097c0: e586c000 str ip, [r6]
*pathloc = newloc;
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
300097c4: e08a0000 add r0, sl, r0 300097c8: e597c00c ldr ip, [r7, #12] 300097cc: e0841001 add r1, r4, r1 300097d0: e59d2000 ldr r2, [sp] 300097d4: e1a03007 mov r3, r7 300097d8: e1a0e00f mov lr, pc 300097dc: e59cf000 ldr pc, [ip] 300097e0: e1a06000 mov r6, r0 300097e4: eaffffd5 b 30009740 <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 ) {
300097e8: e593e05c ldr lr, [r3, #92] ; 0x5c 300097ec: e35e0000 cmp lr, #0
300097f0: 0affff93 beq 30009644 <IMFS_eval_path+0x70>
newloc = node->info.directory.mt_fs->mt_fs_root;
300097f4: e28ee01c add lr, lr, #28 300097f8: eaffffe5 b 30009794 <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 );
300097fc: eb0010fd bl 3000dbf8 <__errno> <== NOT EXECUTED 30009800: e3a03005 mov r3, #5 <== NOT EXECUTED 30009804: e5803000 str r3, [r0] <== NOT EXECUTED 30009808: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000980c: eaffffcb b 30009740 <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 );
30009810: eb0010f8 bl 3000dbf8 <__errno> 30009814: e3a03014 mov r3, #20 30009818: e5803000 str r3, [r0] 3000981c: e3e06000 mvn r6, #0 30009820: eaffffc6 b 30009740 <IMFS_eval_path+0x16c>
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
30009824: e1a00007 mov r0, r7 30009828: e3a01000 mov r1, #0 3000982c: eb000007 bl 30009850 <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 )
30009830: e3700001 cmn r0, #1
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
30009834: e1a06000 mov r6, r0
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
30009838: e5973000 ldr r3, [r7]
if ( result == -1 )
3000983c: 0affffbf beq 30009740 <IMFS_eval_path+0x16c>
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
30009840: e1a06003 mov r6, r3 30009844: e593304c ldr r3, [r3, #76] ; 0x4c 30009848: eaffff9c b 300096c0 <IMFS_eval_path+0xec>
300099b8 <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 */
)
{
300099b8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
300099bc: e24dd040 sub sp, sp, #64 ; 0x40
300099c0: e1a06001 mov r6, r1
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
300099c4: 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 */
)
{
300099c8: e1a0a000 mov sl, r0 300099cc: e58d2000 str r2, [sp]
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
300099d0: eb001472 bl 3000eba0 <strlen>
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
int i = 0;
300099d4: e3a07000 mov r7, #0
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
300099d8: e1a04000 mov r4, r0 300099dc: 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 );
300099e0: e1a01004 mov r1, r4 300099e4: e28d303c add r3, sp, #60 ; 0x3c 300099e8: e08a0007 add r0, sl, r7 300099ec: e1a02008 mov r2, r8 300099f0: eb0000e9 bl 30009d9c <IMFS_get_token>
pathlen -= len;
i += len;
if ( !pathloc->node_access )
300099f4: e5963000 ldr r3, [r6]
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
300099f8: e59db03c ldr fp, [sp, #60] ; 0x3c
i += len;
if ( !pathloc->node_access )
300099fc: 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 );
30009a00: e1a09000 mov r9, r0
pathlen -= len;
30009a04: e06b4004 rsb r4, fp, r4
i += len;
if ( !pathloc->node_access )
30009a08: 0a000035 beq 30009ae4 <IMFS_evaluate_for_make+0x12c>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
30009a0c: e3500000 cmp r0, #0
30009a10: 1a000006 bne 30009a30 <IMFS_evaluate_for_make+0x78>
pathloc->node_access = node;
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
30009a14: eb001077 bl 3000dbf8 <__errno> 30009a18: e3a03011 mov r3, #17 30009a1c: e5803000 str r3, [r0] 30009a20: e3e05000 mvn r5, #0
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
30009a24: e1a00005 mov r0, r5
30009a28: e28dd040 add sp, sp, #64 ; 0x40
30009a2c: 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 )
30009a30: e595104c ldr r1, [r5, #76] ; 0x4c 30009a34: e3510001 cmp r1, #1
30009a38: 0a000044 beq 30009b50 <IMFS_evaluate_for_make+0x198>
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
30009a3c: 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;
30009a40: e1a05003 mov r5, r3
switch( type ) {
30009a44: e3590004 cmp r9, #4 30009a48: 979ff109 ldrls pc, [pc, r9, lsl #2]
30009a4c: eaffffe3 b 300099e0 <IMFS_evaluate_for_make+0x28> <== NOT EXECUTED 30009a50: 30009a14 .word 0x30009a14 <== NOT EXECUTED 30009a54: 300099e0 .word 0x300099e0 <== NOT EXECUTED 30009a58: 30009ab4 .word 0x30009ab4 <== NOT EXECUTED 30009a5c: 30009a64 .word 0x30009a64 <== NOT EXECUTED 30009a60: 30009af8 .word 0x30009af8 <== NOT EXECUTED
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
30009a64: e593304c ldr r3, [r3, #76] ; 0x4c 30009a68: e3530003 cmp r3, #3
30009a6c: 0a00006a beq 30009c1c <IMFS_evaluate_for_make+0x264>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
30009a70: e3530004 cmp r3, #4
30009a74: 0a000068 beq 30009c1c <IMFS_evaluate_for_make+0x264>
if ( result == -1 )
return -1;
}
node = pathloc->node_access;
if ( !node )
30009a78: e3550000 cmp r5, #0
30009a7c: 0a00005f beq 30009c00 <IMFS_evaluate_for_make+0x248>
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
30009a80: e595304c ldr r3, [r5, #76] ; 0x4c 30009a84: e3530001 cmp r3, #1
30009a88: 1a00005c bne 30009c00 <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 ) {
30009a8c: e595c05c ldr ip, [r5, #92] ; 0x5c 30009a90: e35c0000 cmp ip, #0
30009a94: 1a00005e bne 30009c14 <IMFS_evaluate_for_make+0x25c>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
30009a98: e1a00005 mov r0, r5 30009a9c: e1a01008 mov r1, r8 30009aa0: eb00009a bl 30009d10 <IMFS_find_match_in_dir>
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
30009aa4: e2505000 subs r5, r0, #0
30009aa8: 0a000017 beq 30009b0c <IMFS_evaluate_for_make+0x154>
done = true;
else
pathloc->node_access = node;
30009aac: e5865000 str r5, [r6] 30009ab0: eaffffca b 300099e0 <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 )
30009ab4: e59f1180 ldr r1, [pc, #384] ; 30009c3c <IMFS_evaluate_for_make+0x284> 30009ab8: e5912000 ldr r2, [r1] 30009abc: e5922018 ldr r2, [r2, #24] 30009ac0: e1530002 cmp r3, r2
30009ac4: 0affffc5 beq 300099e0 <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){
30009ac8: e596c010 ldr ip, [r6, #16] 30009acc: e59c201c ldr r2, [ip, #28] 30009ad0: e1530002 cmp r3, r2
30009ad4: 0a000023 beq 30009b68 <IMFS_evaluate_for_make+0x1b0>
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
30009ad8: e5935008 ldr r5, [r3, #8] 30009adc: e3550000 cmp r5, #0
30009ae0: 1afffff1 bne 30009aac <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 );
30009ae4: eb001043 bl 3000dbf8 <__errno> 30009ae8: e3a03002 mov r3, #2 30009aec: e5803000 str r3, [r0] 30009af0: e3e05000 mvn r5, #0 30009af4: eaffffca b 30009a24 <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 );
30009af8: eb00103e bl 3000dbf8 <__errno> 30009afc: e3a0305b mov r3, #91 ; 0x5b 30009b00: e5803000 str r3, [r0] 30009b04: e3e05000 mvn r5, #0 30009b08: eaffffc5 b 30009a24 <IMFS_evaluate_for_make+0x6c>
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
30009b0c: e59d303c ldr r3, [sp, #60] ; 0x3c 30009b10: e59d1000 ldr r1, [sp] 30009b14: e0633007 rsb r3, r3, r7 30009b18: e08a3003 add r3, sl, r3 30009b1c: 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++) {
30009b20: e7da0007 ldrb r0, [sl, r7] 30009b24: e08a4007 add r4, sl, r7 30009b28: e3500000 cmp r0, #0
30009b2c: 1a000003 bne 30009b40 <IMFS_evaluate_for_make+0x188>
30009b30: ea000021 b 30009bbc <IMFS_evaluate_for_make+0x204> 30009b34: e5f40001 ldrb r0, [r4, #1]! 30009b38: e3500000 cmp r0, #0
30009b3c: 0a00001e beq 30009bbc <IMFS_evaluate_for_make+0x204>
if ( !IMFS_is_separator( path[ i ] ) )
30009b40: ebffe4e6 bl 30002ee0 <rtems_filesystem_is_separator> 30009b44: e3500000 cmp r0, #0
30009b48: 1afffff9 bne 30009b34 <IMFS_evaluate_for_make+0x17c>
30009b4c: eaffffe4 b 30009ae4 <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 ) )
30009b50: e1a00006 mov r0, r6 30009b54: ebfffe71 bl 30009520 <IMFS_evaluate_permission> 30009b58: e3500000 cmp r0, #0
30009b5c: 0a000022 beq 30009bec <IMFS_evaluate_for_make+0x234>
30009b60: e5963000 ldr r3, [r6] 30009b64: eaffffb4 b 30009a3c <IMFS_evaluate_for_make+0x84>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
30009b68: 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;
30009b6c: e28d4028 add r4, sp, #40 ; 0x28
30009b70: e8bc000f ldm ip!, {r0, r1, r2, r3}
30009b74: e8a4000f stmia r4!, {r0, r1, r2, r3}
*pathloc = newloc;
30009b78: e28de028 add lr, sp, #40 ; 0x28
30009b7c: e8be000f ldm lr!, {r0, r1, r2, r3}
30009b80: 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;
30009b84: e59cc000 ldr ip, [ip]
*pathloc = newloc;
30009b88: e8ae000f stmia lr!, {r0, r1, r2, r3}
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
30009b8c: 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;
30009b90: e58ec000 str ip, [lr]
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
30009b94: 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;
30009b98: e584c000 str ip, [r4]
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
30009b9c: e596300c ldr r3, [r6, #12] 30009ba0: e08a0000 add r0, sl, r0 30009ba4: e1a01006 mov r1, r6 30009ba8: e59d2000 ldr r2, [sp] 30009bac: e1a0e00f mov lr, pc 30009bb0: e593f004 ldr pc, [r3, #4] 30009bb4: e1a05000 mov r5, r0 30009bb8: eaffff99 b 30009a24 <IMFS_evaluate_for_make+0x6c>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
30009bbc: e1a00006 mov r0, r6 30009bc0: ebfffe31 bl 3000948c <IMFS_Set_handlers>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
30009bc4: e5963000 ldr r3, [r6]
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
30009bc8: e1a05000 mov r5, r0
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
30009bcc: e593304c ldr r3, [r3, #76] ; 0x4c 30009bd0: e3530001 cmp r3, #1
30009bd4: 1a000009 bne 30009c00 <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 ) )
30009bd8: e1a00006 mov r0, r6 30009bdc: e3a01003 mov r1, #3 30009be0: ebfffe4e bl 30009520 <IMFS_evaluate_permission> 30009be4: e3500000 cmp r0, #0
30009be8: 1affff8d bne 30009a24 <IMFS_evaluate_for_make+0x6c>
rtems_set_errno_and_return_minus_one( EACCES );
30009bec: eb001001 bl 3000dbf8 <__errno> 30009bf0: e3a0300d mov r3, #13 30009bf4: e5803000 str r3, [r0] 30009bf8: e3e05000 mvn r5, #0 30009bfc: eaffff88 b 30009a24 <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 );
30009c00: eb000ffc bl 3000dbf8 <__errno> 30009c04: e3a03014 mov r3, #20 30009c08: e5803000 str r3, [r0] 30009c0c: e3e05000 mvn r5, #0 30009c10: eaffff83 b 30009a24 <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;
30009c14: e28cc01c add ip, ip, #28 30009c18: eaffffd3 b 30009b6c <IMFS_evaluate_for_make+0x1b4>
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
30009c1c: e1a00006 mov r0, r6 30009c20: e3a01000 mov r1, #0 30009c24: ebffff2e bl 300098e4 <IMFS_evaluate_link>
if ( result == -1 )
30009c28: e3700001 cmn r0, #1
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
30009c2c: e1a05000 mov r5, r0
if ( result == -1 )
30009c30: 0affff7b beq 30009a24 <IMFS_evaluate_for_make+0x6c>
30009c34: e5965000 ldr r5, [r6] 30009c38: eaffff8e b 30009a78 <IMFS_evaluate_for_make+0xc0>
30009520 <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 ) )
30009520: e3d13007 bics r3, r1, #7
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
30009524: e92d4070 push {r4, r5, r6, lr}
30009528: 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 ) )
3000952c: 1a000010 bne 30009574 <IMFS_evaluate_permission+0x54>
rtems_set_errno_and_return_minus_one( EPERM );
jnode = node->node_access;
30009530: e5904000 ldr r4, [r0]
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
30009534: eb000318 bl 3000a19c <geteuid> 30009538: e1a06000 mov r6, r0
st_gid = getegid();
3000953c: eb000311 bl 3000a188 <getegid>
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
30009540: e1d433bc ldrh r3, [r4, #60] ; 0x3c 30009544: e1530006 cmp r3, r6
flags_to_test <<= 6;
30009548: 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 )
3000954c: 0a000002 beq 3000955c <IMFS_evaluate_permission+0x3c>
flags_to_test <<= 6;
else if ( st_gid == jnode->st_gid )
30009550: e1d433be ldrh r3, [r4, #62] ; 0x3e 30009554: e1530000 cmp r3, r0
flags_to_test <<= 3;
30009558: 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 )
3000955c: e5940030 ldr r0, [r4, #48] ; 0x30 30009560: 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 );
30009564: e1550000 cmp r5, r0 30009568: 13a00000 movne r0, #0 3000956c: 03a00001 moveq r0, #1
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
30009570: 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 );
30009574: eb00119f bl 3000dbf8 <__errno> <== NOT EXECUTED
30009578: e3a03001 mov r3, #1 <== NOT EXECUTED
3000957c: e5803000 str r3, [r0] <== NOT EXECUTED
30009580: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009584: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30009c40 <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
)
{
30009c40: 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;
30009c44: e1a0c000 mov ip, r0
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
30009c48: e24dd014 sub sp, sp, #20
/*
* 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;
30009c4c: e5bc401c ldr r4, [ip, #28]!
loc = temp_mt_entry->mt_fs_root;
30009c50: e1a0600d mov r6, sp
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
30009c54: 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;
30009c58: e8bc000f ldm ip!, {r0, r1, r2, r3}
30009c5c: e8a6000f stmia r6!, {r0, r1, r2, r3}
30009c60: e59c2000 ldr r2, [ip]
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
30009c64: 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;
30009c68: e1a0500d mov r5, sp 30009c6c: e5862000 str r2, [r6]
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
30009c70: e58e301c str r3, [lr, #28]
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
30009c74: e1a0000d mov r0, sp
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
30009c78: e5946008 ldr r6, [r4, #8]
loc.node_access = (void *)jnode;
30009c7c: e58d4000 str r4, [sp]
IMFS_Set_handlers( &loc );
30009c80: ebfffe01 bl 3000948c <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
30009c84: e594304c ldr r3, [r4, #76] ; 0x4c
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
30009c88: e2842054 add r2, r4, #84 ; 0x54 30009c8c: e3530001 cmp r3, #1
30009c90: 1a000010 bne 30009cd8 <IMFS_fsunmount+0x98>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
30009c94: e5943050 ldr r3, [r4, #80] ; 0x50 30009c98: e1530002 cmp r3, r2
30009c9c: 0a000014 beq 30009cf4 <IMFS_fsunmount+0xb4>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
}
if ( jnode != NULL ) {
30009ca0: e3540000 cmp r4, #0
30009ca4: 0a000008 beq 30009ccc <IMFS_fsunmount+0x8c>
if ( jnode->type == IMFS_DIRECTORY ) {
30009ca8: e594304c ldr r3, [r4, #76] ; 0x4c 30009cac: e3530001 cmp r3, #1
30009cb0: 1affffef bne 30009c74 <IMFS_fsunmount+0x34>
}
}
} while (jnode != NULL);
return 0;
}
30009cb4: e5943050 ldr r3, [r4, #80] ; 0x50 30009cb8: e2842054 add r2, r4, #84 ; 0x54
return -1;
jnode = next;
}
if ( jnode != NULL ) {
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
30009cbc: e1530002 cmp r3, r2
30009cc0: 0affffeb beq 30009c74 <IMFS_fsunmount+0x34>
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
30009cc4: e2534000 subs r4, r3, #0
30009cc8: 1affffe9 bne 30009c74 <IMFS_fsunmount+0x34>
return 0;
30009ccc: e1a00004 mov r0, r4
}
30009cd0: e28dd014 add sp, sp, #20
30009cd4: 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 );
30009cd8: e1a0100d mov r1, sp 30009cdc: e3a00000 mov r0, #0 30009ce0: ebffdf8c bl 30001b18 <IMFS_unlink>
if (result != 0)
30009ce4: e3500000 cmp r0, #0
30009ce8: 1a000006 bne 30009d08 <IMFS_fsunmount+0xc8>
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
30009cec: e1a04006 mov r4, r6 30009cf0: eaffffea b 30009ca0 <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 );
30009cf4: e3a00000 mov r0, #0 30009cf8: e1a0100d mov r1, sp 30009cfc: ebffdf85 bl 30001b18 <IMFS_unlink>
if (result != 0)
30009d00: e3500000 cmp r0, #0
30009d04: 0afffff8 beq 30009cec <IMFS_fsunmount+0xac>
return -1;
30009d08: e3e00000 mvn r0, #0 <== NOT EXECUTED 30009d0c: eaffffef b 30009cd0 <IMFS_fsunmount+0x90> <== NOT EXECUTED
3000c144 <IMFS_memfile_get_block_pointer>:
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
3000c144: e59f3200 ldr r3, [pc, #512] ; 3000c34c <IMFS_memfile_get_block_pointer+0x208>
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
3000c148: 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 ) {
3000c14c: e5934000 ldr r4, [r3]
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
3000c150: e24dd004 sub sp, sp, #4
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
3000c154: e1a04124 lsr r4, r4, #2 3000c158: e2443001 sub r3, r4, #1 3000c15c: e1510003 cmp r1, r3
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
3000c160: e1a05000 mov r5, r0 3000c164: e1a06002 mov r6, r2
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
3000c168: 8a000007 bhi 3000c18c <IMFS_memfile_get_block_pointer+0x48>
p = info->indirect;
if ( malloc_it ) {
3000c16c: e3520000 cmp r2, #0
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
p = info->indirect;
3000c170: e5900058 ldr r0, [r0, #88] ; 0x58
if ( malloc_it ) {
3000c174: 0a00001c beq 3000c1ec <IMFS_memfile_get_block_pointer+0xa8>
if ( !p ) {
3000c178: e3500000 cmp r0, #0
3000c17c: 0a000041 beq 3000c288 <IMFS_memfile_get_block_pointer+0x144>
}
if ( !p )
return 0;
return &info->indirect[ my_block ];
3000c180: e0800101 add r0, r0, r1, lsl #2
/*
* This means the requested block number is out of range.
*/
return 0;
}
3000c184: e28dd004 add sp, sp, #4
3000c188: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
3000c18c: e0274494 mla r7, r4, r4, r4 3000c190: e2473001 sub r3, r7, #1 3000c194: e1510003 cmp r1, r3
3000c198: 8a000016 bhi 3000c1f8 <IMFS_memfile_get_block_pointer+0xb4>
my_block -= FIRST_DOUBLY_INDIRECT;
3000c19c: e0647001 rsb r7, r4, r1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
3000c1a0: e1a00007 mov r0, r7 3000c1a4: e1a01004 mov r1, r4 3000c1a8: eb001477 bl 3001138c <__umodsi3>
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000c1ac: e1a01004 mov r1, r4
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
3000c1b0: e1a08000 mov r8, r0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000c1b4: e1a00007 mov r0, r7 3000c1b8: eb00142d bl 30011274 <__aeabi_uidiv>
p = info->doubly_indirect;
if ( malloc_it ) {
3000c1bc: 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;
3000c1c0: e1a04000 mov r4, r0
p = info->doubly_indirect;
3000c1c4: e595305c ldr r3, [r5, #92] ; 0x5c
if ( malloc_it ) {
3000c1c8: 0a00003f beq 3000c2cc <IMFS_memfile_get_block_pointer+0x188>
if ( !p ) {
3000c1cc: e3530000 cmp r3, #0
3000c1d0: 0a000045 beq 3000c2ec <IMFS_memfile_get_block_pointer+0x1a8>
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
3000c1d4: e7930104 ldr r0, [r3, r4, lsl #2] 3000c1d8: e0834104 add r4, r3, r4, lsl #2
if ( !p1 ) {
3000c1dc: e3500000 cmp r0, #0
3000c1e0: 0a00002f beq 3000c2a4 <IMFS_memfile_get_block_pointer+0x160>
p = (block_p *)p[ doubly ];
if ( !p )
return 0;
return (block_p *)&p[ singly ];
3000c1e4: e0800108 add r0, r0, r8, lsl #2 3000c1e8: eaffffe5 b 3000c184 <IMFS_memfile_get_block_pointer+0x40>
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
3000c1ec: e3500000 cmp r0, #0
3000c1f0: 1affffe2 bne 3000c180 <IMFS_memfile_get_block_pointer+0x3c>
3000c1f4: eaffffe2 b 3000c184 <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
3000c1f8: e0234497 mla r3, r7, r4, r4 3000c1fc: e2433001 sub r3, r3, #1 3000c200: e1510003 cmp r1, r3
}
/*
* This means the requested block number is out of range.
*/
return 0;
3000c204: 83a00000 movhi r0, #0
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
3000c208: 8affffdd bhi 3000c184 <IMFS_memfile_get_block_pointer+0x40>
my_block -= FIRST_TRIPLY_INDIRECT;
3000c20c: e0677001 rsb r7, r7, r1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
3000c210: e1a00007 mov r0, r7 3000c214: e1a01004 mov r1, r4 3000c218: eb00145b bl 3001138c <__umodsi3>
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000c21c: 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;
3000c220: e1a0a000 mov sl, r0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000c224: e1a00007 mov r0, r7 3000c228: eb001411 bl 30011274 <__aeabi_uidiv>
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
3000c22c: 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;
3000c230: e1a08000 mov r8, r0
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
3000c234: eb00140e bl 30011274 <__aeabi_uidiv>
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
3000c238: 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;
3000c23c: e1a07000 mov r7, r0
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
3000c240: e1a00008 mov r0, r8 3000c244: eb001450 bl 3001138c <__umodsi3>
p = info->triply_indirect;
if ( malloc_it ) {
3000c248: 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;
3000c24c: e1a04000 mov r4, r0
p = info->triply_indirect;
3000c250: e5950060 ldr r0, [r5, #96] ; 0x60
if ( malloc_it ) {
3000c254: 0a000029 beq 3000c300 <IMFS_memfile_get_block_pointer+0x1bc>
if ( !p ) {
3000c258: e3500000 cmp r0, #0
3000c25c: 0a000035 beq 3000c338 <IMFS_memfile_get_block_pointer+0x1f4>
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
3000c260: e7903107 ldr r3, [r0, r7, lsl #2] 3000c264: e0807107 add r7, r0, r7, lsl #2
if ( !p1 ) {
3000c268: e3530000 cmp r3, #0
3000c26c: 0a00002c beq 3000c324 <IMFS_memfile_get_block_pointer+0x1e0>
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
3000c270: e7930104 ldr r0, [r3, r4, lsl #2] 3000c274: e0834104 add r4, r3, r4, lsl #2
if ( !p2 ) {
3000c278: e3500000 cmp r0, #0
3000c27c: 0a00000d beq 3000c2b8 <IMFS_memfile_get_block_pointer+0x174>
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
3000c280: e080010a add r0, r0, sl, lsl #2 3000c284: eaffffbe b 3000c184 <IMFS_memfile_get_block_pointer+0x40>
p = info->indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
3000c288: e58d1000 str r1, [sp] 3000c28c: ebffff9f bl 3000c110 <memfile_alloc_block>
if ( !p )
3000c290: e3500000 cmp r0, #0 3000c294: e59d1000 ldr r1, [sp]
return 0;
info->indirect = p;
3000c298: 15850058 strne r0, [r5, #88] ; 0x58
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
3000c29c: 1affffb7 bne 3000c180 <IMFS_memfile_get_block_pointer+0x3c>
3000c2a0: eaffffb7 b 3000c184 <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
3000c2a4: ebffff99 bl 3000c110 <memfile_alloc_block>
if ( !p1 )
3000c2a8: e3500000 cmp r0, #0
return 0;
p[ doubly ] = (block_p) p1;
3000c2ac: 15840000 strne r0, [r4]
p = (block_p *)p[ doubly ];
if ( !p )
return 0;
return (block_p *)&p[ singly ];
3000c2b0: 10800108 addne r0, r0, r8, lsl #2 3000c2b4: eaffffb2 b 3000c184 <IMFS_memfile_get_block_pointer+0x40>
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
3000c2b8: ebffff94 bl 3000c110 <memfile_alloc_block>
if ( !p2 )
3000c2bc: e3500000 cmp r0, #0
return 0;
p1[ doubly ] = (block_p) p2;
3000c2c0: 15840000 strne r0, [r4]
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
3000c2c4: 1080010a addne r0, r0, sl, lsl #2 3000c2c8: eaffffad b 3000c184 <IMFS_memfile_get_block_pointer+0x40>
}
return (block_p *)&p1[ singly ];
}
if ( !p )
3000c2cc: e3530000 cmp r3, #0
3000c2d0: 1a000001 bne 3000c2dc <IMFS_memfile_get_block_pointer+0x198>
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
return 0;
3000c2d4: e1a00003 mov r0, r3 <== NOT EXECUTED 3000c2d8: eaffffa9 b 3000c184 <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
}
if ( !p )
return 0;
p = (block_p *)p[ doubly ];
3000c2dc: e7930100 ldr r0, [r3, r0, lsl #2]
if ( !p )
3000c2e0: e3500000 cmp r0, #0
return 0;
return (block_p *)&p[ singly ];
3000c2e4: 10800108 addne r0, r0, r8, lsl #2 3000c2e8: eaffffa5 b 3000c184 <IMFS_memfile_get_block_pointer+0x40>
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
3000c2ec: ebffff87 bl 3000c110 <memfile_alloc_block>
if ( !p )
3000c2f0: e2503000 subs r3, r0, #0
3000c2f4: 0afffff6 beq 3000c2d4 <IMFS_memfile_get_block_pointer+0x190>
return 0;
info->doubly_indirect = p;
3000c2f8: e585305c str r3, [r5, #92] ; 0x5c 3000c2fc: eaffffb4 b 3000c1d4 <IMFS_memfile_get_block_pointer+0x90>
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
3000c300: e3500000 cmp r0, #0
3000c304: 0affff9e beq 3000c184 <IMFS_memfile_get_block_pointer+0x40>
return 0;
p1 = (block_p *) p[ triply ];
3000c308: e7900107 ldr r0, [r0, r7, lsl #2]
if ( !p1 )
3000c30c: e3500000 cmp r0, #0
3000c310: 0affff9b beq 3000c184 <IMFS_memfile_get_block_pointer+0x40>
return 0;
p2 = (block_p *)p1[ doubly ];
3000c314: e7900104 ldr r0, [r0, r4, lsl #2]
if ( !p2 )
3000c318: e3500000 cmp r0, #0
return 0;
return (block_p *)&p2[ singly ];
3000c31c: 1080010a addne r0, r0, sl, lsl #2 3000c320: eaffff97 b 3000c184 <IMFS_memfile_get_block_pointer+0x40>
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
3000c324: ebffff79 bl 3000c110 <memfile_alloc_block>
if ( !p1 )
3000c328: e2503000 subs r3, r0, #0
3000c32c: 0affffe8 beq 3000c2d4 <IMFS_memfile_get_block_pointer+0x190>
return 0;
p[ triply ] = (block_p) p1;
3000c330: e5873000 str r3, [r7] 3000c334: eaffffcd b 3000c270 <IMFS_memfile_get_block_pointer+0x12c>
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
3000c338: ebffff74 bl 3000c110 <memfile_alloc_block>
if ( !p )
3000c33c: e3500000 cmp r0, #0
3000c340: 0affff8f beq 3000c184 <IMFS_memfile_get_block_pointer+0x40>
return 0;
info->triply_indirect = p;
3000c344: e5850060 str r0, [r5, #96] ; 0x60 3000c348: eaffffc4 b 3000c260 <IMFS_memfile_get_block_pointer+0x11c>
3000c350 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
3000c350: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000c354: 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) {
3000c358: e590004c ldr r0, [r0, #76] ; 0x4c
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
3000c35c: 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) {
3000c360: e3500006 cmp r0, #6
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
3000c364: e1a07001 mov r7, r1 3000c368: e1a08002 mov r8, r2 3000c36c: e1a0b003 mov fp, r3 3000c370: 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) {
3000c374: 0a00005c beq 3000c4ec <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 )
3000c378: 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;
3000c37c: e1a03001 mov r3, r1
if ( last_byte > the_jnode->info.file.size )
3000c380: e3a01000 mov r1, #0 3000c384: e1510002 cmp r1, r2 3000c388: 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;
3000c38c: e0851007 add r1, r5, r7
if ( last_byte > the_jnode->info.file.size )
3000c390: da00003d ble 3000c48c <IMFS_memfile_read+0x13c>
my_length = the_jnode->info.file.size - start;
3000c394: e0635002 rsb r5, r3, r2
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
3000c398: e59f61b8 ldr r6, [pc, #440] ; 3000c558 <IMFS_memfile_read+0x208>
3000c39c: e1a00007 mov r0, r7
3000c3a0: e5964000 ldr r4, [r6]
3000c3a4: e1a01008 mov r1, r8
3000c3a8: e1a02004 mov r2, r4
3000c3ac: e1a03fc2 asr r3, r2, #31
3000c3b0: e98d000c stmib sp, {r2, r3}
3000c3b4: eb001781 bl 300121c0 <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000c3b8: e99d000c ldmib sp, {r2, r3}
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
3000c3bc: e1a0a000 mov sl, r0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000c3c0: e1a01008 mov r1, r8 3000c3c4: e1a00007 mov r0, r7 3000c3c8: eb00164f bl 30011d0c <__divdi3>
if ( start_offset ) {
3000c3cc: 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;
3000c3d0: e1a07000 mov r7, r0
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
3000c3d4: 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 ) {
3000c3d8: 0a000014 beq 3000c430 <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 );
3000c3dc: e1a00009 mov r0, r9 3000c3e0: e1a01007 mov r1, r7 3000c3e4: e3a02000 mov r2, #0 3000c3e8: ebffff55 bl 3000c144 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
3000c3ec: e3500000 cmp r0, #0
3000c3f0: 0a000023 beq 3000c484 <IMFS_memfile_read+0x134>
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
3000c3f4: 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;
3000c3f8: e06a3004 rsb r3, sl, r4 3000c3fc: e1550003 cmp r5, r3 3000c400: 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 );
3000c404: e081100a add r1, r1, sl 3000c408: e1a02003 mov r2, r3 3000c40c: e1a0000b mov r0, fp 3000c410: e58d3000 str r3, [sp] 3000c414: eb000825 bl 3000e4b0 <memcpy>
dest += to_copy;
3000c418: e59d3000 ldr r3, [sp]
block++;
my_length -= to_copy;
3000c41c: 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;
3000c420: e08b8003 add r8, fp, r3
block++;
3000c424: e2877001 add r7, r7, #1
my_length -= to_copy;
3000c428: e0635005 rsb r5, r3, r5
copied += to_copy;
3000c42c: 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 ) {
3000c430: e1550004 cmp r5, r4
3000c434: 2a000008 bcs 3000c45c <IMFS_memfile_read+0x10c>
3000c438: ea000017 b 3000c49c <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 );
3000c43c: e5931000 ldr r1, [r3] 3000c440: eb00081a bl 3000e4b0 <memcpy>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
3000c444: e5963000 ldr r3, [r6]
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;
3000c448: e0888004 add r8, r8, r4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
3000c44c: 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;
block++;
3000c450: e2877001 add r7, r7, #1
my_length -= to_copy;
copied += to_copy;
3000c454: 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 ) {
3000c458: 8a00000f bhi 3000c49c <IMFS_memfile_read+0x14c>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
3000c45c: e3a02000 mov r2, #0 3000c460: e1a01007 mov r1, r7 3000c464: e1a00009 mov r0, r9 3000c468: ebffff35 bl 3000c144 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
3000c46c: e2503000 subs r3, r0, #0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
3000c470: e1a02004 mov r2, r4
dest += to_copy;
block++;
my_length -= to_copy;
3000c474: 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 );
3000c478: 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 )
3000c47c: 1affffee bne 3000c43c <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;
3000c480: e1a0000a mov r0, sl <== NOT EXECUTED
}
IMFS_update_atime( the_jnode );
return copied;
}
3000c484: e28dd014 add sp, sp, #20
3000c488: 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 ) 3000c48c: 1affffc1 bne 3000c398 <IMFS_memfile_read+0x48>
3000c490: e1510002 cmp r1, r2
3000c494: 9affffbf bls 3000c398 <IMFS_memfile_read+0x48>
3000c498: eaffffbd b 3000c394 <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 ) {
3000c49c: e3550000 cmp r5, #0
3000c4a0: 0a00000a beq 3000c4d0 <IMFS_memfile_read+0x180>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
3000c4a4: e1a00009 mov r0, r9 3000c4a8: e1a01007 mov r1, r7 3000c4ac: e3a02000 mov r2, #0 3000c4b0: ebffff23 bl 3000c144 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
3000c4b4: e2503000 subs r3, r0, #0
3000c4b8: 0afffff0 beq 3000c480 <IMFS_memfile_read+0x130>
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
3000c4bc: e1a00008 mov r0, r8 3000c4c0: e5931000 ldr r1, [r3] 3000c4c4: e1a02005 mov r2, r5 3000c4c8: eb0007f8 bl 3000e4b0 <memcpy>
copied += my_length;
3000c4cc: e08aa005 add sl, sl, r5
}
IMFS_update_atime( the_jnode );
3000c4d0: e28d000c add r0, sp, #12 3000c4d4: e3a01000 mov r1, #0 3000c4d8: ebffd6f3 bl 300020ac <gettimeofday> 3000c4dc: e59d300c ldr r3, [sp, #12]
return copied;
3000c4e0: e1a0000a mov r0, sl
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
3000c4e4: e5893040 str r3, [r9, #64] ; 0x40
return copied;
3000c4e8: eaffffe5 b 3000c484 <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))
3000c4ec: e2894050 add r4, r9, #80 ; 0x50
3000c4f0: e8940018 ldm r4, {r3, r4}
3000c4f4: e1a00003 mov r0, r3
3000c4f8: e1a01004 mov r1, r4
3000c4fc: e3a02000 mov r2, #0
3000c500: e0500007 subs r0, r0, r7
3000c504: e0c11008 sbc r1, r1, r8
3000c508: 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;
3000c50c: e5992058 ldr r2, [r9, #88] ; 0x58
if (my_length > (the_jnode->info.linearfile.size - start))
3000c510: da00000b ble 3000c544 <IMFS_memfile_read+0x1f4>
my_length = the_jnode->info.linearfile.size - start;
3000c514: e067a003 rsb sl, r7, r3
memcpy(dest, &file_ptr[start], my_length);
3000c518: e0821007 add r1, r2, r7 3000c51c: e1a0000b mov r0, fp 3000c520: e1a0200a mov r2, sl 3000c524: eb0007e1 bl 3000e4b0 <memcpy>
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
3000c528: e28d000c add r0, sp, #12 3000c52c: e3a01000 mov r1, #0 3000c530: ebffd6dd bl 300020ac <gettimeofday> 3000c534: e59d300c ldr r3, [sp, #12]
return copied;
3000c538: e1a0000a mov r0, sl
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
3000c53c: e5893040 str r3, [r9, #64] ; 0x40 3000c540: eaffffcf b 3000c484 <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))
3000c544: 1a000001 bne 3000c550 <IMFS_memfile_read+0x200>
3000c548: e1550000 cmp r5, r0
3000c54c: 8afffff0 bhi 3000c514 <IMFS_memfile_read+0x1c4>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
3000c550: e1a0a005 mov sl, r5 <== NOT EXECUTED 3000c554: eaffffef b 3000c518 <IMFS_memfile_read+0x1c8> <== NOT EXECUTED
3000197c <IMFS_mount>:
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
3000197c: e5903008 ldr r3, [r0, #8]
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
30001980: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
30001984: e593204c ldr r2, [r3, #76] ; 0x4c 30001988: e3520001 cmp r2, #1
3000198c: 1a000002 bne 3000199c <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;
30001990: e583005c str r0, [r3, #92] ; 0x5c
return 0;
30001994: e3a00000 mov r0, #0
}
30001998: 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 );
3000199c: eb003095 bl 3000dbf8 <__errno> <== NOT EXECUTED
300019a0: e3a03014 mov r3, #20 <== NOT EXECUTED
300019a4: e5803000 str r3, [r0] <== NOT EXECUTED
300019a8: e3e00000 mvn r0, #0 <== NOT EXECUTED
300019ac: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000431c <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
3000431c: e92d4030 push {r4, r5, lr}
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
30004320: e59f50f8 ldr r5, [pc, #248] ; 30004420 <IMFS_print_jnode+0x104>
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
30004324: e1a04000 mov r4, r0
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
30004328: e5953000 ldr r3, [r5] 3000432c: e280000c add r0, r0, #12 30004330: e5931008 ldr r1, [r3, #8] 30004334: eb003869 bl 300124e0 <fputs>
switch( the_jnode->type ) {
30004338: e594204c ldr r2, [r4, #76] ; 0x4c 3000433c: e2423001 sub r3, r2, #1 30004340: e3530006 cmp r3, #6 30004344: 979ff103 ldrls pc, [pc, r3, lsl #2]
30004348: ea000023 b 300043dc <IMFS_print_jnode+0xc0> <== NOT EXECUTED 3000434c: 300043f0 .word 0x300043f0 <== NOT EXECUTED 30004350: 30004404 .word 0x30004404 <== NOT EXECUTED 30004354: 30004368 .word 0x30004368 <== NOT EXECUTED 30004358: 30004368 .word 0x30004368 <== NOT EXECUTED 3000435c: 300043a0 .word 0x300043a0 <== NOT EXECUTED 30004360: 300043c0 .word 0x300043c0 <== NOT EXECUTED 30004364: 30004384 .word 0x30004384 <== NOT EXECUTED
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
30004368: e5953000 ldr r3, [r5] 3000436c: e59f00b0 ldr r0, [pc, #176] ; 30004424 <IMFS_print_jnode+0x108> 30004370: e5933008 ldr r3, [r3, #8] 30004374: e3a01001 mov r1, #1 30004378: e3a02013 mov r2, #19
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
}
3000437c: 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" );
30004380: ea003b87 b 300131a4 <fwrite>
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
30004384: e5953000 ldr r3, [r5] 30004388: e59f0098 ldr r0, [pc, #152] ; 30004428 <IMFS_print_jnode+0x10c> 3000438c: e5933008 ldr r3, [r3, #8] 30004390: e3a01001 mov r1, #1 30004394: e3a02012 mov r2, #18
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
}
30004398: 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" );
3000439c: ea003b80 b 300131a4 <fwrite>
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
300043a0: e5953000 ldr r3, [r5] 300043a4: e59f1080 ldr r1, [pc, #128] ; 3000442c <IMFS_print_jnode+0x110> 300043a8: e5930008 ldr r0, [r3, #8] 300043ac: e5942050 ldr r2, [r4, #80] ; 0x50 300043b0: eb0037f5 bl 3001238c <fprintf>
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
300043b4: e59f0074 ldr r0, [pc, #116] ; 30004430 <IMFS_print_jnode+0x114>
}
300043b8: e8bd4030 pop {r4, r5, lr}
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
300043bc: ea003f59 b 30014128 <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)",
300043c0: e5953000 ldr r3, [r5] 300043c4: e59f1068 ldr r1, [pc, #104] ; 30004434 <IMFS_print_jnode+0x118> 300043c8: e5930008 ldr r0, [r3, #8] 300043cc: e5942050 ldr r2, [r4, #80] ; 0x50 300043d0: e5943058 ldr r3, [r4, #88] ; 0x58 300043d4: eb0037ec bl 3001238c <fprintf>
(uint32_t)the_jnode->info.linearfile.size,
the_jnode->info.linearfile.direct
);
break;
300043d8: eafffff5 b 300043b4 <IMFS_print_jnode+0x98>
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
300043dc: e5953000 ldr r3, [r5] <== NOT EXECUTED 300043e0: e59f1050 ldr r1, [pc, #80] ; 30004438 <IMFS_print_jnode+0x11c><== NOT EXECUTED 300043e4: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
return;
}
puts("");
}
300043e8: 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 );
300043ec: ea0037e6 b 3001238c <fprintf> <== NOT EXECUTED
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( the_jnode->type ) {
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
300043f0: e5953000 ldr r3, [r5] 300043f4: e3a0002f mov r0, #47 ; 0x2f 300043f8: e5931008 ldr r1, [r3, #8] 300043fc: eb003802 bl 3001240c <fputc>
break;
30004400: eaffffeb b 300043b4 <IMFS_print_jnode+0x98>
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
30004404: e5953000 ldr r3, [r5] 30004408: e59f102c ldr r1, [pc, #44] ; 3000443c <IMFS_print_jnode+0x120> 3000440c: e5930008 ldr r0, [r3, #8] 30004410: e5942050 ldr r2, [r4, #80] ; 0x50 30004414: e5943054 ldr r3, [r4, #84] ; 0x54 30004418: eb0037db bl 3001238c <fprintf>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
3000441c: eaffffe4 b 300043b4 <IMFS_print_jnode+0x98>
30009f48 <IMFS_stat>:
{
IMFS_fs_info_t *fs_info;
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
30009f48: e5903000 ldr r3, [r0]
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
30009f4c: e92d40f0 push {r4, r5, r6, r7, lr}
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
30009f50: e593204c ldr r2, [r3, #76] ; 0x4c 30009f54: e2422002 sub r2, r2, #2 30009f58: e3520005 cmp r2, #5 30009f5c: 979ff102 ldrls pc, [pc, r2, lsl #2]
30009f60: ea000026 b 3000a000 <IMFS_stat+0xb8> <== NOT EXECUTED 30009f64: 30009fec .word 0x30009fec <== NOT EXECUTED 30009f68: 3000a000 .word 0x3000a000 <== NOT EXECUTED 30009f6c: 30009f7c .word 0x30009f7c <== NOT EXECUTED 30009f70: 3000a014 .word 0x3000a014 <== NOT EXECUTED 30009f74: 3000a014 .word 0x3000a014 <== NOT EXECUTED 30009f78: 30009f7c .word 0x30009f7c <== NOT EXECUTED
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
30009f7c: e3a04000 mov r4, #0 30009f80: e3a05000 mov r5, #0 30009f84: e5814020 str r4, [r1, #32] 30009f88: 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;
30009f8c: e5902010 ldr r2, [r0, #16]
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;
30009f90: e1d373b4 ldrh r7, [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 =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
30009f94: e5922034 ldr r2, [r2, #52] ; 0x34
buf->st_ino = the_jnode->st_ino;
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;
30009f98: e5930044 ldr r0, [r3, #68] ; 0x44
*/
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;
30009f9c: e5935030 ldr r5, [r3, #48] ; 0x30
buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino;
30009fa0: e5934038 ldr r4, [r3, #56] ; 0x38
* 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 =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
30009fa4: e5926000 ldr r6, [r2]
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;
buf->st_atime = the_jnode->stat_atime;
30009fa8: e593c040 ldr ip, [r3, #64] ; 0x40
buf->st_mtime = the_jnode->stat_mtime; buf->st_ctime = the_jnode->stat_ctime;
30009fac: e5932048 ldr r2, [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;
buf->st_nlink = the_jnode->st_nlink;
30009fb0: e1c171b0 strh r7, [r1, #16]
/* * 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 =
30009fb4: e59f706c ldr r7, [pc, #108] ; 3000a028 <IMFS_stat+0xe0> 30009fb8: e5817000 str r7, [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;
30009fbc: e1d373bc ldrh r7, [r3, #60] ; 0x3c
buf->st_gid = the_jnode->st_gid;
30009fc0: e1d333be ldrh r3, [r3, #62] ; 0x3e
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;
30009fc4: e1c171b2 strh r7, [r1, #18]
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
30009fc8: e5810030 str r0, [r1, #48] ; 0x30
/* * 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 =
30009fcc: e5816004 str r6, [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;
30009fd0: 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;
30009fd4: e581500c str r5, [r1, #12]
buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino;
30009fd8: e5814008 str r4, [r1, #8]
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
30009fdc: e581c028 str ip, [r1, #40] ; 0x28
buf->st_mtime = the_jnode->stat_mtime; buf->st_ctime = the_jnode->stat_ctime;
30009fe0: e5812038 str r2, [r1, #56] ; 0x38
return 0;
30009fe4: e3a00000 mov r0, #0
}
30009fe8: e8bd80f0 pop {r4, r5, r6, r7, 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 );
30009fec: e593c054 ldr ip, [r3, #84] ; 0x54
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
30009ff0: e5932050 ldr r2, [r3, #80] ; 0x50 30009ff4: e581c01c str ip, [r1, #28] 30009ff8: e5812018 str r2, [r1, #24]
break;
30009ffc: eaffffe2 b 30009f8c <IMFS_stat+0x44>
case IMFS_FIFO:
buf->st_size = 0;
break;
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
3000a000: eb000efc bl 3000dbf8 <__errno>
3000a004: e3a03086 mov r3, #134 ; 0x86
3000a008: e5803000 str r3, [r0]
3000a00c: e3e00000 mvn r0, #0
3000a010: e8bd80f0 pop {r4, r5, r6, r7, 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;
3000a014: e2835050 add r5, r3, #80 ; 0x50
3000a018: e8950030 ldm r5, {r4, r5}
3000a01c: e5814020 str r4, [r1, #32]
3000a020: e5815024 str r5, [r1, #36] ; 0x24
break;
3000a024: eaffffd8 b 30009f8c <IMFS_stat+0x44>
30001b18 <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30001b18: 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;
30001b1c: e5915000 ldr r5, [r1]
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30001b20: e24dd01c sub sp, sp, #28
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
30001b24: e595304c ldr r3, [r5, #76] ; 0x4c
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30001b28: e1a04001 mov r4, r1
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
30001b2c: e3530003 cmp r3, #3
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30001b30: e1a06000 mov r6, r0
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
30001b34: 0a000006 beq 30001b54 <IMFS_unlink+0x3c>
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
30001b38: e5943008 ldr r3, [r4, #8] 30001b3c: e1a00006 mov r0, r6 30001b40: e1a01004 mov r1, r4 30001b44: e1a0e00f mov lr, pc 30001b48: e593f034 ldr pc, [r3, #52] ; 0x34
return result;
}
30001b4c: e28dd01c add sp, sp, #28
30001b50: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
30001b54: e595e050 ldr lr, [r5, #80] ; 0x50 30001b58: e35e0000 cmp lr, #0
30001b5c: 0a00001f beq 30001be0 <IMFS_unlink+0xc8>
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
30001b60: e1a0c00d mov ip, sp
30001b64: e1a07001 mov r7, r1
30001b68: e8b7000f ldm r7!, {r0, r1, r2, r3}
30001b6c: e8ac000f stmia ip!, {r0, r1, r2, r3}
30001b70: e5973000 ldr r3, [r7]
the_link.node_access = node->info.hard_link.link_node;
30001b74: e28d801c add r8, sp, #28
IMFS_Set_handlers( &the_link );
30001b78: 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;
30001b7c: e58c3000 str r3, [ip]
the_link.node_access = node->info.hard_link.link_node;
30001b80: e528e01c str lr, [r8, #-28]!
IMFS_Set_handlers( &the_link );
30001b84: eb001e40 bl 3000948c <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)
30001b88: e5953050 ldr r3, [r5, #80] ; 0x50 30001b8c: e1d323b4 ldrh r2, [r3, #52] ; 0x34 30001b90: e3520001 cmp r2, #1
30001b94: 0a000008 beq 30001bbc <IMFS_unlink+0xa4>
if ( result != 0 )
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
30001b98: e2422001 sub r2, r2, #1 30001b9c: e1c323b4 strh r2, [r3, #52] ; 0x34
IMFS_update_ctime( node->info.hard_link.link_node );
30001ba0: e28d0014 add r0, sp, #20 30001ba4: e3a01000 mov r1, #0 30001ba8: eb00013f bl 300020ac <gettimeofday> 30001bac: e5953050 ldr r3, [r5, #80] ; 0x50 30001bb0: e59d2014 ldr r2, [sp, #20] 30001bb4: e5832048 str r2, [r3, #72] ; 0x48 30001bb8: eaffffde b 30001b38 <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 );
30001bbc: e1a00006 mov r0, r6 30001bc0: e1a0100d mov r1, sp 30001bc4: e59d3008 ldr r3, [sp, #8] 30001bc8: e1a0e00f mov lr, pc 30001bcc: e593f034 ldr pc, [r3, #52] ; 0x34
if ( result != 0 )
30001bd0: e3500000 cmp r0, #0
30001bd4: 0affffd7 beq 30001b38 <IMFS_unlink+0x20>
return -1;
30001bd8: e3e00000 mvn r0, #0 30001bdc: eaffffda b 30001b4c <IMFS_unlink+0x34>
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
30001be0: eb003004 bl 3000dbf8 <__errno> <== NOT EXECUTED 30001be4: e3a03016 mov r3, #22 <== NOT EXECUTED 30001be8: e5803000 str r3, [r0] <== NOT EXECUTED 30001bec: e3e00000 mvn r0, #0 <== NOT EXECUTED 30001bf0: eaffffd5 b 30001b4c <IMFS_unlink+0x34> <== NOT EXECUTED
30001bf4 <IMFS_unmount>:
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
30001bf4: e5903008 ldr r3, [r0, #8]
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
30001bf8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
30001bfc: e593204c ldr r2, [r3, #76] ; 0x4c 30001c00: e3520001 cmp r2, #1
30001c04: 1a000005 bne 30001c20 <IMFS_unmount+0x2c>
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
30001c08: e593205c ldr r2, [r3, #92] ; 0x5c 30001c0c: e3520000 cmp r2, #0
30001c10: 0a000007 beq 30001c34 <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;
30001c14: e3a00000 mov r0, #0 30001c18: e583005c str r0, [r3, #92] ; 0x5c
return 0;
}
30001c1c: 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 );
30001c20: eb002ff4 bl 3000dbf8 <__errno>
30001c24: e3a03014 mov r3, #20 <== NOT EXECUTED
30001c28: e5803000 str r3, [r0] <== NOT EXECUTED
30001c2c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30001c30: 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 */
30001c34: eb002fef bl 3000dbf8 <__errno> <== NOT EXECUTED
30001c38: e3a03016 mov r3, #22 <== NOT EXECUTED
30001c3c: e5803000 str r3, [r0] <== NOT EXECUTED
30001c40: e3e00000 mvn r0, #0 <== NOT EXECUTED
30001c44: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30001f8c <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
30001f8c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
30001f90: e59030bc ldr r3, [r0, #188] ; 0xbc <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
30001f94: e59060b8 ldr r6, [r0, #184] ; 0xb8 <== NOT EXECUTED
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
30001f98: e283c010 add ip, r3, #16 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
30001f9c: e2466010 sub r6, r6, #16 <== NOT EXECUTED
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
30001fa0: e28cb010 add fp, ip, #16 <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
30001fa4: e3c61003 bic r1, r6, #3 <== NOT EXECUTED 30001fa8: e08b1001 add r1, fp, r1 <== NOT EXECUTED 30001fac: e15b0001 cmp fp, r1 <== NOT EXECUTED
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
30001fb0: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 30001fb4: e1a05000 mov r5, r0 <== NOT EXECUTED
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
30001fb8: e59090e8 ldr r9, [r0, #232] ; 0xe8 <== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
30001fbc: 2a00000b bcs 30001ff0 <Stack_check_Dump_threads_usage+0x64><== NOT EXECUTED
if (*base != U32_PATTERN)
30001fc0: e59c0010 ldr r0, [ip, #16] <== NOT EXECUTED 30001fc4: e59f20d0 ldr r2, [pc, #208] ; 3000209c <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED 30001fc8: e1500002 cmp r0, r2 <== NOT EXECUTED
* 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(
30001fcc: 02833024 addeq r3, r3, #36 ; 0x24 <== NOT EXECUTED
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
if (*base != U32_PATTERN)
30001fd0: 0a000003 beq 30001fe4 <Stack_check_Dump_threads_usage+0x58><== NOT EXECUTED 30001fd4: ea000027 b 30002078 <Stack_check_Dump_threads_usage+0xec> <== NOT EXECUTED 30001fd8: e4932004 ldr r2, [r3], #4 <== NOT EXECUTED 30001fdc: e1520000 cmp r2, r0 <== NOT EXECUTED 30001fe0: 1a000024 bne 30002078 <Stack_check_Dump_threads_usage+0xec><== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
30001fe4: e1510003 cmp r1, r3 <== NOT EXECUTED
if (*base != U32_PATTERN)
30001fe8: e1a0b003 mov fp, r3 <== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
30001fec: 8afffff9 bhi 30001fd8 <Stack_check_Dump_threads_usage+0x4c><== NOT EXECUTED
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
used = Stack_check_Calculate_used( low, size, high_water_mark );
else
used = 0;
30001ff0: e3a0b000 mov fp, #0 <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
#endif
{
(*print_handler)(
30001ff4: e5958008 ldr r8, [r5, #8] <== NOT EXECUTED
30001ff8: e59f40a0 ldr r4, [pc, #160] ; 300020a0 <Stack_check_Dump_threads_usage+0x114><== NOT EXECUTED
30001ffc: e3a01005 mov r1, #5 <== NOT EXECUTED
30002000: e28d2008 add r2, sp, #8 <== NOT EXECUTED
30002004: e1a00008 mov r0, r8 <== NOT EXECUTED
30002008: e8940480 ldm r4, {r7, sl} <== NOT EXECUTED
3000200c: eb00182b bl 300080c0 <rtems_object_get_name> <== NOT EXECUTED
30002010: e1a02008 mov r2, r8 <== NOT EXECUTED
30002014: e1a03000 mov r3, r0 <== NOT EXECUTED
30002018: e59f1084 ldr r1, [pc, #132] ; 300020a4 <Stack_check_Dump_threads_usage+0x118><== NOT EXECUTED
3000201c: e1a0000a mov r0, sl <== NOT EXECUTED
30002020: e1a0e00f mov lr, pc <== NOT EXECUTED
30002024: e12fff17 bx r7 <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
30002028: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 3000202c: e59520bc ldr r2, [r5, #188] ; 0xbc <== NOT EXECUTED 30002030: e2433001 sub r3, r3, #1 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
30002034: e0823003 add r3, r2, r3 <== NOT EXECUTED 30002038: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 3000203c: e58d9000 str r9, [sp] <== NOT EXECUTED 30002040: e58d6004 str r6, [sp, #4] <== NOT EXECUTED 30002044: e59f105c ldr r1, [pc, #92] ; 300020a8 <Stack_check_Dump_threads_usage+0x11c><== NOT EXECUTED 30002048: e1a0e00f mov lr, pc <== NOT EXECUTED 3000204c: e594f000 ldr pc, [r4] <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
30002050: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30002054: e3530000 cmp r3, #0 <== NOT EXECUTED 30002058: 0a00000a beq 30002088 <Stack_check_Dump_threads_usage+0xfc><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
3000205c: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 30002060: e59f1044 ldr r1, [pc, #68] ; 300020ac <Stack_check_Dump_threads_usage+0x120><== NOT EXECUTED 30002064: e1a0200b mov r2, fp <== NOT EXECUTED 30002068: e1a0e00f mov lr, pc <== NOT EXECUTED 3000206c: e594f000 ldr pc, [r4] <== NOT EXECUTED
}
}
30002070: e28dd010 add sp, sp, #16 <== NOT EXECUTED
30002074: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
30002078: e35b0000 cmp fp, #0 <== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
3000207c: 108cc006 addne ip, ip, r6 <== NOT EXECUTED 30002080: 106bb00c rsbne fp, fp, ip <== NOT EXECUTED 30002084: eaffffda b 30001ff4 <Stack_check_Dump_threads_usage+0x68> <== NOT EXECUTED
current,
size
);
if (Stack_check_Initialized == 0) {
(*print_handler)( print_context, "Unavailable\n" );
30002088: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 3000208c: e59f101c ldr r1, [pc, #28] ; 300020b0 <Stack_check_Dump_threads_usage+0x124><== NOT EXECUTED 30002090: e1a0e00f mov lr, pc <== NOT EXECUTED 30002094: e594f000 ldr pc, [r4] <== NOT EXECUTED 30002098: eafffff4 b 30002070 <Stack_check_Dump_threads_usage+0xe4> <== NOT EXECUTED
30002160 <Stack_check_report_blown_task>:
Thread_Control *running,
bool pattern_ok
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
30002160: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30002164: e1a06000 mov r6, r0 <== NOT EXECUTED
30002168: e24dd020 sub sp, sp, #32 <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
char name[32];
printk("BLOWN STACK!!!\n");
3000216c: e59f0084 ldr r0, [pc, #132] ; 300021f8 <Stack_check_report_blown_task+0x98><== NOT EXECUTED
Thread_Control *running,
bool pattern_ok
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
30002170: e20140ff and r4, r1, #255 ; 0xff <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern(stack);
30002174: e59650bc ldr r5, [r6, #188] ; 0xbc <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
30002178: eb000783 bl 30003f8c <printk> <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
3000217c: e59f0078 ldr r0, [pc, #120] ; 300021fc <Stack_check_report_blown_task+0x9c><== NOT EXECUTED 30002180: e1a01006 mov r1, r6 <== NOT EXECUTED 30002184: eb000780 bl 30003f8c <printk> <== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
30002188: e59f0070 ldr r0, [pc, #112] ; 30002200 <Stack_check_report_blown_task+0xa0><== NOT EXECUTED 3000218c: e5961008 ldr r1, [r6, #8] <== NOT EXECUTED 30002190: eb00077d bl 30003f8c <printk> <== NOT EXECUTED
printk(
30002194: e59f0068 ldr r0, [pc, #104] ; 30002204 <Stack_check_report_blown_task+0xa4><== NOT EXECUTED 30002198: e596100c ldr r1, [r6, #12] <== NOT EXECUTED 3000219c: eb00077a bl 30003f8c <printk> <== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
300021a0: e1a0200d mov r2, sp <== NOT EXECUTED 300021a4: e3a01020 mov r1, #32 <== NOT EXECUTED 300021a8: e5960008 ldr r0, [r6, #8] <== NOT EXECUTED 300021ac: eb0017c3 bl 300080c0 <rtems_object_get_name> <== NOT EXECUTED 300021b0: e1a01000 mov r1, r0 <== NOT EXECUTED 300021b4: e59f004c ldr r0, [pc, #76] ; 30002208 <Stack_check_report_blown_task+0xa8><== NOT EXECUTED 300021b8: eb000773 bl 30003f8c <printk> <== NOT EXECUTED
);
printk(
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
300021bc: e59620bc ldr r2, [r6, #188] ; 0xbc <== NOT EXECUTED 300021c0: e59610b8 ldr r1, [r6, #184] ; 0xb8 <== NOT EXECUTED
);
printk(
"task name string: %s\n",
rtems_object_get_name(running->Object.id, sizeof(name), name)
);
printk(
300021c4: e59f0040 ldr r0, [pc, #64] ; 3000220c <Stack_check_report_blown_task+0xac><== NOT EXECUTED 300021c8: e0823001 add r3, r2, r1 <== NOT EXECUTED 300021cc: eb00076e bl 30003f8c <printk> <== NOT EXECUTED
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
300021d0: e3540000 cmp r4, #0 <== NOT EXECUTED 300021d4: 0a000001 beq 300021e0 <Stack_check_report_blown_task+0x80> <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
300021d8: e3a00081 mov r0, #129 ; 0x81 <== NOT EXECUTED 300021dc: eb0019c0 bl 300088e4 <rtems_fatal_error_occurred> <== NOT EXECUTED
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
printk(
300021e0: e59f0028 ldr r0, [pc, #40] ; 30002210 <Stack_check_report_blown_task+0xb0><== NOT EXECUTED 300021e4: e3a01010 mov r1, #16 <== NOT EXECUTED 300021e8: e2852008 add r2, r5, #8 <== NOT EXECUTED 300021ec: e2853018 add r3, r5, #24 <== NOT EXECUTED 300021f0: eb000765 bl 30003f8c <printk> <== NOT EXECUTED 300021f4: eafffff7 b 300021d8 <Stack_check_report_blown_task+0x78> <== NOT EXECUTED
30016ce0 <_CORE_message_queue_Broadcast>:
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
30016ce0: e590304c ldr r3, [r0, #76] ; 0x4c
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
30016ce4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
30016ce8: e1530002 cmp r3, r2
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
30016cec: e1a07000 mov r7, r0 30016cf0: e1a05002 mov r5, r2 30016cf4: e1a08001 mov r8, r1 30016cf8: e59da020 ldr sl, [sp, #32]
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
30016cfc: 3a000016 bcc 30016d5c <_CORE_message_queue_Broadcast+0x7c>
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
30016d00: e5906048 ldr r6, [r0, #72] ; 0x48 30016d04: e3560000 cmp r6, #0
*count = 0;
30016d08: 13a00000 movne r0, #0 30016d0c: 158a0000 strne r0, [sl]
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
30016d10: 18bd85f0 popne {r4, r5, r6, r7, r8, sl, pc}
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
30016d14: e1a00007 mov r0, r7 30016d18: eb000b0b bl 3001994c <_Thread_queue_Dequeue> 30016d1c: e2504000 subs r4, r0, #0
30016d20: 0a00000a beq 30016d50 <_CORE_message_queue_Broadcast+0x70>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30016d24: e594002c ldr r0, [r4, #44] ; 0x2c 30016d28: e1a01008 mov r1, r8 30016d2c: e1a02005 mov r2, r5 30016d30: eb00245f bl 3001feb4 <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30016d34: e5943028 ldr r3, [r4, #40] ; 0x28
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
30016d38: e1a00007 mov r0, r7
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30016d3c: e5835000 str r5, [r3]
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
30016d40: eb000b01 bl 3001994c <_Thread_queue_Dequeue> 30016d44: e2504000 subs r4, r0, #0
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
30016d48: e2866001 add r6, r6, #1
/*
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
number_broadcasted = 0;
while ((the_thread =
30016d4c: 1afffff4 bne 30016d24 <_CORE_message_queue_Broadcast+0x44>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
30016d50: e58a6000 str r6, [sl]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
30016d54: e1a00004 mov r0, r4
30016d58: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
30016d5c: e3a00001 mov r0, #1 <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
30016d60: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
3000b854 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000b854: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000b858: 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;
3000b85c: e5902010 ldr r2, [r0, #16]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000b860: e24dd01c sub sp, sp, #28 3000b864: 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 ) {
3000b868: e2911004 adds r1, r1, #4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000b86c: 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 ) {
3000b870: e58d1000 str r1, [sp]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000b874: 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;
3000b878: 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 ) {
3000b87c: 2a000078 bcs 3000ba64 <_Heap_Allocate_aligned_with_boundary+0x210>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
3000b880: e3530000 cmp r3, #0
3000b884: 1a000074 bne 3000ba5c <_Heap_Allocate_aligned_with_boundary+0x208>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
3000b888: 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 ) {
3000b88c: e1570009 cmp r7, r9
3000b890: 0a000073 beq 3000ba64 <_Heap_Allocate_aligned_with_boundary+0x210>
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
3000b894: e59d300c ldr r3, [sp, #12]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
3000b898: 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
3000b89c: e2833007 add r3, r3, #7
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000b8a0: e3a06001 mov r6, #1
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
3000b8a4: e58d3010 str r3, [sp, #16]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
3000b8a8: e58d1014 str r1, [sp, #20]
/*
* 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 ) {
3000b8ac: e599a004 ldr sl, [r9, #4] 3000b8b0: e59d2000 ldr r2, [sp] 3000b8b4: e152000a cmp r2, sl
3000b8b8: 2a00004e bcs 3000b9f8 <_Heap_Allocate_aligned_with_boundary+0x1a4>
if ( alignment == 0 ) {
3000b8bc: 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;
3000b8c0: 02894008 addeq r4, r9, #8
3000b8c4: 0a000051 beq 3000ba10 <_Heap_Allocate_aligned_with_boundary+0x1bc>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
3000b8c8: 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;
3000b8cc: 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;
3000b8d0: 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;
3000b8d4: 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;
3000b8d8: 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;
3000b8dc: e081400a add r4, r1, sl
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
3000b8e0: 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;
3000b8e4: e0633002 rsb r3, r3, r2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000b8e8: 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
3000b8ec: e083a00a add sl, r3, sl 3000b8f0: 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;
3000b8f4: e2893008 add r3, r9, #8 3000b8f8: e58d3008 str r3, [sp, #8]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000b8fc: eb0016a2 bl 3001138c <__umodsi3> 3000b900: 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 ) {
3000b904: e15a0004 cmp sl, r4
3000b908: 2a000003 bcs 3000b91c <_Heap_Allocate_aligned_with_boundary+0xc8>
3000b90c: e1a0000a mov r0, sl 3000b910: e1a01008 mov r1, r8 3000b914: eb00169c bl 3001138c <__umodsi3> 3000b918: e060400a rsb r4, r0, sl
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
3000b91c: e35b0000 cmp fp, #0
3000b920: 0a000026 beq 3000b9c0 <_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;
3000b924: e084a005 add sl, r4, r5 3000b928: e1a0000a mov r0, sl 3000b92c: e1a0100b mov r1, fp 3000b930: eb001695 bl 3001138c <__umodsi3> 3000b934: 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 ) {
3000b938: e15a0000 cmp sl, r0 3000b93c: 93a0a000 movls sl, #0 3000b940: 83a0a001 movhi sl, #1 3000b944: e1540000 cmp r4, r0 3000b948: 23a0a000 movcs sl, #0 3000b94c: e35a0000 cmp sl, #0
3000b950: 0a00001a beq 3000b9c0 <_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;
3000b954: e59d1008 ldr r1, [sp, #8] 3000b958: 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 ) {
3000b95c: e1530000 cmp r3, r0 3000b960: 958d9018 strls r9, [sp, #24] 3000b964: 91a09003 movls r9, r3
3000b968: 9a000002 bls 3000b978 <_Heap_Allocate_aligned_with_boundary+0x124>
3000b96c: ea000021 b 3000b9f8 <_Heap_Allocate_aligned_with_boundary+0x1a4> 3000b970: e1590000 cmp r9, r0
3000b974: 8a00003c bhi 3000ba6c <_Heap_Allocate_aligned_with_boundary+0x218>
return 0;
}
alloc_begin = boundary_line - alloc_size;
3000b978: e0654000 rsb r4, r5, r0 3000b97c: e1a01008 mov r1, r8 3000b980: e1a00004 mov r0, r4 3000b984: eb001680 bl 3001138c <__umodsi3> 3000b988: e0604004 rsb r4, r0, r4
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
3000b98c: e084a005 add sl, r4, r5 3000b990: e1a0000a mov r0, sl 3000b994: e1a0100b mov r1, fp 3000b998: eb00167b bl 3001138c <__umodsi3> 3000b99c: 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 ) {
3000b9a0: e15a0000 cmp sl, r0 3000b9a4: 93a0a000 movls sl, #0 3000b9a8: 83a0a001 movhi sl, #1 3000b9ac: e1540000 cmp r4, r0 3000b9b0: 23a0a000 movcs sl, #0 3000b9b4: e35a0000 cmp sl, #0
3000b9b8: 1affffec bne 3000b970 <_Heap_Allocate_aligned_with_boundary+0x11c>
3000b9bc: 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 ) {
3000b9c0: e59d2008 ldr r2, [sp, #8] 3000b9c4: e1520004 cmp r2, r4
3000b9c8: 8a00000a bhi 3000b9f8 <_Heap_Allocate_aligned_with_boundary+0x1a4>
3000b9cc: e59d100c ldr r1, [sp, #12] 3000b9d0: e1a00004 mov r0, r4 3000b9d4: eb00166c bl 3001138c <__umodsi3> 3000b9d8: e3e0a007 mvn sl, #7 3000b9dc: e069a00a rsb sl, r9, sl
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3000b9e0: 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 ) {
3000b9e4: e59d1004 ldr r1, [sp, #4] 3000b9e8: e060300a rsb r3, r0, sl 3000b9ec: e15a0000 cmp sl, r0 3000b9f0: 11510003 cmpne r1, r3
3000b9f4: 9a000005 bls 3000ba10 <_Heap_Allocate_aligned_with_boundary+0x1bc>
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
3000b9f8: e5999008 ldr r9, [r9, #8] 3000b9fc: 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 ) {
3000ba00: e1570009 cmp r7, r9
3000ba04: 0a00001d beq 3000ba80 <_Heap_Allocate_aligned_with_boundary+0x22c>
3000ba08: e1a06003 mov r6, r3 3000ba0c: eaffffa6 b 3000b8ac <_Heap_Allocate_aligned_with_boundary+0x58>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
3000ba10: e3540000 cmp r4, #0
3000ba14: 0afffff7 beq 3000b9f8 <_Heap_Allocate_aligned_with_boundary+0x1a4>
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3000ba18: e5972048 ldr r2, [r7, #72] ; 0x48
stats->searches += search_count;
3000ba1c: e597304c ldr r3, [r7, #76] ; 0x4c
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3000ba20: e2822001 add r2, r2, #1
stats->searches += search_count;
3000ba24: 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;
3000ba28: e5872048 str r2, [r7, #72] ; 0x48
stats->searches += search_count;
3000ba2c: e587304c str r3, [r7, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000ba30: e1a00007 mov r0, r7 3000ba34: e1a01009 mov r1, r9 3000ba38: e1a02004 mov r2, r4 3000ba3c: e1a03005 mov r3, r5 3000ba40: ebffeb89 bl 3000686c <_Heap_Block_allocate> 3000ba44: e1a00004 mov r0, r4
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
3000ba48: e5973044 ldr r3, [r7, #68] ; 0x44 3000ba4c: e1530006 cmp r3, r6
stats->max_search = search_count;
3000ba50: 35876044 strcc r6, [r7, #68] ; 0x44
}
return (void *) alloc_begin;
}
3000ba54: e28dd01c add sp, sp, #28
3000ba58: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
3000ba5c: e1550003 cmp r5, r3
3000ba60: 9a000008 bls 3000ba88 <_Heap_Allocate_aligned_with_boundary+0x234>
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000ba64: e3a00000 mov r0, #0 3000ba68: eafffff9 b 3000ba54 <_Heap_Allocate_aligned_with_boundary+0x200>
3000ba6c: e59d9018 ldr r9, [sp, #24] <== NOT EXECUTED
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
3000ba70: e2863001 add r3, r6, #1 <== NOT EXECUTED 3000ba74: 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 ) {
3000ba78: e1570009 cmp r7, r9 <== NOT EXECUTED 3000ba7c: 1affffe1 bne 3000ba08 <_Heap_Allocate_aligned_with_boundary+0x1b4><== NOT EXECUTED
3000ba80: e3a00000 mov r0, #0 3000ba84: eaffffef b 3000ba48 <_Heap_Allocate_aligned_with_boundary+0x1f4>
if ( boundary < alloc_size ) {
return NULL;
}
if ( alignment == 0 ) {
alignment = page_size;
3000ba88: e3580000 cmp r8, #0 3000ba8c: 01a08002 moveq r8, r2 3000ba90: eaffff7c b 3000b888 <_Heap_Allocate_aligned_with_boundary+0x34>
3000ba94 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
3000ba94: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
3000ba98: e1a04000 mov r4, r0
3000ba9c: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000baa0: e1a00001 mov r0, r1 3000baa4: e5941010 ldr r1, [r4, #16] 3000baa8: eb001637 bl 3001138c <__umodsi3> 3000baac: e2455008 sub r5, 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
3000bab0: 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);
3000bab4: 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;
3000bab8: e1550003 cmp r5, r3
3000babc: 3a00002f bcc 3000bb80 <_Heap_Free+0xec>
3000bac0: e5941024 ldr r1, [r4, #36] ; 0x24 3000bac4: e1550001 cmp r5, r1
3000bac8: 8a00002c bhi 3000bb80 <_Heap_Free+0xec>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
3000bacc: 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;
3000bad0: 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);
3000bad4: e0852006 add r2, 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;
3000bad8: e1530002 cmp r3, r2
3000badc: 8a000027 bhi 3000bb80 <_Heap_Free+0xec>
3000bae0: e1510002 cmp r1, r2
3000bae4: 3a000027 bcc 3000bb88 <_Heap_Free+0xf4>
3000bae8: e5927004 ldr r7, [r2, #4]
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
3000baec: e2170001 ands r0, r7, #1
3000baf0: 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 ));
3000baf4: e1510002 cmp r1, r2
- 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;
3000baf8: e3c77001 bic r7, r7, #1 3000bafc: 03a08000 moveq r8, #0
3000bb00: 0a000004 beq 3000bb18 <_Heap_Free+0x84>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
3000bb04: e0820007 add r0, r2, 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;
3000bb08: e5900004 ldr r0, [r0, #4]
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
3000bb0c: e3100001 tst r0, #1 3000bb10: 13a08000 movne r8, #0 3000bb14: 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 ) ) {
3000bb18: e21c0001 ands r0, ip, #1
3000bb1c: 1a00001b bne 3000bb90 <_Heap_Free+0xfc>
uintptr_t const prev_size = block->prev_size;
3000bb20: 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);
3000bb24: 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;
3000bb28: e153000a cmp r3, sl
3000bb2c: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
3000bb30: e151000a cmp r1, sl
3000bb34: 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;
3000bb38: 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) ) {
3000bb3c: e2100001 ands r0, r0, #1
3000bb40: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
3000bb44: e3580000 cmp r8, #0
3000bb48: 0a000039 beq 3000bc34 <_Heap_Free+0x1a0>
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
3000bb4c: 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;
3000bb50: e0867007 add r7, r6, r7
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
3000bb54: e5923008 ldr r3, [r2, #8]
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
3000bb58: e087c00c add ip, r7, ip
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
3000bb5c: e592200c ldr r2, [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;
3000bb60: e2400001 sub r0, r0, #1
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
3000bb64: 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;
3000bb68: e5823008 str r3, [r2, #8]
next->prev = prev;
3000bb6c: e583200c str r2, [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;
3000bb70: e5840038 str r0, [r4, #56] ; 0x38
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
3000bb74: 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;
3000bb78: e78ac00c str ip, [sl, ip] 3000bb7c: ea00000f b 3000bbc0 <_Heap_Free+0x12c>
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
3000bb80: e3a00000 mov r0, #0
3000bb84: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
3000bb88: e3a00000 mov r0, #0 <== NOT EXECUTED
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
3000bb8c: 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 */
3000bb90: e3580000 cmp r8, #0
3000bb94: 0a000014 beq 3000bbec <_Heap_Free+0x158>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
3000bb98: e5923008 ldr r3, [r2, #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;
3000bb9c: e0877006 add r7, r7, r6
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
3000bba0: e592200c ldr r2, [r2, #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;
3000bba4: e3871001 orr r1, r7, #1
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
3000bba8: e5853008 str r3, [r5, #8]
new_block->prev = prev;
3000bbac: e585200c str r2, [r5, #12]
next->prev = new_block;
prev->next = new_block;
3000bbb0: e5825008 str r5, [r2, #8]
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
3000bbb4: e583500c str r5, [r3, #12] 3000bbb8: e5851004 str r1, [r5, #4]
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
3000bbbc: e7857007 str r7, [r5, r7]
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
3000bbc0: e5942040 ldr r2, [r4, #64] ; 0x40
++stats->frees;
3000bbc4: e5943050 ldr r3, [r4, #80] ; 0x50
stats->free_size += block_size;
3000bbc8: e5941030 ldr r1, [r4, #48] ; 0x30
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
3000bbcc: e2422001 sub r2, r2, #1
++stats->frees;
3000bbd0: e2833001 add r3, r3, #1
stats->free_size += block_size;
3000bbd4: e0816006 add r6, r1, r6
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
3000bbd8: e5842040 str r2, [r4, #64] ; 0x40
++stats->frees;
3000bbdc: e5843050 str r3, [r4, #80] ; 0x50
stats->free_size += block_size;
3000bbe0: e5846030 str r6, [r4, #48] ; 0x30
return( true );
3000bbe4: e3a00001 mov r0, #1
3000bbe8: 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;
3000bbec: e3863001 orr r3, r6, #1 3000bbf0: e5853004 str r3, [r5, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
3000bbf4: e5943038 ldr r3, [r4, #56] ; 0x38
if ( stats->max_free_blocks < stats->free_blocks ) {
3000bbf8: e594c03c ldr ip, [r4, #60] ; 0x3c
} 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;
3000bbfc: e5920004 ldr r0, [r2, #4]
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
3000bc00: e5941008 ldr r1, [r4, #8]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
3000bc04: e2833001 add r3, r3, #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;
3000bc08: e3c00001 bic r0, r0, #1
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
if ( stats->max_free_blocks < stats->free_blocks ) {
3000bc0c: e153000c cmp r3, ip
new_block->next = next;
3000bc10: e5851008 str r1, [r5, #8]
new_block->prev = block_before;
3000bc14: 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;
3000bc18: e5820004 str r0, [r2, #4]
block_before->next = new_block; next->prev = new_block;
3000bc1c: e581500c str r5, [r1, #12]
next_block->prev_size = block_size;
3000bc20: 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;
3000bc24: e5845008 str r5, [r4, #8]
/* Statistics */
++stats->free_blocks;
3000bc28: e5843038 str r3, [r4, #56] ; 0x38
if ( stats->max_free_blocks < stats->free_blocks ) {
stats->max_free_blocks = stats->free_blocks;
3000bc2c: 8584303c strhi r3, [r4, #60] ; 0x3c 3000bc30: eaffffe2 b 3000bbc0 <_Heap_Free+0x12c>
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;
3000bc34: e086c00c add ip, r6, ip
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
3000bc38: e38c3001 orr r3, ip, #1 3000bc3c: e58a3004 str r3, [sl, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000bc40: e5923004 ldr r3, [r2, #4]
next_block->prev_size = size;
3000bc44: e785c006 str ip, [r5, r6]
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
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;
3000bc48: e3c33001 bic r3, r3, #1 3000bc4c: e5823004 str r3, [r2, #4] 3000bc50: eaffffda b 3000bbc0 <_Heap_Free+0x12c>
300138bc <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
300138bc: e92d40f0 push {r4, r5, r6, r7, lr}
300138c0: e1a04000 mov r4, r0
300138c4: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
300138c8: e1a00001 mov r0, r1 300138cc: e5941010 ldr r1, [r4, #16] 300138d0: e1a07002 mov r7, r2 300138d4: ebfff6ac bl 3001138c <__umodsi3> 300138d8: 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
300138dc: 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);
300138e0: 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;
300138e4: e1500003 cmp r0, r3
300138e8: 3a000010 bcc 30013930 <_Heap_Size_of_alloc_area+0x74>
300138ec: e5942024 ldr r2, [r4, #36] ; 0x24 300138f0: e1500002 cmp r0, r2
300138f4: 8a00000d bhi 30013930 <_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;
300138f8: e5906004 ldr r6, [r0, #4] 300138fc: 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);
30013900: 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;
30013904: e1530006 cmp r3, r6
30013908: 8a000008 bhi 30013930 <_Heap_Size_of_alloc_area+0x74>
3001390c: e1520006 cmp r2, r6
30013910: 3a000008 bcc 30013938 <_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;
30013914: 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 )
30013918: e2100001 ands r0, r0, #1
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
3001391c: 12655004 rsbne r5, r5, #4 30013920: 10856006 addne r6, r5, r6 30013924: 15876000 strne r6, [r7]
return true;
30013928: 13a00001 movne r0, #1
3001392c: e8bd80f0 pop {r4, r5, r6, r7, pc}
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
30013930: e3a00000 mov r0, #0
30013934: e8bd80f0 pop {r4, r5, r6, r7, pc}
30013938: e3a00000 mov r0, #0 <== NOT EXECUTED
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
3001393c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
300075cc <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
300075cc: 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() ) ) {
300075d0: e59f35cc ldr r3, [pc, #1484] ; 30007ba4 <_Heap_Walk+0x5d8>
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;
300075d4: e31200ff tst r2, #255 ; 0xff
if ( !_System_state_Is_up( _System_state_Get() ) ) {
300075d8: 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;
300075dc: e59f25c4 ldr r2, [pc, #1476] ; 30007ba8 <_Heap_Walk+0x5dc> 300075e0: e59f95c4 ldr r9, [pc, #1476] ; 30007bac <_Heap_Walk+0x5e0>
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
300075e4: 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;
300075e8: 11a09002 movne r9, r2
Heap_Control *heap,
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
300075ec: 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() ) ) {
300075f0: 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;
300075f4: e5902014 ldr r2, [r0, #20]
Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block;
300075f8: e5903024 ldr r3, [r0, #36] ; 0x24
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
300075fc: e24dd038 sub sp, sp, #56 ; 0x38 30007600: e1a04000 mov r4, r0
uintptr_t const page_size = heap->page_size;
30007604: e58d1024 str r1, [sp, #36] ; 0x24
uintptr_t const min_block_size = heap->min_block_size;
30007608: e58d2028 str r2, [sp, #40] ; 0x28
Heap_Block *const first_block = heap->first_block;
3000760c: e5908020 ldr r8, [r0, #32]
Heap_Block *const last_block = heap->last_block;
30007610: 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() ) ) {
30007614: 0a000002 beq 30007624 <_Heap_Walk+0x58>
}
block = next_block;
} while ( block != first_block );
return true;
30007618: e3a00001 mov r0, #1
}
3000761c: e28dd038 add sp, sp, #56 ; 0x38
30007620: 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)(
30007624: e594101c ldr r1, [r4, #28] 30007628: e5900018 ldr r0, [r0, #24] 3000762c: e5942008 ldr r2, [r4, #8] 30007630: e594300c ldr r3, [r4, #12] 30007634: e59dc028 ldr ip, [sp, #40] ; 0x28 30007638: e58d1008 str r1, [sp, #8] 3000763c: e59d102c ldr r1, [sp, #44] ; 0x2c 30007640: e58d0004 str r0, [sp, #4] 30007644: e58d1010 str r1, [sp, #16] 30007648: e58d2014 str r2, [sp, #20] 3000764c: e58d3018 str r3, [sp, #24] 30007650: e59f2558 ldr r2, [pc, #1368] ; 30007bb0 <_Heap_Walk+0x5e4> 30007654: e58dc000 str ip, [sp] 30007658: e58d800c str r8, [sp, #12] 3000765c: e1a0000a mov r0, sl 30007660: e3a01000 mov r1, #0 30007664: e59d3024 ldr r3, [sp, #36] ; 0x24 30007668: e1a0e00f mov lr, pc 3000766c: e12fff19 bx r9
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
30007670: e59d2024 ldr r2, [sp, #36] ; 0x24 30007674: e3520000 cmp r2, #0
30007678: 0a000026 beq 30007718 <_Heap_Walk+0x14c>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
3000767c: e59d3024 ldr r3, [sp, #36] ; 0x24 30007680: e2135007 ands r5, r3, #7
30007684: 1a00002a bne 30007734 <_Heap_Walk+0x168>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
30007688: e59d0028 ldr r0, [sp, #40] ; 0x28 3000768c: e59d1024 ldr r1, [sp, #36] ; 0x24 30007690: ebffe53f bl 30000b94 <__umodsi3>
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
30007694: e250b000 subs fp, r0, #0
30007698: 1a00002c bne 30007750 <_Heap_Walk+0x184>
3000769c: e2880008 add r0, r8, #8 300076a0: e59d1024 ldr r1, [sp, #36] ; 0x24 300076a4: ebffe53a bl 30000b94 <__umodsi3>
);
return false;
}
if (
300076a8: e2506000 subs r6, r0, #0
300076ac: 1a00002f bne 30007770 <_Heap_Walk+0x1a4>
block = next_block;
} while ( block != first_block );
return true;
}
300076b0: e598b004 ldr fp, [r8, #4]
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
300076b4: e21b5001 ands r5, fp, #1
300076b8: 0a0000cd beq 300079f4 <_Heap_Walk+0x428>
- 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;
300076bc: e59dc02c ldr ip, [sp, #44] ; 0x2c 300076c0: e59c3004 ldr r3, [ip, #4] 300076c4: 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);
300076c8: 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;
300076cc: e5935004 ldr r5, [r3, #4]
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
300076d0: e2155001 ands r5, r5, #1
300076d4: 0a000008 beq 300076fc <_Heap_Walk+0x130>
);
return false;
}
if (
300076d8: e1580003 cmp r8, r3
300076dc: 0a00002b beq 30007790 <_Heap_Walk+0x1c4>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
300076e0: e1a0000a mov r0, sl <== NOT EXECUTED 300076e4: e3a01001 mov r1, #1 <== NOT EXECUTED 300076e8: e59f24c4 ldr r2, [pc, #1220] ; 30007bb4 <_Heap_Walk+0x5e8> <== NOT EXECUTED 300076ec: e1a0e00f mov lr, pc <== NOT EXECUTED 300076f0: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
300076f4: e1a00006 mov r0, r6 <== NOT EXECUTED 300076f8: eaffffc7 b 3000761c <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
300076fc: e1a0000a mov r0, sl 30007700: e3a01001 mov r1, #1 30007704: e59f24ac ldr r2, [pc, #1196] ; 30007bb8 <_Heap_Walk+0x5ec> 30007708: e1a0e00f mov lr, pc 3000770c: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
30007710: e1a00005 mov r0, r5 30007714: eaffffc0 b 3000761c <_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" );
30007718: e1a0000a mov r0, sl 3000771c: e3a01001 mov r1, #1 30007720: e59f2494 ldr r2, [pc, #1172] ; 30007bbc <_Heap_Walk+0x5f0> 30007724: e1a0e00f mov lr, pc 30007728: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000772c: e59d0024 ldr r0, [sp, #36] ; 0x24 30007730: eaffffb9 b 3000761c <_Heap_Walk+0x50>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
30007734: e1a0000a mov r0, sl 30007738: e3a01001 mov r1, #1 3000773c: e59f247c ldr r2, [pc, #1148] ; 30007bc0 <_Heap_Walk+0x5f4> 30007740: e1a0e00f mov lr, pc 30007744: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
30007748: e3a00000 mov r0, #0 3000774c: eaffffb2 b 3000761c <_Heap_Walk+0x50>
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
30007750: e1a0000a mov r0, sl 30007754: e3a01001 mov r1, #1 30007758: e59f2464 ldr r2, [pc, #1124] ; 30007bc4 <_Heap_Walk+0x5f8> 3000775c: e59d3028 ldr r3, [sp, #40] ; 0x28 30007760: e1a0e00f mov lr, pc 30007764: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
30007768: e1a00005 mov r0, r5 3000776c: eaffffaa b 3000761c <_Heap_Walk+0x50>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
30007770: e1a0000a mov r0, sl 30007774: e3a01001 mov r1, #1 30007778: e59f2448 ldr r2, [pc, #1096] ; 30007bc8 <_Heap_Walk+0x5fc> 3000777c: e1a03008 mov r3, r8 30007780: e1a0e00f mov lr, pc 30007784: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
30007788: e1a0000b mov r0, fp 3000778c: eaffffa2 b 3000761c <_Heap_Walk+0x50>
block = next_block;
} while ( block != first_block );
return true;
}
30007790: e5945008 ldr r5, [r4, #8]
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
30007794: 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 ) {
30007798: e1540005 cmp r4, r5 3000779c: 05943020 ldreq r3, [r4, #32]
300077a0: 0a00000d beq 300077dc <_Heap_Walk+0x210>
block = next_block;
} while ( block != first_block );
return true;
}
300077a4: 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;
300077a8: e1530005 cmp r3, r5
300077ac: 9a000097 bls 30007a10 <_Heap_Walk+0x444>
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
300077b0: e1a0000a mov r0, sl 300077b4: e3a01001 mov r1, #1 300077b8: e59f240c ldr r2, [pc, #1036] ; 30007bcc <_Heap_Walk+0x600> 300077bc: e1a03005 mov r3, r5 300077c0: e1a0e00f mov lr, pc 300077c4: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
300077c8: e3a00000 mov r0, #0 300077cc: eaffff92 b 3000761c <_Heap_Walk+0x50> 300077d0: e1a03008 mov r3, r8 300077d4: e59db034 ldr fp, [sp, #52] ; 0x34 300077d8: e59d8030 ldr r8, [sp, #48] ; 0x30
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
300077dc: 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;
300077e0: 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);
300077e4: 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;
300077e8: e1530005 cmp r3, r5
300077ec: 9a000008 bls 30007814 <_Heap_Walk+0x248>
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)(
300077f0: e1a0000a mov r0, sl 300077f4: e58d5000 str r5, [sp] 300077f8: e3a01001 mov r1, #1 300077fc: e59f23cc ldr r2, [pc, #972] ; 30007bd0 <_Heap_Walk+0x604> 30007800: e1a03006 mov r3, r6 30007804: e1a0e00f mov lr, pc 30007808: e12fff19 bx r9
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
3000780c: e3a00000 mov r0, #0 30007810: eaffff81 b 3000761c <_Heap_Walk+0x50> 30007814: e5943024 ldr r3, [r4, #36] ; 0x24 30007818: e1530005 cmp r3, r5
3000781c: 3afffff3 bcc 300077f0 <_Heap_Walk+0x224>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
30007820: e59d1024 ldr r1, [sp, #36] ; 0x24 30007824: e1a00007 mov r0, r7 30007828: ebffe4d9 bl 30000b94 <__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;
3000782c: e59d102c ldr r1, [sp, #44] ; 0x2c 30007830: e0563001 subs r3, r6, r1 30007834: 13a03001 movne r3, #1
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
30007838: e3500000 cmp r0, #0
3000783c: 0a000001 beq 30007848 <_Heap_Walk+0x27c>
30007840: e3530000 cmp r3, #0
30007844: 1a0000aa bne 30007af4 <_Heap_Walk+0x528>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
30007848: e59d2028 ldr r2, [sp, #40] ; 0x28 3000784c: e1520007 cmp r2, r7
30007850: 9a000001 bls 3000785c <_Heap_Walk+0x290>
30007854: e3530000 cmp r3, #0
30007858: 1a0000ae bne 30007b18 <_Heap_Walk+0x54c>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
3000785c: e1560005 cmp r6, r5
30007860: 3a000001 bcc 3000786c <_Heap_Walk+0x2a0>
30007864: e3530000 cmp r3, #0
30007868: 1a0000b4 bne 30007b40 <_Heap_Walk+0x574>
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;
3000786c: e5953004 ldr r3, [r5, #4] 30007870: e20bb001 and fp, fp, #1
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
30007874: e3130001 tst r3, #1
30007878: 0a000018 beq 300078e0 <_Heap_Walk+0x314>
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
3000787c: e35b0000 cmp fp, #0
30007880: 0a00000c beq 300078b8 <_Heap_Walk+0x2ec>
(*printer)(
30007884: e58d7000 str r7, [sp] 30007888: e1a0000a mov r0, sl 3000788c: e3a01000 mov r1, #0 30007890: e59f233c ldr r2, [pc, #828] ; 30007bd4 <_Heap_Walk+0x608> 30007894: e1a03006 mov r3, r6 30007898: e1a0e00f mov lr, pc 3000789c: e12fff19 bx r9
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
300078a0: e1580005 cmp r8, r5
300078a4: 0affff5b beq 30007618 <_Heap_Walk+0x4c>
300078a8: e595b004 ldr fp, [r5, #4] 300078ac: e5943020 ldr r3, [r4, #32] 300078b0: e1a06005 mov r6, r5 300078b4: eaffffc9 b 300077e0 <_Heap_Walk+0x214>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
300078b8: e58d7000 str r7, [sp] 300078bc: e5963000 ldr r3, [r6] 300078c0: e1a0000a mov r0, sl 300078c4: e58d3004 str r3, [sp, #4] 300078c8: e1a0100b mov r1, fp 300078cc: e59f2304 ldr r2, [pc, #772] ; 30007bd8 <_Heap_Walk+0x60c> 300078d0: e1a03006 mov r3, r6 300078d4: e1a0e00f mov lr, pc 300078d8: e12fff19 bx r9 300078dc: eaffffef b 300078a0 <_Heap_Walk+0x2d4>
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 ?
300078e0: 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)(
300078e4: e5943008 ldr r3, [r4, #8]
block = next_block;
} while ( block != first_block );
return true;
}
300078e8: 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)(
300078ec: e1530002 cmp r3, r2 300078f0: 059f02e4 ldreq r0, [pc, #740] ; 30007bdc <_Heap_Walk+0x610>
300078f4: 0a000003 beq 30007908 <_Heap_Walk+0x33c>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
300078f8: e59f32e0 ldr r3, [pc, #736] ; 30007be0 <_Heap_Walk+0x614> 300078fc: e1540002 cmp r4, r2 30007900: e59f02dc ldr r0, [pc, #732] ; 30007be4 <_Heap_Walk+0x618> 30007904: 01a00003 moveq r0, r3
block->next,
block->next == last_free_block ?
30007908: 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)(
3000790c: e1510003 cmp r1, r3 30007910: 059f12d0 ldreq r1, [pc, #720] ; 30007be8 <_Heap_Walk+0x61c>
30007914: 0a000003 beq 30007928 <_Heap_Walk+0x35c>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
30007918: e59fc2cc ldr ip, [pc, #716] ; 30007bec <_Heap_Walk+0x620> 3000791c: e1540003 cmp r4, r3 30007920: e59f12bc ldr r1, [pc, #700] ; 30007be4 <_Heap_Walk+0x618> 30007924: 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)(
30007928: e58d2004 str r2, [sp, #4] 3000792c: e58d0008 str r0, [sp, #8] 30007930: e58d300c str r3, [sp, #12] 30007934: e58d1010 str r1, [sp, #16] 30007938: e1a03006 mov r3, r6 3000793c: e58d7000 str r7, [sp] 30007940: e1a0000a mov r0, sl 30007944: e3a01000 mov r1, #0 30007948: e59f22a0 ldr r2, [pc, #672] ; 30007bf0 <_Heap_Walk+0x624> 3000794c: e1a0e00f mov lr, pc 30007950: e12fff19 bx r9
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
30007954: e5953000 ldr r3, [r5] 30007958: e1570003 cmp r7, r3
3000795c: 1a000011 bne 300079a8 <_Heap_Walk+0x3dc>
);
return false;
}
if ( !prev_used ) {
30007960: e35b0000 cmp fp, #0
30007964: 0a00001a beq 300079d4 <_Heap_Walk+0x408>
block = next_block;
} while ( block != first_block );
return true;
}
30007968: 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 ) {
3000796c: e1540003 cmp r4, r3
30007970: 0a000004 beq 30007988 <_Heap_Walk+0x3bc>
if ( free_block == block ) {
30007974: e1560003 cmp r6, r3
30007978: 0affffc8 beq 300078a0 <_Heap_Walk+0x2d4>
return true;
}
free_block = free_block->next;
3000797c: 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 ) {
30007980: e1540003 cmp r4, r3
30007984: 1afffffa bne 30007974 <_Heap_Walk+0x3a8>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
30007988: e1a0000a mov r0, sl 3000798c: e3a01001 mov r1, #1 30007990: e59f225c ldr r2, [pc, #604] ; 30007bf4 <_Heap_Walk+0x628> 30007994: e1a03006 mov r3, r6 30007998: e1a0e00f mov lr, pc 3000799c: e12fff19 bx r9
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
300079a0: e3a00000 mov r0, #0 300079a4: eaffff1c b 3000761c <_Heap_Walk+0x50>
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
300079a8: e58d3004 str r3, [sp, #4] 300079ac: e1a0000a mov r0, sl 300079b0: e58d7000 str r7, [sp] 300079b4: e58d5008 str r5, [sp, #8] 300079b8: e3a01001 mov r1, #1 300079bc: e59f2234 ldr r2, [pc, #564] ; 30007bf8 <_Heap_Walk+0x62c> 300079c0: e1a03006 mov r3, r6 300079c4: e1a0e00f mov lr, pc 300079c8: e12fff19 bx r9
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
300079cc: e3a00000 mov r0, #0 300079d0: eaffff11 b 3000761c <_Heap_Walk+0x50>
return false;
}
if ( !prev_used ) {
(*printer)(
300079d4: e1a0000a mov r0, sl 300079d8: e3a01001 mov r1, #1 300079dc: e59f2218 ldr r2, [pc, #536] ; 30007bfc <_Heap_Walk+0x630> 300079e0: e1a03006 mov r3, r6 300079e4: e1a0e00f mov lr, pc 300079e8: e12fff19 bx r9
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
300079ec: e1a0000b mov r0, fp 300079f0: eaffff09 b 3000761c <_Heap_Walk+0x50>
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
300079f4: e1a0000a mov r0, sl 300079f8: e3a01001 mov r1, #1 300079fc: e59f21fc ldr r2, [pc, #508] ; 30007c00 <_Heap_Walk+0x634> 30007a00: e1a0e00f mov lr, pc 30007a04: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
30007a08: e1a00005 mov r0, r5 30007a0c: eaffff02 b 3000761c <_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;
30007a10: e594c024 ldr ip, [r4, #36] ; 0x24 30007a14: e15c0005 cmp ip, r5
30007a18: 3affff64 bcc 300077b0 <_Heap_Walk+0x1e4>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
30007a1c: e2850008 add r0, r5, #8 30007a20: e1a01007 mov r1, r7 30007a24: e58d3020 str r3, [sp, #32] 30007a28: e58dc01c str ip, [sp, #28] 30007a2c: ebffe458 bl 30000b94 <__umodsi3>
);
return false;
}
if (
30007a30: e3500000 cmp r0, #0 30007a34: e59d3020 ldr r3, [sp, #32] 30007a38: e59dc01c ldr ip, [sp, #28]
30007a3c: 1a000048 bne 30007b64 <_Heap_Walk+0x598>
- 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;
30007a40: e5952004 ldr r2, [r5, #4] 30007a44: e3c22001 bic r2, r2, #1
block = next_block;
} while ( block != first_block );
return true;
}
30007a48: e0852002 add r2, r5, 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;
30007a4c: e5922004 ldr r2, [r2, #4]
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
30007a50: e3120001 tst r2, #1
30007a54: 1a00004a bne 30007b84 <_Heap_Walk+0x5b8>
30007a58: e58d8030 str r8, [sp, #48] ; 0x30 30007a5c: e58db034 str fp, [sp, #52] ; 0x34 30007a60: e1a01004 mov r1, r4 30007a64: e1a06005 mov r6, r5 30007a68: e1a08003 mov r8, r3 30007a6c: e1a0b00c mov fp, ip 30007a70: ea000013 b 30007ac4 <_Heap_Walk+0x4f8>
return false;
}
prev_block = free_block;
free_block = free_block->next;
30007a74: e5955008 ldr r5, [r5, #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 ) {
30007a78: e1540005 cmp r4, r5
30007a7c: 0affff53 beq 300077d0 <_Heap_Walk+0x204>
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;
30007a80: e1580005 cmp r8, r5
30007a84: 8affff49 bhi 300077b0 <_Heap_Walk+0x1e4>
30007a88: e155000b cmp r5, fp
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
30007a8c: e2850008 add r0, r5, #8 30007a90: 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;
30007a94: 8affff45 bhi 300077b0 <_Heap_Walk+0x1e4>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
30007a98: ebffe43d bl 30000b94 <__umodsi3>
);
return false;
}
if (
30007a9c: e3500000 cmp r0, #0
30007aa0: 1a00002f bne 30007b64 <_Heap_Walk+0x598>
- 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;
30007aa4: e5953004 ldr r3, [r5, #4]
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
30007aa8: e1a01006 mov r1, r6 30007aac: e3c33001 bic r3, r3, #1
block = next_block;
} while ( block != first_block );
return true;
}
30007ab0: 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;
30007ab4: e5933004 ldr r3, [r3, #4]
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
30007ab8: e1a06005 mov r6, r5 30007abc: e3130001 tst r3, #1
30007ac0: 1a00002f bne 30007b84 <_Heap_Walk+0x5b8>
);
return false;
}
if ( free_block->prev != prev_block ) {
30007ac4: e595200c ldr r2, [r5, #12] 30007ac8: e1520001 cmp r2, r1
30007acc: 0affffe8 beq 30007a74 <_Heap_Walk+0x4a8>
(*printer)(
30007ad0: e58d2000 str r2, [sp] 30007ad4: e1a0000a mov r0, sl 30007ad8: e3a01001 mov r1, #1 30007adc: e59f2120 ldr r2, [pc, #288] ; 30007c04 <_Heap_Walk+0x638> 30007ae0: e1a03005 mov r3, r5 30007ae4: e1a0e00f mov lr, pc 30007ae8: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
30007aec: e3a00000 mov r0, #0 30007af0: eafffec9 b 3000761c <_Heap_Walk+0x50>
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
30007af4: e1a0000a mov r0, sl 30007af8: e58d7000 str r7, [sp] 30007afc: e3a01001 mov r1, #1 30007b00: e59f2100 ldr r2, [pc, #256] ; 30007c08 <_Heap_Walk+0x63c> 30007b04: e1a03006 mov r3, r6 30007b08: e1a0e00f mov lr, pc 30007b0c: e12fff19 bx r9
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
30007b10: e3a00000 mov r0, #0 30007b14: eafffec0 b 3000761c <_Heap_Walk+0x50>
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
30007b18: e58d2004 str r2, [sp, #4] 30007b1c: e1a0000a mov r0, sl 30007b20: e58d7000 str r7, [sp] 30007b24: e3a01001 mov r1, #1 30007b28: e59f20dc ldr r2, [pc, #220] ; 30007c0c <_Heap_Walk+0x640> 30007b2c: e1a03006 mov r3, r6 30007b30: e1a0e00f mov lr, pc 30007b34: e12fff19 bx r9
block,
block_size,
min_block_size
);
return false;
30007b38: e3a00000 mov r0, #0 30007b3c: eafffeb6 b 3000761c <_Heap_Walk+0x50>
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
30007b40: e1a0000a mov r0, sl 30007b44: e58d5000 str r5, [sp] 30007b48: e3a01001 mov r1, #1 30007b4c: e59f20bc ldr r2, [pc, #188] ; 30007c10 <_Heap_Walk+0x644> 30007b50: e1a03006 mov r3, r6 30007b54: e1a0e00f mov lr, pc 30007b58: e12fff19 bx r9
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
30007b5c: e3a00000 mov r0, #0 30007b60: eafffead b 3000761c <_Heap_Walk+0x50>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
30007b64: e1a0000a mov r0, sl 30007b68: e3a01001 mov r1, #1 30007b6c: e59f20a0 ldr r2, [pc, #160] ; 30007c14 <_Heap_Walk+0x648> 30007b70: e1a03005 mov r3, r5 30007b74: e1a0e00f mov lr, pc 30007b78: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
30007b7c: e3a00000 mov r0, #0 30007b80: eafffea5 b 3000761c <_Heap_Walk+0x50>
return false;
}
if ( _Heap_Is_used( free_block ) ) {
(*printer)(
30007b84: e1a0000a mov r0, sl 30007b88: e3a01001 mov r1, #1 30007b8c: e59f2084 ldr r2, [pc, #132] ; 30007c18 <_Heap_Walk+0x64c> 30007b90: e1a03005 mov r3, r5 30007b94: e1a0e00f mov lr, pc 30007b98: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
30007b9c: e3a00000 mov r0, #0 30007ba0: eafffe9d b 3000761c <_Heap_Walk+0x50>
300069b0 <_Internal_error_Occurred>:
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
300069b0: e59f303c ldr r3, [pc, #60] ; 300069f4 <_Internal_error_Occurred+0x44>
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
300069b4: e201c0ff and ip, r1, #255 ; 0xff
300069b8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
300069bc: e1a0100c mov r1, ip
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
300069c0: e5830000 str r0, [r3]
_Internal_errors_What_happened.is_internal = is_internal;
300069c4: e5c3c004 strb ip, [r3, #4]
_Internal_errors_What_happened.the_error = the_error;
300069c8: e5832008 str r2, [r3, #8]
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
300069cc: e1a04002 mov r4, r2
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
300069d0: eb00079e bl 30008850 <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
300069d4: e59f301c ldr r3, [pc, #28] ; 300069f8 <_Internal_error_Occurred+0x48><== NOT EXECUTED 300069d8: e3a02005 mov r2, #5 <== NOT EXECUTED 300069dc: e5832000 str r2, [r3] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
300069e0: e10f2000 mrs r2, CPSR <== NOT EXECUTED 300069e4: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 300069e8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
300069ec: e1a00004 mov r0, r4 <== NOT EXECUTED 300069f0: eafffffe b 300069f0 <_Internal_error_Occurred+0x40> <== NOT EXECUTED
30006ab8 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
30006ab8: 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 )
30006abc: e5904034 ldr r4, [r0, #52] ; 0x34
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
30006ac0: e24dd014 sub sp, sp, #20
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
30006ac4: e3540000 cmp r4, #0
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
30006ac8: 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 );
30006acc: e1d070b8 ldrh r7, [r0, #8]
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
30006ad0: 0a00009b beq 30006d44 <_Objects_Extend_information+0x28c>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
30006ad4: e1d081b4 ldrh r8, [r0, #20] 30006ad8: e1d0a1b0 ldrh sl, [r0, #16] 30006adc: e1a01008 mov r1, r8 30006ae0: e1a0000a mov r0, sl 30006ae4: eb0029e2 bl 30011274 <__aeabi_uidiv> 30006ae8: e1a03800 lsl r3, r0, #16
for ( ; block < block_count; block++ ) {
30006aec: e1b03823 lsrs r3, r3, #16
30006af0: 0a000099 beq 30006d5c <_Objects_Extend_information+0x2a4>
if ( information->object_blocks[ block ] == NULL ) {
30006af4: e5949000 ldr r9, [r4] 30006af8: e3590000 cmp r9, #0 30006afc: 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 );
30006b00: 01a06007 moveq r6, r7
index_base = minimum_index; block = 0;
30006b04: 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 ) {
30006b08: 0a00000c beq 30006b40 <_Objects_Extend_information+0x88>
30006b0c: e1a02004 mov r2, r4 30006b10: 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 );
30006b14: e1a06007 mov r6, r7
index_base = minimum_index; block = 0;
30006b18: e3a04000 mov r4, #0 30006b1c: ea000002 b 30006b2c <_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 ) {
30006b20: e5b29004 ldr r9, [r2, #4]! 30006b24: e3590000 cmp r9, #0
30006b28: 0a000004 beq 30006b40 <_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++ ) {
30006b2c: e2844001 add r4, r4, #1 30006b30: e1530004 cmp r3, r4
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
break;
} else
index_base += information->allocation_size;
30006b34: 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++ ) {
30006b38: 8afffff8 bhi 30006b20 <_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;
30006b3c: e3a09001 mov r9, #1
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
30006b40: 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 ) {
30006b44: e35a0801 cmp sl, #65536 ; 0x10000
30006b48: 2a000063 bcs 30006cdc <_Objects_Extend_information+0x224>
/*
* 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 ) {
30006b4c: 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;
30006b50: e5950018 ldr r0, [r5, #24]
if ( information->auto_extend ) {
30006b54: 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;
30006b58: e0000091 mul r0, r1, r0
if ( information->auto_extend ) {
30006b5c: 1a000060 bne 30006ce4 <_Objects_Extend_information+0x22c>
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
30006b60: e58d3000 str r3, [sp] 30006b64: eb00087c bl 30008d5c <_Workspace_Allocate_or_fatal_error> 30006b68: e59d3000 ldr r3, [sp] 30006b6c: e1a08000 mov r8, r0
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
30006b70: e3590000 cmp r9, #0
30006b74: 0a000039 beq 30006c60 <_Objects_Extend_information+0x1a8>
*/
/*
* Up the block count and maximum
*/
block_count++;
30006b78: e283b001 add fp, r3, #1
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
30006b7c: e08b008b add r0, fp, fp, lsl #1
((maximum + minimum_index) * sizeof(Objects_Control *));
30006b80: e08a0000 add r0, sl, r0
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
30006b84: e0800007 add r0, r0, r7
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
30006b88: e1a00100 lsl r0, r0, #2 30006b8c: e58d3000 str r3, [sp] 30006b90: eb000867 bl 30008d34 <_Workspace_Allocate>
if ( !object_blocks ) {
30006b94: e2509000 subs r9, r0, #0 30006b98: e59d3000 ldr r3, [sp]
30006b9c: 0a000073 beq 30006d70 <_Objects_Extend_information+0x2b8>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
30006ba0: e1d521b0 ldrh r2, [r5, #16]
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
30006ba4: e089c10b add ip, r9, fp, lsl #2 30006ba8: e1570002 cmp r7, r2 30006bac: e089b18b add fp, r9, fp, lsl #3
30006bb0: 3a000051 bcc 30006cfc <_Objects_Extend_information+0x244>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
30006bb4: e3570000 cmp r7, #0 30006bb8: 13a02000 movne r2, #0 30006bbc: 11a0100b movne r1, fp
local_table[ index ] = NULL;
30006bc0: 11a00002 movne r0, r2
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
30006bc4: 0a000003 beq 30006bd8 <_Objects_Extend_information+0x120>
30006bc8: e2822001 add r2, r2, #1 30006bcc: e1570002 cmp r7, r2
local_table[ index ] = NULL;
30006bd0: e4810004 str r0, [r1], #4
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
30006bd4: 8afffffb bhi 30006bc8 <_Objects_Extend_information+0x110>
30006bd8: 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 );
30006bdc: e1d511b4 ldrh r1, [r5, #20]
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
30006be0: e3a00000 mov r0, #0
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
30006be4: e0861001 add r1, r6, r1
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
30006be8: e1560001 cmp r6, r1
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
30006bec: e7890003 str r0, [r9, r3]
inactive_per_block[block_count] = 0;
30006bf0: e78c0003 str r0, [ip, r3]
for ( index=index_base ;
30006bf4: 2a000005 bcs 30006c10 <_Objects_Extend_information+0x158>
30006bf8: e08b2106 add r2, fp, r6, lsl #2
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
30006bfc: 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++ ) {
30006c00: 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 ;
30006c04: e1530001 cmp r3, r1
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
30006c08: 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 ;
30006c0c: 3afffffb bcc 30006c00 <_Objects_Extend_information+0x148>
30006c10: e10f3000 mrs r3, CPSR 30006c14: e3832080 orr r2, r3, #128 ; 0x80 30006c18: e129f002 msr CPSR_fc, r2
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
30006c1c: 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(
30006c20: e1d510b4 ldrh r1, [r5, #4] 30006c24: 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;
30006c28: e1a0a80a lsl sl, sl, #16 30006c2c: e3822801 orr r2, r2, #65536 ; 0x10000 30006c30: e1a0a82a lsr sl, sl, #16
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
30006c34: 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) |
30006c38: e182200a orr r2, r2, sl
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
30006c3c: e5950034 ldr r0, [r5, #52] ; 0x34
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
30006c40: e585c030 str ip, [r5, #48] ; 0x30
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
30006c44: e5859034 str r9, [r5, #52] ; 0x34
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
30006c48: e585b01c str fp, [r5, #28]
information->maximum = (Objects_Maximum) maximum;
30006c4c: e1c5a1b0 strh sl, [r5, #16]
information->maximum_id = _Objects_Build_id(
30006c50: e585200c str r2, [r5, #12]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
30006c54: e129f003 msr CPSR_fc, r3
information->maximum
);
_ISR_Enable( level );
if ( old_tables )
30006c58: e3500000 cmp r0, #0
_Workspace_Free( old_tables );
30006c5c: 1b00083a blne 30008d4c <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
30006c60: e5953034 ldr r3, [r5, #52] ; 0x34
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
30006c64: e28d7008 add r7, sp, #8
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
30006c68: e7838104 str r8, [r3, r4, lsl #2]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
30006c6c: e1a01008 mov r1, r8 30006c70: e1a00007 mov r0, r7 30006c74: e1d521b4 ldrh r2, [r5, #20] 30006c78: e5953018 ldr r3, [r5, #24] 30006c7c: eb001263 bl 3000b610 <_Chain_Initialize>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
30006c80: e1a04104 lsl r4, r4, #2
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
30006c84: 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 ) {
30006c88: ea000009 b 30006cb4 <_Objects_Extend_information+0x1fc> 30006c8c: e5953000 ldr r3, [r5]
the_object->id = _Objects_Build_id(
30006c90: e1d520b4 ldrh r2, [r5, #4] 30006c94: e1a03c03 lsl r3, r3, #24 30006c98: e3833801 orr r3, r3, #65536 ; 0x10000
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
30006c9c: 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) |
30006ca0: e1833006 orr r3, r3, r6 30006ca4: e5813008 str r3, [r1, #8]
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
30006ca8: e1a00008 mov r0, r8 30006cac: ebfffce8 bl 30006054 <_Chain_Append>
index++;
30006cb0: 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 ) {
30006cb4: e1a00007 mov r0, r7 30006cb8: ebfffcf8 bl 300060a0 <_Chain_Get> 30006cbc: e2501000 subs r1, r0, #0
30006cc0: 1afffff1 bne 30006c8c <_Objects_Extend_information+0x1d4>
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
30006cc4: e1d522bc ldrh r2, [r5, #44] ; 0x2c
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
30006cc8: e1d531b4 ldrh r3, [r5, #20] 30006ccc: e5951030 ldr r1, [r5, #48] ; 0x30
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
30006cd0: e0832002 add r2, r3, r2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
30006cd4: e7813004 str r3, [r1, r4]
information->inactive =
30006cd8: e1c522bc strh r2, [r5, #44] ; 0x2c
(Objects_Maximum)(information->inactive + information->allocation_size);
}
30006cdc: e28dd014 add sp, sp, #20
30006ce0: 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 );
30006ce4: e58d3000 str r3, [sp] 30006ce8: eb000811 bl 30008d34 <_Workspace_Allocate>
if ( !new_object_block )
30006cec: e2508000 subs r8, r0, #0 30006cf0: e59d3000 ldr r3, [sp]
30006cf4: 1affff9d bne 30006b70 <_Objects_Extend_information+0xb8>
30006cf8: eafffff7 b 30006cdc <_Objects_Extend_information+0x224>
/*
* 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,
30006cfc: e1a03103 lsl r3, r3, #2
30006d00: e5951034 ldr r1, [r5, #52] ; 0x34
30006d04: e1a02003 mov r2, r3
30006d08: e88d1008 stm sp, {r3, ip}
30006d0c: eb001de7 bl 3000e4b0 <memcpy>
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
30006d10: e89d1008 ldm sp, {r3, ip}
30006d14: e1a0000c mov r0, ip
30006d18: e1a02003 mov r2, r3
30006d1c: e5951030 ldr r1, [r5, #48] ; 0x30
30006d20: eb001de2 bl 3000e4b0 <memcpy>
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
30006d24: e1d521b0 ldrh r2, [r5, #16]
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
30006d28: e1a0000b mov r0, fp
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
30006d2c: 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,
30006d30: e595101c ldr r1, [r5, #28]
30006d34: e1a02102 lsl r2, r2, #2
30006d38: eb001ddc bl 3000e4b0 <memcpy>
30006d3c: e89d1008 ldm sp, {r3, ip}
30006d40: eaffffa5 b 30006bdc <_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 )
30006d44: e1d0a1b0 ldrh sl, [r0, #16] 30006d48: 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 );
30006d4c: 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;
30006d50: e3a09001 mov r9, #1
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
30006d54: e1a03004 mov r3, r4 30006d58: eaffff78 b 30006b40 <_Objects_Extend_information+0x88>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
30006d5c: 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 );
30006d60: 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;
30006d64: e3a09001 mov r9, #1 <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
30006d68: e1a04003 mov r4, r3 <== NOT EXECUTED 30006d6c: eaffff73 b 30006b40 <_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 );
30006d70: e1a00008 mov r0, r8 30006d74: eb0007f4 bl 30008d4c <_Workspace_Free>
return;
30006d78: eaffffd7 b 30006cdc <_Objects_Extend_information+0x224>
300070e8 <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
300070e8: 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 );
300070ec: e1d040b8 ldrh r4, [r0, #8]
block_count = (information->maximum - index_base) /
300070f0: e1d051b4 ldrh r5, [r0, #20]
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
300070f4: 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) /
300070f8: e1d001b0 ldrh r0, [r0, #16] 300070fc: e1a01005 mov r1, r5 30007100: e0640000 rsb r0, r4, r0 30007104: eb00285a bl 30011274 <__aeabi_uidiv>
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
30007108: e3500000 cmp r0, #0
3000710c: 08bd80f0 popeq {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
30007110: e5962030 ldr r2, [r6, #48] ; 0x30 30007114: e5923000 ldr r3, [r2] 30007118: 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++ ) {
3000711c: 13a03000 movne r3, #0
if ( information->inactive_per_block[ block ] ==
30007120: 1a000005 bne 3000713c <_Objects_Shrink_information+0x54>
30007124: ea000008 b 3000714c <_Objects_Shrink_information+0x64> <== NOT EXECUTED
30007128: e5b21004 ldr r1, [r2, #4]!
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
3000712c: e0844005 add r4, r4, r5
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 ] ==
30007130: e1550001 cmp r5, r1
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
30007134: 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 ] ==
30007138: 0a000004 beq 30007150 <_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++ ) {
3000713c: e2833001 add r3, r3, #1 30007140: e1500003 cmp r0, r3
30007144: 8afffff7 bhi 30007128 <_Objects_Shrink_information+0x40>
30007148: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
3000714c: 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 );
30007150: e5960020 ldr r0, [r6, #32] 30007154: ea000002 b 30007164 <_Objects_Shrink_information+0x7c>
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
30007158: e3550000 cmp r5, #0
3000715c: 0a00000b beq 30007190 <_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;
30007160: 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 );
30007164: 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;
30007168: e5905000 ldr r5, [r0]
if ((index >= index_base) &&
3000716c: e1530004 cmp r3, r4
30007170: 3afffff8 bcc 30007158 <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
30007174: e1d621b4 ldrh r2, [r6, #20] 30007178: 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) &&
3000717c: e1530002 cmp r3, r2
30007180: 2afffff4 bcs 30007158 <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
30007184: ebfffbbd bl 30006080 <_Chain_Extract>
}
}
while ( the_object );
30007188: e3550000 cmp r5, #0
3000718c: 1afffff3 bne 30007160 <_Objects_Shrink_information+0x78>
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
30007190: e5963034 ldr r3, [r6, #52] ; 0x34 30007194: e7930007 ldr r0, [r3, r7] 30007198: eb0006eb bl 30008d4c <_Workspace_Free>
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
3000719c: e1d602bc ldrh r0, [r6, #44] ; 0x2c 300071a0: 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;
300071a4: e5961034 ldr r1, [r6, #52] ; 0x34
information->inactive_per_block[ block ] = 0;
300071a8: e5962030 ldr r2, [r6, #48] ; 0x30
information->inactive -= information->allocation_size;
300071ac: 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;
300071b0: e7815007 str r5, [r1, r7]
information->inactive_per_block[ block ] = 0;
300071b4: e7825007 str r5, [r2, r7]
information->inactive -= information->allocation_size;
300071b8: e1c632bc strh r3, [r6, #44] ; 0x2c
return;
300071bc: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000db74 <_POSIX_signals_Clear_process_signals>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
3000db74: e10f2000 mrs r2, CPSR 3000db78: e3823080 orr r3, r2, #128 ; 0x80 3000db7c: 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 ) {
3000db80: e59f1050 ldr r1, [pc, #80] ; 3000dbd8 <_POSIX_signals_Clear_process_signals+0x64> 3000db84: e0803080 add r3, r0, r0, lsl #1 3000db88: e7911103 ldr r1, [r1, r3, lsl #2] 3000db8c: e1a0c103 lsl ip, r3, #2 3000db90: e3510002 cmp r1, #2
3000db94: 0a000007 beq 3000dbb8 <_POSIX_signals_Clear_process_signals+0x44>
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
3000db98: e59f303c ldr r3, [pc, #60] ; 3000dbdc <_POSIX_signals_Clear_process_signals+0x68> 3000db9c: e3a0c001 mov ip, #1 3000dba0: e5931000 ldr r1, [r3] 3000dba4: e2400001 sub r0, r0, #1 3000dba8: e1c1001c bic r0, r1, ip, lsl r0 3000dbac: e5830000 str r0, [r3]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3000dbb0: e129f002 msr CPSR_fc, r2
}
_ISR_Enable( level );
}
3000dbb4: e12fff1e bx lr 3000dbb8: e59f1020 ldr r1, [pc, #32] ; 3000dbe0 <_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 );
3000dbbc: e28cc004 add ip, ip, #4
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
3000dbc0: e7913103 ldr r3, [r1, r3, lsl #2] 3000dbc4: e08c1001 add r1, ip, r1 3000dbc8: e1530001 cmp r3, r1
3000dbcc: 0afffff1 beq 3000db98 <_POSIX_signals_Clear_process_signals+0x24>
3000dbd0: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
}
3000dbd4: e12fff1e bx lr <== NOT EXECUTED
30021edc <_POSIX_signals_Unblock_thread>:
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
30021edc: e590c010 ldr ip, [r0, #16] 30021ee0: e59f3110 ldr r3, [pc, #272] ; 30021ff8 <_POSIX_signals_Unblock_thread+0x11c>
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
30021ee4: 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 ) ) {
30021ee8: e59f7108 ldr r7, [pc, #264] ; 30021ff8 <_POSIX_signals_Unblock_thread+0x11c> 30021eec: e00c3003 and r3, ip, r3 30021ef0: e2416001 sub r6, r1, #1 30021ef4: e3a05001 mov r5, #1 30021ef8: e1530007 cmp r3, r7
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
30021efc: e1a04000 mov r4, r0
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
30021f00: e59030fc ldr r3, [r0, #252] ; 0xfc 30021f04: e1a06615 lsl r6, r5, r6
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
30021f08: 0a000017 beq 30021f6c <_POSIX_signals_Unblock_thread+0x90>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
30021f0c: e59330d0 ldr r3, [r3, #208] ; 0xd0 30021f10: e1d66003 bics r6, r6, r3
30021f14: 0a000012 beq 30021f64 <_POSIX_signals_Unblock_thread+0x88>
* 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 ) ) {
30021f18: e21c6201 ands r6, ip, #268435456 ; 0x10000000
30021f1c: 0a00000e beq 30021f5c <_POSIX_signals_Unblock_thread+0x80>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
30021f20: e59f50d4 ldr r5, [pc, #212] ; 30021ffc <_POSIX_signals_Unblock_thread+0x120>
the_thread->Wait.return_code = EINTR;
30021f24: e3a03004 mov r3, #4 30021f28: e00c5005 and r5, ip, r5
/*
* 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) )
30021f2c: e3550000 cmp r5, #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;
30021f30: 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) )
30021f34: 1a00002c bne 30021fec <_POSIX_signals_Unblock_thread+0x110>
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
30021f38: e21c0008 ands r0, ip, #8
30021f3c: 08bd80f0 popeq {r4, r5, r6, r7, pc}
(void) _Watchdog_Remove( &the_thread->Timer );
30021f40: e2840048 add r0, r4, #72 ; 0x48 30021f44: ebffb093 bl 3000e198 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
30021f48: e1a00004 mov r0, r4 30021f4c: e59f10ac ldr r1, [pc, #172] ; 30022000 <_POSIX_signals_Unblock_thread+0x124> 30021f50: ebffab85 bl 3000cd6c <_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;
30021f54: e1a00005 mov r0, r5
30021f58: 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 ) {
30021f5c: e35c0000 cmp ip, #0
30021f60: 0a000016 beq 30021fc0 <_POSIX_signals_Unblock_thread+0xe4>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
30021f64: e1a00006 mov r0, r6
30021f68: 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) ) {
30021f6c: e5900030 ldr r0, [r0, #48] ; 0x30 30021f70: e1160000 tst r6, r0
30021f74: 0a00000d beq 30021fb0 <_POSIX_signals_Unblock_thread+0xd4>
the_thread->Wait.return_code = EINTR;
30021f78: e3a03004 mov r3, #4 30021f7c: e5843034 str r3, [r4, #52] ; 0x34
the_info = (siginfo_t *) the_thread->Wait.return_argument;
30021f80: e5943028 ldr r3, [r4, #40] ; 0x28
if ( !info ) {
30021f84: e3520000 cmp r2, #0
the_info->si_signo = signo;
30021f88: 05831000 streq r1, [r3]
the_info->si_code = SI_USER;
30021f8c: 03a01001 moveq r1, #1
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
30021f90: 18920007 ldmne r2, {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;
30021f94: 05831004 streq r1, [r3, #4]
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
30021f98: 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;
the_info->si_value.sival_int = 0;
30021f9c: 05832008 streq r2, [r3, #8]
} else {
*the_info = *info;
}
_Thread_queue_Extract_with_proxy( the_thread );
30021fa0: e1a00004 mov r0, r4 30021fa4: ebffae17 bl 3000d808 <_Thread_queue_Extract_with_proxy>
return true;
30021fa8: e3a00001 mov r0, #1
30021fac: 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) ) {
30021fb0: e59300d0 ldr r0, [r3, #208] ; 0xd0 30021fb4: e1d60000 bics r0, r6, r0
30021fb8: 1affffee bne 30021f78 <_POSIX_signals_Unblock_thread+0x9c>
30021fbc: 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 ) )
30021fc0: e59f203c ldr r2, [pc, #60] ; 30022004 <_POSIX_signals_Unblock_thread+0x128>
30021fc4: e5920000 ldr r0, [r2]
30021fc8: e3500000 cmp r0, #0
30021fcc: 08bd80f0 popeq {r4, r5, r6, r7, pc}
30021fd0: e5923004 ldr r3, [r2, #4]
30021fd4: e1540003 cmp r4, r3
_Thread_Dispatch_necessary = true;
30021fd8: 05c25010 strbeq r5, [r2, #16]
}
}
return false;
30021fdc: 01a0000c moveq r0, ip
(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 ) )
30021fe0: 08bd80f0 popeq {r4, r5, r6, r7, pc}
_Thread_Dispatch_necessary = true;
}
}
return false;
30021fe4: e1a0000c mov r0, ip <== NOT EXECUTED
}
30021fe8: 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 );
30021fec: ebffae05 bl 3000d808 <_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;
30021ff0: e3a00000 mov r0, #0
30021ff4: e8bd80f0 pop {r4, r5, r6, r7, pc}
300066c8 <_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();
300066c8: e59f30b0 ldr r3, [pc, #176] ; 30006780 <_TOD_Validate+0xb8>
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
300066cc: 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) ||
300066d0: 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();
300066d4: 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;
300066d8: 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) ||
300066dc: 08bd8010 popeq {r4, pc}
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
300066e0: e59f009c ldr r0, [pc, #156] ; 30006784 <_TOD_Validate+0xbc> 300066e4: eb0048c5 bl 30018a00 <__aeabi_uidiv>
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
300066e8: e5943018 ldr r3, [r4, #24] 300066ec: e1500003 cmp r0, r3
300066f0: 9a00001e bls 30006770 <_TOD_Validate+0xa8>
(the_tod->ticks >= ticks_per_second) ||
300066f4: e5943014 ldr r3, [r4, #20] 300066f8: e353003b cmp r3, #59 ; 0x3b
300066fc: 8a00001b bhi 30006770 <_TOD_Validate+0xa8>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
30006700: e5943010 ldr r3, [r4, #16] 30006704: e353003b cmp r3, #59 ; 0x3b
30006708: 8a000018 bhi 30006770 <_TOD_Validate+0xa8>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
3000670c: e594300c ldr r3, [r4, #12] 30006710: e3530017 cmp r3, #23
30006714: 8a000015 bhi 30006770 <_TOD_Validate+0xa8>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
30006718: 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) ||
3000671c: e3500000 cmp r0, #0
30006720: 08bd8010 popeq {r4, pc}
(the_tod->month == 0) ||
30006724: e350000c cmp r0, #12
30006728: 8a000010 bhi 30006770 <_TOD_Validate+0xa8>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
3000672c: e5943000 ldr r3, [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) ||
30006730: e59f2050 ldr r2, [pc, #80] ; 30006788 <_TOD_Validate+0xc0> 30006734: e1530002 cmp r3, r2
30006738: 9a00000c bls 30006770 <_TOD_Validate+0xa8>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
3000673c: 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) ||
30006740: e3540000 cmp r4, #0
30006744: 0a00000b beq 30006778 <_TOD_Validate+0xb0>
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
30006748: e3130003 tst r3, #3
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
3000674c: 059f3038 ldreq r3, [pc, #56] ; 3000678c <_TOD_Validate+0xc4>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
30006750: 159f3034 ldrne r3, [pc, #52] ; 3000678c <_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 ];
30006754: 0280000d addeq r0, r0, #13 30006758: 07930100 ldreq r0, [r3, r0, lsl #2]
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
3000675c: 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(
30006760: e1500004 cmp r0, r4
30006764: 33a00000 movcc r0, #0
30006768: 23a00001 movcs r0, #1
3000676c: 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;
30006770: e3a00000 mov r0, #0
30006774: e8bd8010 pop {r4, pc}
30006778: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( the_tod->day > days_in_month )
return false;
return true;
}
3000677c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30008044 <_Thread_queue_Enqueue_priority>:
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
30008044: 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
)
{
30008048: e92d07f0 push {r4, r5, r6, r7, r8, r9, 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 );
3000804c: e281403c add r4, r1, #60 ; 0x3c
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
30008050: e281c038 add ip, r1, #56 ; 0x38
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
30008054: 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 ) )
30008058: e3130020 tst r3, #32
head->previous = NULL;
3000805c: e3a04000 mov r4, #0 30008060: e581403c str r4, [r1, #60] ; 0x3c
tail->previous = head;
30008064: 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);
30008068: e1a0a323 lsr sl, 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;
3000806c: e5905038 ldr r5, [r0, #56] ; 0x38
if ( _Thread_queue_Is_reverse_search( priority ) )
30008070: 1a00001f bne 300080f4 <_Thread_queue_Enqueue_priority+0xb0>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
30008074: e08aa08a add sl, sl, sl, lsl #1 30008078: e1a0910a lsl r9, sl, #2
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
3000807c: e289a004 add sl, r9, #4 30008080: e080a00a add sl, r0, sl 30008084: e0809009 add r9, r0, r9
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30008088: e10f7000 mrs r7, CPSR 3000808c: e387c080 orr ip, r7, #128 ; 0x80 30008090: e129f00c msr CPSR_fc, ip 30008094: e1a08007 mov r8, r7 30008098: e599c000 ldr ip, [r9]
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 ) ) {
3000809c: e15c000a cmp ip, sl
300080a0: 1a000009 bne 300080cc <_Thread_queue_Enqueue_priority+0x88>
300080a4: ea000052 b 300081f4 <_Thread_queue_Enqueue_priority+0x1b0>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
300080a8: e10f6000 mrs r6, CPSR 300080ac: e129f007 msr CPSR_fc, r7 300080b0: 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);
300080b4: 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) ) {
300080b8: e1150006 tst r5, r6
300080bc: 0a000035 beq 30008198 <_Thread_queue_Enqueue_priority+0x154>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
300080c0: 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 ) ) {
300080c4: e15c000a cmp ip, sl
300080c8: 0a000002 beq 300080d8 <_Thread_queue_Enqueue_priority+0x94>
search_priority = search_thread->current_priority;
300080cc: e59c4014 ldr r4, [ip, #20]
if ( priority <= search_priority )
300080d0: e1530004 cmp r3, r4
300080d4: 8afffff3 bhi 300080a8 <_Thread_queue_Enqueue_priority+0x64>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
300080d8: e5905030 ldr r5, [r0, #48] ; 0x30 300080dc: e3550001 cmp r5, #1
300080e0: 0a00002e beq 300081a0 <_Thread_queue_Enqueue_priority+0x15c> * 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;
300080e4: e5828000 str r8, [r2]
return the_thread_queue->sync_state; }
300080e8: e1a00005 mov r0, r5
300080ec: e8bd07f0 pop {r4, r5, r6, r7, r8, r9, sl}
300080f0: e12fff1e bx lr
300080f4: e08aa08a add sl, sl, sl, lsl #1
300080f8: e59f90fc ldr r9, [pc, #252] ; 300081fc <_Thread_queue_Enqueue_priority+0x1b8>
300080fc: e080a10a add sl, r0, sl, 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;
30008100: e5d94000 ldrb r4, [r9] 30008104: e2844001 add r4, r4, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30008108: e10f7000 mrs r7, CPSR 3000810c: e387c080 orr ip, r7, #128 ; 0x80 30008110: e129f00c msr CPSR_fc, ip 30008114: e1a08007 mov r8, r7
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
30008118: e59ac008 ldr ip, [sl, #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 ) ) {
3000811c: e15c000a cmp ip, sl
30008120: 1a000009 bne 3000814c <_Thread_queue_Enqueue_priority+0x108>
30008124: ea00000b b 30008158 <_Thread_queue_Enqueue_priority+0x114>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
30008128: e10f6000 mrs r6, CPSR 3000812c: e129f007 msr CPSR_fc, r7 30008130: e129f006 msr CPSR_fc, r6 30008134: 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) ) {
30008138: e1150006 tst r5, r6
3000813c: 0a000013 beq 30008190 <_Thread_queue_Enqueue_priority+0x14c>
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
30008140: 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 ) ) {
30008144: e15c000a cmp ip, sl
30008148: 0a000002 beq 30008158 <_Thread_queue_Enqueue_priority+0x114>
search_priority = search_thread->current_priority;
3000814c: e59c4014 ldr r4, [ip, #20]
if ( priority >= search_priority )
30008150: e1530004 cmp r3, r4
30008154: 3afffff3 bcc 30008128 <_Thread_queue_Enqueue_priority+0xe4>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
30008158: e5905030 ldr r5, [r0, #48] ; 0x30 3000815c: e3550001 cmp r5, #1
30008160: 1affffdf bne 300080e4 <_Thread_queue_Enqueue_priority+0xa0>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
30008164: 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;
30008168: e3a03000 mov r3, #0 3000816c: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
30008170: 0a000016 beq 300081d0 <_Thread_queue_Enqueue_priority+0x18c>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
30008174: e59c3000 ldr r3, [ip]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
30008178: e8811008 stm r1, {r3, ip}
search_node->next = the_node; next_node->previous = the_node;
3000817c: 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;
30008180: e58c1000 str r1, [ip]
next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
30008184: e5810044 str r0, [r1, #68] ; 0x44
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
30008188: e129f007 msr CPSR_fc, r7
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000818c: eaffffd5 b 300080e8 <_Thread_queue_Enqueue_priority+0xa4>
30008190: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED 30008194: eaffffd9 b 30008100 <_Thread_queue_Enqueue_priority+0xbc> <== NOT EXECUTED
30008198: e129f007 msr CPSR_fc, r7 3000819c: eaffffb9 b 30008088 <_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 )
300081a0: 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;
300081a4: e3a03000 mov r3, #0 300081a8: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
300081ac: 0a000007 beq 300081d0 <_Thread_queue_Enqueue_priority+0x18c>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
300081b0: e59c3004 ldr r3, [ip, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
300081b4: e581c000 str ip, [r1]
the_node->previous = previous_node;
300081b8: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
300081bc: e5831000 str r1, [r3]
search_node->previous = the_node;
300081c0: e58c1004 str r1, [ip, #4]
the_thread->Wait.queue = the_thread_queue;
300081c4: e5810044 str r0, [r1, #68] ; 0x44 300081c8: e129f007 msr CPSR_fc, r7
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
300081cc: eaffffc5 b 300080e8 <_Thread_queue_Enqueue_priority+0xa4>
_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;
300081d0: 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 );
300081d4: e28c203c add r2, ip, #60 ; 0x3c
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
300081d8: e881000c stm r1, {r2, r3}
the_node->previous = previous_node; previous_node->next = the_node;
300081dc: e5831000 str r1, [r3]
search_node->previous = the_node;
300081e0: e58c1040 str r1, [ip, #64] ; 0x40
the_thread->Wait.queue = the_thread_queue;
300081e4: e5810044 str r0, [r1, #68] ; 0x44 300081e8: e129f008 msr CPSR_fc, r8
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
300081ec: e3a05001 mov r5, #1 300081f0: eaffffbc b 300080e8 <_Thread_queue_Enqueue_priority+0xa4>
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
300081f4: e3e04000 mvn r4, #0 300081f8: eaffffb6 b 300080d8 <_Thread_queue_Enqueue_priority+0x94>
30008850 <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
30008850: e92d41f0 push {r4, r5, r6, r7, r8, lr}
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
30008854: e59f5040 ldr r5, [pc, #64] ; 3000889c <_User_extensions_Fatal+0x4c>
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
30008858: e1a08000 mov r8, r0
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
3000885c: e5954008 ldr r4, [r5, #8]
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
30008860: e1a07002 mov r7, r2
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
30008864: e1540005 cmp r4, r5
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
30008868: e20160ff and r6, r1, #255 ; 0xff
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
3000886c: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
30008870: e5943030 ldr r3, [r4, #48] ; 0x30
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
30008874: e1a00008 mov r0, r8
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
30008878: e3530000 cmp r3, #0
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
3000887c: e1a01006 mov r1, r6 30008880: e1a02007 mov r2, r7 30008884: 11a0e00f movne lr, pc 30008888: 112fff13 bxne r3
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
3000888c: e5944004 ldr r4, [r4, #4]
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
30008890: e1540005 cmp r4, r5
30008894: 1afffff5 bne 30008870 <_User_extensions_Fatal+0x20>
30008898: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
300088a0 <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
300088a0: e92d40f0 push {r4, r5, r6, r7, lr}
return false;
}
}
return true;
}
300088a4: e59f5050 ldr r5, [pc, #80] ; 300088fc <_User_extensions_Thread_create+0x5c>
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
300088a8: e1a06000 mov r6, r0
return false;
}
}
return true;
}
300088ac: e4954004 ldr r4, [r5], #4
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
300088b0: e1540005 cmp r4, r5
300088b4: 0a00000e beq 300088f4 <_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)(
300088b8: e59f7040 ldr r7, [pc, #64] ; 30008900 <_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 ) {
300088bc: e5943014 ldr r3, [r4, #20]
status = (*the_extension->Callouts.thread_create)(
300088c0: 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 ) {
300088c4: e3530000 cmp r3, #0
300088c8: 0a000004 beq 300088e0 <_User_extensions_Thread_create+0x40>
status = (*the_extension->Callouts.thread_create)(
300088cc: e5970004 ldr r0, [r7, #4] 300088d0: e1a0e00f mov lr, pc 300088d4: e12fff13 bx r3
_Thread_Executing,
the_thread
);
if ( !status )
300088d8: e3500000 cmp r0, #0
300088dc: 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 ) {
300088e0: e5944000 ldr r4, [r4]
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
300088e4: e1540005 cmp r4, r5
300088e8: 1afffff3 bne 300088bc <_User_extensions_Thread_create+0x1c>
if ( !status )
return false;
}
}
return true;
300088ec: e3a00001 mov r0, #1
300088f0: e8bd80f0 pop {r4, r5, r6, r7, pc}
300088f4: e3a00001 mov r0, #1 <== NOT EXECUTED
}
300088f8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000a6f8 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
3000a6f8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
3000a6fc: e1a04000 mov r4, r0
3000a700: e1a05002 mov r5, r2
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
3000a704: e10f3000 mrs r3, CPSR 3000a708: e3832080 orr r2, r3, #128 ; 0x80 3000a70c: e129f002 msr CPSR_fc, r2
}
}
_ISR_Enable( level );
}
3000a710: e1a07000 mov r7, r0 3000a714: e4972004 ldr r2, [r7], #4
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
3000a718: e1520007 cmp r2, r7
3000a71c: 0a000018 beq 3000a784 <_Watchdog_Adjust+0x8c>
switch ( direction ) {
3000a720: e3510000 cmp r1, #0
3000a724: 1a000018 bne 3000a78c <_Watchdog_Adjust+0x94>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
3000a728: e3550000 cmp r5, #0
3000a72c: 0a000014 beq 3000a784 <_Watchdog_Adjust+0x8c>
if ( units < _Watchdog_First( header )->delta_interval ) {
3000a730: e5926010 ldr r6, [r2, #16] 3000a734: e1550006 cmp r5, r6
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000a738: 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 ) {
3000a73c: 2a000005 bcs 3000a758 <_Watchdog_Adjust+0x60>
3000a740: ea000018 b 3000a7a8 <_Watchdog_Adjust+0xb0> <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
3000a744: e0555006 subs r5, r5, r6
3000a748: 0a00000d beq 3000a784 <_Watchdog_Adjust+0x8c>
if ( units < _Watchdog_First( header )->delta_interval ) {
3000a74c: e5926010 ldr r6, [r2, #16] 3000a750: e1560005 cmp r6, r5
3000a754: 8a000013 bhi 3000a7a8 <_Watchdog_Adjust+0xb0>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000a758: e5828010 str r8, [r2, #16]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3000a75c: e129f003 msr CPSR_fc, r3
_ISR_Enable( level );
_Watchdog_Tickle( header );
3000a760: e1a00004 mov r0, r4 3000a764: eb0000aa bl 3000aa14 <_Watchdog_Tickle>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
3000a768: e10f3000 mrs r3, CPSR 3000a76c: e3832080 orr r2, r3, #128 ; 0x80 3000a770: e129f002 msr CPSR_fc, r2
}
}
_ISR_Enable( level );
}
3000a774: e5941000 ldr r1, [r4]
_Watchdog_Tickle( header );
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000a778: e1570001 cmp r7, r1
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
3000a77c: e1a02001 mov r2, r1
3000a780: 1affffef bne 3000a744 <_Watchdog_Adjust+0x4c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3000a784: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
3000a788: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
3000a78c: e3510001 cmp r1, #1
3000a790: 1afffffb bne 3000a784 <_Watchdog_Adjust+0x8c>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
3000a794: e5921010 ldr r1, [r2, #16] 3000a798: e0815005 add r5, r1, r5 3000a79c: e5825010 str r5, [r2, #16] 3000a7a0: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
3000a7a4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
_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;
3000a7a8: e0655006 rsb r5, r5, r6 3000a7ac: e5825010 str r5, [r2, #16]
break;
3000a7b0: eafffff3 b 3000a784 <_Watchdog_Adjust+0x8c>
3000665c <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
3000665c: 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 );
30006660: e1a00001 mov r0, r1
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
30006664: e24dd048 sub sp, sp, #72 ; 0x48 30006668: e1a05001 mov r5, r1 3000666c: 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 );
30006670: ebfffa34 bl 30004f48 <rtems_filesystem_dirname>
if ( old_parent_pathlen == 0 )
30006674: e2507000 subs r7, r0, #0
30006678: 1a000059 bne 300067e4 <_rename_r+0x188>
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
3000667c: e28d4018 add r4, sp, #24 30006680: e1a00005 mov r0, r5 30006684: e28d1044 add r1, sp, #68 ; 0x44 30006688: e1a02004 mov r2, r4 3000668c: eb0000e8 bl 30006a34 <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;
30006690: e1a08007 mov r8, r7
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
30006694: e28dc02c add ip, sp, #44 ; 0x2c
30006698: e1a0e004 mov lr, r4
3000669c: e8be000f ldm lr!, {r0, r1, r2, r3}
300066a0: e8ac000f stmia ip!, {r0, r1, r2, r3}
300066a4: e59e3000 ldr r3, [lr]
name = old + old_parent_pathlen;
300066a8: e0855007 add r5, r5, r7
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
300066ac: e58c3000 str r3, [ip]
name = old + old_parent_pathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
300066b0: 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;
300066b4: e58d5040 str r5, [sp, #64] ; 0x40
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
300066b8: eb0039ab bl 30014d6c <strlen> 300066bc: e1a01000 mov r1, r0 300066c0: e1a00005 mov r0, r5 300066c4: ebfffa2e bl 30004f84 <rtems_filesystem_prefix_separators> 300066c8: e0855000 add r5, r5, r0
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
300066cc: 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 ) );
300066d0: e58d5040 str r5, [sp, #64] ; 0x40
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
300066d4: eb0039a4 bl 30014d6c <strlen> 300066d8: e28d702c add r7, sp, #44 ; 0x2c 300066dc: e1a01000 mov r1, r0 300066e0: e3a02000 mov r2, #0 300066e4: e1a00005 mov r0, r5 300066e8: e1a03007 mov r3, r7 300066ec: e58d2000 str r2, [sp] 300066f0: ebfff9e2 bl 30004e80 <rtems_filesystem_evaluate_relative_path>
0, &old_loc, false );
if ( result != 0 ) {
300066f4: e3500000 cmp r0, #0
300066f8: 1a000031 bne 300067c4 <_rename_r+0x168>
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
300066fc: e28d5004 add r5, sp, #4 30006700: e1a00006 mov r0, r6 30006704: e1a02005 mov r2, r5 30006708: e28d1044 add r1, sp, #68 ; 0x44 3000670c: eb0000c8 bl 30006a34 <rtems_filesystem_get_start_loc>
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
30006710: e59d0044 ldr r0, [sp, #68] ; 0x44 30006714: e1a01005 mov r1, r5 30006718: e0860000 add r0, r6, r0 3000671c: e28d2040 add r2, sp, #64 ; 0x40 30006720: e59d3010 ldr r3, [sp, #16] 30006724: e1a0e00f mov lr, pc 30006728: e593f004 ldr pc, [r3, #4]
if ( result != 0 ) {
3000672c: e3500000 cmp r0, #0
30006730: 1a000037 bne 30006814 <_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 ) {
30006734: e59d3014 ldr r3, [sp, #20] 30006738: e59d2028 ldr r2, [sp, #40] ; 0x28 3000673c: e1520003 cmp r2, r3
30006740: 1a000013 bne 30006794 <_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 );
30006744: e1a01007 mov r1, r7 30006748: e1a02005 mov r2, r5 3000674c: e59d3040 ldr r3, [sp, #64] ; 0x40 30006750: e59dc010 ldr ip, [sp, #16] 30006754: e1a00004 mov r0, r4 30006758: e1a0e00f mov lr, pc 3000675c: e59cf040 ldr pc, [ip, #64] ; 0x40 30006760: e1a06000 mov r6, r0
rtems_filesystem_freenode( &new_parent_loc );
30006764: e1a00005 mov r0, r5 30006768: ebfffa98 bl 300051d0 <rtems_filesystem_freenode>
if ( free_old_parentloc )
3000676c: e3580000 cmp r8, #0
30006770: 1a000004 bne 30006788 <_rename_r+0x12c>
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
30006774: e1a00007 mov r0, r7 30006778: ebfffa94 bl 300051d0 <rtems_filesystem_freenode>
return result;
}
3000677c: e1a00006 mov r0, r6
30006780: e28dd048 add sp, sp, #72 ; 0x48
30006784: 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 );
30006788: e1a00004 mov r0, r4 3000678c: ebfffa8f bl 300051d0 <rtems_filesystem_freenode> 30006790: eafffff7 b 30006774 <_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 );
30006794: e1a00005 mov r0, r5 30006798: ebfffa8c bl 300051d0 <rtems_filesystem_freenode>
if ( free_old_parentloc )
3000679c: e3580000 cmp r8, #0
rtems_filesystem_freenode( &old_parent_loc );
300067a0: 11a00004 movne r0, r4 300067a4: 1bfffa89 blne 300051d0 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &old_loc );
300067a8: e1a00007 mov r0, r7 300067ac: ebfffa87 bl 300051d0 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
300067b0: eb002c6a bl 30011960 <__errno> 300067b4: e3a03012 mov r3, #18 300067b8: e5803000 str r3, [r0] 300067bc: e3e06000 mvn r6, #0 300067c0: eaffffed b 3000677c <_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 )
300067c4: e3580000 cmp r8, #0
300067c8: 1a000001 bne 300067d4 <_rename_r+0x178>
rtems_filesystem_freenode( &old_parent_loc );
return -1;
300067cc: e3e06000 mvn r6, #0
300067d0: eaffffe9 b 3000677c <_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 );
300067d4: e1a00004 mov r0, r4 300067d8: ebfffa7c bl 300051d0 <rtems_filesystem_freenode>
return -1;
300067dc: e3e06000 mvn r6, #0 300067e0: eaffffe5 b 3000677c <_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,
300067e4: e3a03000 mov r3, #0 300067e8: e28d4018 add r4, sp, #24 300067ec: e58d3000 str r3, [sp] 300067f0: e3a02002 mov r2, #2 300067f4: e1a00005 mov r0, r5 300067f8: e1a01007 mov r1, r7 300067fc: e1a03004 mov r3, r4 30006800: ebfff9ba bl 30004ef0 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
30006804: e3500000 cmp r0, #0
30006808: 1affffef bne 300067cc <_rename_r+0x170>
return -1;
free_old_parentloc = true;
3000680c: e3a08001 mov r8, #1 30006810: eaffff9f b 30006694 <_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 );
30006814: e1a00005 mov r0, r5 30006818: ebfffa6c bl 300051d0 <rtems_filesystem_freenode>
if ( free_old_parentloc )
3000681c: e3580000 cmp r8, #0
rtems_filesystem_freenode( &old_parent_loc );
30006820: 11a00004 movne r0, r4 30006824: 1bfffa69 blne 300051d0 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &old_loc );
30006828: e1a00007 mov r0, r7 3000682c: ebfffa67 bl 300051d0 <rtems_filesystem_freenode>
return -1;
30006830: e3e06000 mvn r6, #0 30006834: eaffffd0 b 3000677c <_rename_r+0x120>
30006164 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
30006164: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
30006168: e59f41b4 ldr r4, [pc, #436] ; 30006324 <aio_cancel+0x1c0>
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
3000616c: e1a05001 mov r5, r1 30006170: e1a07000 mov r7, r0
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
30006174: e1a00004 mov r0, r4 30006178: eb000441 bl 30007284 <pthread_mutex_lock>
if (aiocbp == NULL)
3000617c: e3550000 cmp r5, #0
30006180: 0a00002d beq 3000623c <aio_cancel+0xd8>
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
}
else
{
if (aiocbp->aio_fildes != fildes) {
30006184: e5956000 ldr r6, [r5] 30006188: e1560007 cmp r6, r7
3000618c: 1a000023 bne 30006220 <aio_cancel+0xbc>
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
30006190: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 30006194: e1a01006 mov r1, r6 <== NOT EXECUTED 30006198: e3a02000 mov r2, #0 <== NOT EXECUTED 3000619c: eb0000c2 bl 300064ac <rtems_aio_search_fd> <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
300061a0: e2507000 subs r7, r0, #0 <== NOT EXECUTED 300061a4: 0a00000c beq 300061dc <aio_cancel+0x78> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
pthread_mutex_lock (&r_chain->mutex);
300061a8: e287401c add r4, r7, #28 <== NOT EXECUTED 300061ac: e1a00004 mov r0, r4 <== NOT EXECUTED 300061b0: eb000433 bl 30007284 <pthread_mutex_lock> <== NOT EXECUTED
result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp);
300061b4: e1a01005 mov r1, r5 <== NOT EXECUTED 300061b8: e1a00007 mov r0, r7 <== NOT EXECUTED 300061bc: eb0001bb bl 300068b0 <rtems_aio_remove_req> <== NOT EXECUTED 300061c0: e1a05000 mov r5, r0 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
300061c4: e1a00004 mov r0, r4 <== NOT EXECUTED 300061c8: eb00044e bl 30007308 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
300061cc: e59f0150 ldr r0, [pc, #336] ; 30006324 <aio_cancel+0x1c0> <== NOT EXECUTED 300061d0: eb00044c bl 30007308 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
}
return AIO_ALLDONE;
}
300061d4: e1a00005 mov r0, r5
300061d8: e8bd80f0 pop {r4, r5, r6, r7, pc}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
fildes,
0);
if (r_chain == NULL)
if (!rtems_chain_is_empty (&aio_request_queue.idle_req))
300061dc: e5942054 ldr r2, [r4, #84] ; 0x54
300061e0: e2843058 add r3, r4, #88 ; 0x58 <== NOT EXECUTED 300061e4: e1520003 cmp r2, r3 <== NOT EXECUTED 300061e8: 0affffee beq 300061a8 <aio_cancel+0x44> <== NOT EXECUTED
{
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
300061ec: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED 300061f0: e1a01006 mov r1, r6 <== NOT EXECUTED 300061f4: e1a02007 mov r2, r7 <== NOT EXECUTED 300061f8: eb0000ab bl 300064ac <rtems_aio_search_fd> <== NOT EXECUTED
fildes, 0); if (r_chain == NULL)
300061fc: e3500000 cmp r0, #0 <== NOT EXECUTED 30006200: 0a000006 beq 30006220 <aio_cancel+0xbc> <== NOT EXECUTED
{
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp);
30006204: e1a01005 mov r1, r5 <== NOT EXECUTED 30006208: eb0001a8 bl 300068b0 <rtems_aio_remove_req> <== NOT EXECUTED 3000620c: e1a05000 mov r5, r0 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
30006210: e1a00004 mov r0, r4 <== NOT EXECUTED 30006214: eb00043b bl 30007308 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
}
return AIO_ALLDONE;
}
30006218: e1a00005 mov r0, r5 <== NOT EXECUTED
3000621c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
fildes,
0);
if (r_chain == NULL)
{
pthread_mutex_unlock (&aio_request_queue.mutex);
30006220: e1a00004 mov r0, r4 30006224: eb000437 bl 30007308 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
30006228: eb002981 bl 30010834 <__errno> 3000622c: e3a03016 mov r3, #22 30006230: e5803000 str r3, [r0] 30006234: e3e05000 mvn r5, #0 30006238: eaffffe5 b 300061d4 <aio_cancel+0x70>
pthread_mutex_lock (&aio_request_queue.mutex);
if (aiocbp == NULL)
{
if (fcntl (fildes, F_GETFL) < 0) {
3000623c: e1a00007 mov r0, r7 30006240: e3a01003 mov r1, #3 30006244: eb001b65 bl 3000cfe0 <fcntl> 30006248: e3500000 cmp r0, #0
3000624c: ba00002d blt 30006308 <aio_cancel+0x1a4>
pthread_mutex_unlock(&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EBADF);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
30006250: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 30006254: e1a01007 mov r1, r7 <== NOT EXECUTED 30006258: e1a02005 mov r2, r5 <== NOT EXECUTED 3000625c: eb000092 bl 300064ac <rtems_aio_search_fd> <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
30006260: e2506000 subs r6, r0, #0 <== NOT EXECUTED 30006264: 0a00000b beq 30006298 <aio_cancel+0x134> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_ALLDONE;
}
pthread_mutex_lock (&r_chain->mutex);
30006268: e286701c add r7, r6, #28 <== NOT EXECUTED 3000626c: e1a00007 mov r0, r7 <== NOT EXECUTED 30006270: eb000403 bl 30007284 <pthread_mutex_lock> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
30006274: e1a00006 mov r0, r6 <== NOT EXECUTED 30006278: eb000a6e bl 30008c38 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
3000627c: e1a00006 mov r0, r6 <== NOT EXECUTED 30006280: eb000174 bl 30006858 <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
30006284: e1a00007 mov r0, r7 <== NOT EXECUTED 30006288: eb00041e bl 30007308 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000628c: e1a00004 mov r0, r4 <== NOT EXECUTED 30006290: eb00041c bl 30007308 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
30006294: eaffffce b 300061d4 <aio_cancel+0x70> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
fildes,
0);
if (r_chain == NULL)
{
if (!rtems_chain_is_empty (&aio_request_queue.idle_req))
30006298: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED 3000629c: e2843058 add r3, r4, #88 ; 0x58 <== NOT EXECUTED 300062a0: e1520003 cmp r2, r3 <== NOT EXECUTED 300062a4: 0a000013 beq 300062f8 <aio_cancel+0x194> <== NOT EXECUTED
{
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
300062a8: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED 300062ac: e1a01007 mov r1, r7 <== NOT EXECUTED 300062b0: e1a02006 mov r2, r6 <== NOT EXECUTED 300062b4: eb00007c bl 300064ac <rtems_aio_search_fd> <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL) {
300062b8: e2505000 subs r5, r0, #0 <== NOT EXECUTED 300062bc: 0a00000d beq 300062f8 <aio_cancel+0x194> <== NOT EXECUTED
return AIO_ALLDONE;
}
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
pthread_mutex_destroy (&r_chain->mutex);
300062c0: e285701c add r7, r5, #28 <== NOT EXECUTED 300062c4: eb000a5b bl 30008c38 <_Chain_Extract> <== NOT EXECUTED
pthread_mutex_unlock(&aio_request_queue.mutex);
return AIO_ALLDONE;
}
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
300062c8: e1a00005 mov r0, r5 <== NOT EXECUTED 300062cc: eb000161 bl 30006858 <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_destroy (&r_chain->mutex);
300062d0: e1a00007 mov r0, r7 <== NOT EXECUTED 300062d4: eb000347 bl 30006ff8 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->mutex);
300062d8: e1a00007 mov r0, r7 <== NOT EXECUTED 300062dc: eb00026f bl 30006ca0 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
300062e0: e1a00005 mov r0, r5 <== NOT EXECUTED 300062e4: ebfff293 bl 30002d38 <free> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
300062e8: e1a00004 mov r0, r4 <== NOT EXECUTED 300062ec: eb000405 bl 30007308 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
300062f0: e1a05006 mov r5, r6 <== NOT EXECUTED 300062f4: eaffffb6 b 300061d4 <aio_cancel+0x70> <== NOT EXECUTED
}
pthread_mutex_unlock (&aio_request_queue.mutex);
300062f8: e1a00004 mov r0, r4 <== NOT EXECUTED 300062fc: eb000401 bl 30007308 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
30006300: e3a05002 mov r5, #2 <== NOT EXECUTED 30006304: eaffffb2 b 300061d4 <aio_cancel+0x70> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
if (aiocbp == NULL)
{
if (fcntl (fildes, F_GETFL) < 0) {
pthread_mutex_unlock(&aio_request_queue.mutex);
30006308: e1a00004 mov r0, r4 3000630c: eb0003fd bl 30007308 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
30006310: eb002947 bl 30010834 <__errno> 30006314: e3a03009 mov r3, #9 30006318: e5803000 str r3, [r0] 3000631c: e3e05000 mvn r5, #0 30006320: eaffffab b 300061d4 <aio_cancel+0x70>
30006330 <aio_fsync>:
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
30006330: e3500a02 cmp r0, #8192 ; 0x2000
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
30006334: e92d4030 push {r4, r5, lr}
30006338: e1a04001 mov r4, r1
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
3000633c: 13a05016 movne r5, #22
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
30006340: 1a000011 bne 3000638c <aio_fsync+0x5c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
30006344: e5910000 ldr r0, [r1] 30006348: e3a01003 mov r1, #3 3000634c: eb001b23 bl 3000cfe0 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
30006350: e2000003 and r0, r0, #3 30006354: e2400001 sub r0, r0, #1 30006358: e3500001 cmp r0, #1
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
3000635c: 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)))
30006360: 8a000009 bhi 3000638c <aio_fsync+0x5c>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
30006364: e3a00018 mov r0, #24
30006368: ebfff411 bl 300033b4 <malloc> <== NOT EXECUTED
if (req == NULL)
3000636c: e2503000 subs r3, r0, #0 <== NOT EXECUTED 30006370: 0a000004 beq 30006388 <aio_fsync+0x58> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
30006374: e5834014 str r4, [r3, #20] <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_SYNC;
30006378: e3a03003 mov r3, #3 <== NOT EXECUTED 3000637c: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return rtems_aio_enqueue (req);
}
30006380: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
30006384: ea000162 b 30006914 <rtems_aio_enqueue> <== NOT EXECUTED
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);
30006388: e3a0500b mov r5, #11 <== NOT EXECUTED
3000638c: e3e03000 mvn r3, #0 30006390: e5845030 str r5, [r4, #48] ; 0x30 30006394: e5843034 str r3, [r4, #52] ; 0x34 30006398: eb002925 bl 30010834 <__errno> 3000639c: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
300063a0: e3e00000 mvn r0, #0
300063a4: e8bd8030 pop {r4, r5, pc}
30006af8 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
30006af8: e92d4030 push {r4, r5, lr}
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
30006afc: e3a01003 mov r1, #3
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
30006b00: e1a04000 mov r4, r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
30006b04: e5900000 ldr r0, [r0] 30006b08: eb001934 bl 3000cfe0 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
30006b0c: e2000003 and r0, r0, #3 30006b10: e3500002 cmp r0, #2 30006b14: 13500000 cmpne r0, #0
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
30006b18: 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)))
30006b1c: 1a00000f bne 30006b60 <aio_read+0x68>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
30006b20: e5943014 ldr r3, [r4, #20] 30006b24: e3530000 cmp r3, #0
30006b28: 1a000013 bne 30006b7c <aio_read+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
30006b2c: e5943008 ldr r3, [r4, #8] 30006b30: e3530000 cmp r3, #0
30006b34: ba000010 blt 30006b7c <aio_read+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
30006b38: e3a00018 mov r0, #24 30006b3c: ebfff21c bl 300033b4 <malloc>
if (req == NULL)
30006b40: e2503000 subs r3, r0, #0
30006b44: 0a000004 beq 30006b5c <aio_read+0x64>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
30006b48: e5834014 str r4, [r3, #20]
req->aiocbp->aio_lio_opcode = LIO_READ;
30006b4c: e3a03001 mov r3, #1 30006b50: e584302c str r3, [r4, #44] ; 0x2c
return rtems_aio_enqueue (req);
}
30006b54: 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);
30006b58: eaffff6d b 30006914 <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);
30006b5c: e3a0500b mov r5, #11 <== NOT EXECUTED
30006b60: e3e03000 mvn r3, #0 30006b64: e5845030 str r5, [r4, #48] ; 0x30 30006b68: e5843034 str r3, [r4, #52] ; 0x34 30006b6c: eb002730 bl 30010834 <__errno> 30006b70: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
30006b74: e3e00000 mvn r0, #0
30006b78: 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);
30006b7c: e3a05016 mov r5, #22 30006b80: eafffff6 b 30006b60 <aio_read+0x68>
30006b8c <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
30006b8c: e92d4030 push {r4, r5, lr}
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
30006b90: e3a01003 mov r1, #3
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
30006b94: e1a04000 mov r4, r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
30006b98: e5900000 ldr r0, [r0] 30006b9c: eb00190f bl 3000cfe0 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
30006ba0: e2000003 and r0, r0, #3 30006ba4: e2400001 sub r0, r0, #1 30006ba8: e3500001 cmp r0, #1
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
30006bac: 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)))
30006bb0: 8a00000f bhi 30006bf4 <aio_write+0x68>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
30006bb4: e5943014 ldr r3, [r4, #20] 30006bb8: e3530000 cmp r3, #0
30006bbc: 1a000013 bne 30006c10 <aio_write+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
30006bc0: e5943008 ldr r3, [r4, #8] 30006bc4: e3530000 cmp r3, #0
30006bc8: ba000010 blt 30006c10 <aio_write+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
30006bcc: e3a00018 mov r0, #24 30006bd0: ebfff1f7 bl 300033b4 <malloc>
if (req == NULL)
30006bd4: e2503000 subs r3, r0, #0
30006bd8: 0a000004 beq 30006bf0 <aio_write+0x64>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
30006bdc: e5834014 str r4, [r3, #20]
req->aiocbp->aio_lio_opcode = LIO_WRITE;
30006be0: e3a03002 mov r3, #2 30006be4: e584302c str r3, [r4, #44] ; 0x2c
return rtems_aio_enqueue (req);
}
30006be8: 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);
30006bec: eaffff48 b 30006914 <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);
30006bf0: e3a0500b mov r5, #11 <== NOT EXECUTED
30006bf4: e3e03000 mvn r3, #0 30006bf8: e5845030 str r5, [r4, #48] ; 0x30 30006bfc: e5843034 str r3, [r4, #52] ; 0x34 30006c00: eb00270b bl 30010834 <__errno> 30006c04: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
30006c08: e3e00000 mvn r0, #0
30006c0c: 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);
30006c10: e3a05016 mov r5, #22 30006c14: eafffff6 b 30006bf4 <aio_write+0x68>
30009158 <devFS_evaluate_path>:
{
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
30009158: e3d22007 bics r2, r2, #7
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
3000915c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30009160: e1a09000 mov r9, r0
30009164: e1a04001 mov r4, r1
30009168: 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 ) )
3000916c: 1a000028 bne 30009214 <devFS_evaluate_path+0xbc>
rtems_set_errno_and_return_minus_one( EPERM );
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
30009170: e5937000 ldr r7, [r3]
if (!device_name_table)
30009174: e3570000 cmp r7, #0
30009178: 0a00002a beq 30009228 <devFS_evaluate_path+0xd0>
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
3000917c: e59f30b8 ldr r3, [pc, #184] ; 3000923c <devFS_evaluate_path+0xe4> 30009180: e5938000 ldr r8, [r3] 30009184: e3580000 cmp r8, #0 30009188: 11a0a002 movne sl, r2 3000918c: 11a0500a movne r5, sl
30009190: 0a000010 beq 300091d8 <devFS_evaluate_path+0x80>
if (!device_name_table[i].device_name)
30009194: e08aa10a add sl, sl, sl, lsl #2 30009198: e797610a ldr r6, [r7, sl, lsl #2]
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
3000919c: e1a00009 mov r0, r9
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)
300091a0: e2561000 subs r1, r6, #0
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
300091a4: 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)
300091a8: e087a10a add sl, r7, sl, lsl #2
300091ac: 0a000005 beq 300091c8 <devFS_evaluate_path+0x70>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
300091b0: eb000df0 bl 3000c978 <strncmp> 300091b4: e3500000 cmp r0, #0
300091b8: 1a000002 bne 300091c8 <devFS_evaluate_path+0x70>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
300091bc: e7d60004 ldrb r0, [r6, r4] 300091c0: e3500000 cmp r0, #0
300091c4: 0a000008 beq 300091ec <devFS_evaluate_path+0x94>
/* 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++) {
300091c8: e2855001 add r5, r5, #1 300091cc: e1580005 cmp r8, r5 300091d0: e1a0a005 mov sl, r5
300091d4: 8affffee bhi 30009194 <devFS_evaluate_path+0x3c>
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
300091d8: eb000a5f bl 3000bb5c <__errno> 300091dc: e3a03002 mov r3, #2 300091e0: e5803000 str r3, [r0] 300091e4: e3e00000 mvn r0, #0
}
300091e8: 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;
300091ec: e59f304c ldr r3, [pc, #76] ; 30009240 <devFS_evaluate_path+0xe8>
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;
300091f0: e59f204c ldr r2, [pc, #76] ; 30009244 <devFS_evaluate_path+0xec>
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
300091f4: 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;
300091f8: e58b2008 str r2, [fp, #8]
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
300091fc: 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;
30009200: e59f2040 ldr r2, [pc, #64] ; 30009248 <devFS_evaluate_path+0xf0>
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
30009204: e58ba000 str sl, [fp]
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
30009208: e58b200c str r2, [fp, #12]
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
3000920c: e58b3010 str r3, [fp, #16]
return 0;
30009210: 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 );
30009214: eb000a50 bl 3000bb5c <__errno> <== NOT EXECUTED
30009218: e3a03001 mov r3, #1 <== NOT EXECUTED
3000921c: e5803000 str r3, [r0] <== NOT EXECUTED
30009220: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009224: 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 );
30009228: eb000a4b bl 3000bb5c <__errno>
3000922c: e3a0300e mov r3, #14
30009230: e5803000 str r3, [r0]
30009234: e3e00000 mvn r0, #0
30009238: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
30002f4c <drainOutput>:
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
30002f4c: e59030b4 ldr r3, [r0, #180] ; 0xb4
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
30002f50: e92d4030 push {r4, r5, lr}
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
30002f54: e3530000 cmp r3, #0
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
30002f58: e1a04000 mov r4, r0
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
30002f5c: 08bd8030 popeq {r4, r5, pc}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30002f60: e10f3000 mrs r3, CPSR 30002f64: e3832080 orr r2, r3, #128 ; 0x80 30002f68: e129f002 msr CPSR_fc, r2
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
30002f6c: e5901084 ldr r1, [r0, #132] ; 0x84 30002f70: e5902080 ldr r2, [r0, #128] ; 0x80 30002f74: e1510002 cmp r1, r2
30002f78: 0a00000f beq 30002fbc <drainOutput+0x70>
tty->rawOutBufState = rob_wait;
30002f7c: e3a05002 mov r5, #2 <== NOT EXECUTED 30002f80: e5845094 str r5, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
30002f84: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
30002f88: e3a01000 mov r1, #0 <== NOT EXECUTED 30002f8c: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED 30002f90: e1a02001 mov r2, r1 <== NOT EXECUTED 30002f94: eb0009bb bl 30005688 <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
30002f98: e3500000 cmp r0, #0 <== NOT EXECUTED 30002f9c: 1a000008 bne 30002fc4 <drainOutput+0x78> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30002fa0: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30002fa4: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30002fa8: 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) {
30002fac: e5941084 ldr r1, [r4, #132] ; 0x84 <== NOT EXECUTED 30002fb0: e5942080 ldr r2, [r4, #128] ; 0x80 <== NOT EXECUTED 30002fb4: e1510002 cmp r1, r2 <== NOT EXECUTED 30002fb8: 1afffff0 bne 30002f80 <drainOutput+0x34> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
30002fbc: e129f003 msr CPSR_fc, r3
30002fc0: 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);
30002fc4: eb000b58 bl 30005d2c <rtems_fatal_error_occurred> <== NOT EXECUTED
30003d44 <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)
30003d44: e5903020 ldr r3, [r0, #32]
* 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)
{
30003d48: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
if (tty->ccount == 0)
30003d4c: 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)
{
30003d50: e1a04000 mov r4, r0 30003d54: e1a06001 mov r6, r1
if (tty->ccount == 0)
30003d58: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return;
if (lineFlag) {
30003d5c: e3510000 cmp r1, #0
30003d60: 0a000010 beq 30003da8 <erase+0x64>
if (!(tty->termios.c_lflag & ECHO)) {
30003d64: e590103c ldr r1, [r0, #60] ; 0x3c 30003d68: e2112008 ands r2, r1, #8
tty->ccount = 0;
30003d6c: 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)) {
30003d70: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
30003d74: e2110010 ands r0, r1, #16
30003d78: 1a00000c bne 30003db0 <erase+0x6c>
tty->ccount = 0;
30003d7c: e5840020 str r0, [r4, #32] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
30003d80: e1a01004 mov r1, r4 <== NOT EXECUTED 30003d84: e5d40044 ldrb r0, [r4, #68] ; 0x44 <== NOT EXECUTED 30003d88: ebffffc8 bl 30003cb0 <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
30003d8c: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
30003d90: e3130020 tst r3, #32 <== NOT EXECUTED
30003d94: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
echo ('\n', tty);
30003d98: e3a0000a mov r0, #10 <== NOT EXECUTED 30003d9c: e1a01004 mov r1, r4 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
30003da0: 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);
30003da4: eaffffc1 b 30003cb0 <echo> <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
30003da8: e590103c ldr r1, [r0, #60] ; 0x3c 30003dac: e2012008 and r2, r1, #8
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
30003db0: e59f7198 ldr r7, [pc, #408] ; 30003f50 <erase+0x20c> 30003db4: ea000008 b 30003ddc <erase+0x98>
30003db8: e3110c02 tst r1, #512 ; 0x200 <== NOT EXECUTED 30003dbc: 1a00004b bne 30003ef0 <erase+0x1ac> <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
30003dc0: e3560000 cmp r6, #0 <== NOT EXECUTED
30003dc4: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
30003dc8: e5943020 ldr r3, [r4, #32] 30003dcc: e3530000 cmp r3, #0
30003dd0: 0a000045 beq 30003eec <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);
30003dd4: e594103c ldr r1, [r4, #60] ; 0x3c 30003dd8: e2012008 and r2, r1, #8
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
30003ddc: e2433001 sub r3, r3, #1 30003de0: e594001c ldr r0, [r4, #28] 30003de4: e5843020 str r3, [r4, #32]
if (tty->termios.c_lflag & ECHO) {
30003de8: e3520000 cmp r2, #0
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
30003dec: e7d05003 ldrb r5, [r0, r3]
if (tty->termios.c_lflag & ECHO) {
30003df0: 0afffff2 beq 30003dc0 <erase+0x7c>
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
30003df4: e3560000 cmp r6, #0
30003df8: 1a000001 bne 30003e04 <erase+0xc0>
30003dfc: e3110010 tst r1, #16
30003e00: 0a000035 beq 30003edc <erase+0x198>
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
30003e04: e3550009 cmp r5, #9
30003e08: 0a00000f beq 30003e4c <erase+0x108>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
30003e0c: e5973000 ldr r3, [r7] 30003e10: e2855001 add r5, r5, #1 30003e14: e7d33005 ldrb r3, [r3, r5] 30003e18: e3130020 tst r3, #32
30003e1c: 1affffe5 bne 30003db8 <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);
30003e20: e59f012c ldr r0, [pc, #300] ; 30003f54 <erase+0x210> 30003e24: e3a01003 mov r1, #3 30003e28: e1a02004 mov r2, r4 30003e2c: ebfffefd bl 30003a28 <rtems_termios_puts>
if (tty->column)
30003e30: e5943028 ldr r3, [r4, #40] ; 0x28 30003e34: e3530000 cmp r3, #0
tty->column--;
30003e38: 12433001 subne r3, r3, #1 30003e3c: 15843028 strne r3, [r4, #40] ; 0x28
}
}
}
if (!lineFlag)
30003e40: e3560000 cmp r6, #0
30003e44: 1affffdf bne 30003dc8 <erase+0x84>
30003e48: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
30003e4c: 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;
30003e50: e594502c ldr r5, [r4, #44] ; 0x2c
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
30003e54: 0a000011 beq 30003ea0 <erase+0x15c>
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
30003e58: 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;
30003e5c: 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)
30003e60: e201ac02 and sl, r1, #512 ; 0x200
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
30003e64: e7d01002 ldrb r1, [r0, r2] 30003e68: e2822001 add r2, r2, #1
if (c == '\t') {
30003e6c: e3510009 cmp r1, #9
col = (col | 7) + 1;
30003e70: 03855007 orreq r5, r5, #7
} else if (iscntrl (c)) {
30003e74: e088c001 add ip, r8, r1
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
30003e78: 02855001 addeq r5, r5, #1
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
30003e7c: 0a000005 beq 30003e98 <erase+0x154>
col = (col | 7) + 1;
} else if (iscntrl (c)) {
30003e80: e5dcc001 ldrb ip, [ip, #1] 30003e84: e31c0020 tst ip, #32
if (tty->termios.c_lflag & ECHOCTL)
col += 2;
} else {
col++;
30003e88: 02855001 addeq r5, r5, #1
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
30003e8c: 0a000001 beq 30003e98 <erase+0x154>
if (tty->termios.c_lflag & ECHOCTL)
30003e90: e35a0000 cmp sl, #0 <== NOT EXECUTED
col += 2;
30003e94: 12855002 addne r5, r5, #2 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
30003e98: e1530002 cmp r3, r2
30003e9c: 1afffff0 bne 30003e64 <erase+0x120>
}
/*
* Back up over the tab
*/
while (tty->column > col) {
30003ea0: e5943028 ldr r3, [r4, #40] ; 0x28 30003ea4: e1550003 cmp r5, r3
30003ea8: aaffffc4 bge 30003dc0 <erase+0x7c>
rtems_termios_puts ("\b", 1, tty);
30003eac: e59f00a4 ldr r0, [pc, #164] ; 30003f58 <erase+0x214> 30003eb0: e3a01001 mov r1, #1 30003eb4: e1a02004 mov r2, r4 30003eb8: ebfffeda bl 30003a28 <rtems_termios_puts>
tty->column--;
30003ebc: e5943028 ldr r3, [r4, #40] ; 0x28 30003ec0: e2433001 sub r3, r3, #1
}
/*
* Back up over the tab
*/
while (tty->column > col) {
30003ec4: e1530005 cmp r3, r5
rtems_termios_puts ("\b", 1, tty);
tty->column--;
30003ec8: e5843028 str r3, [r4, #40] ; 0x28
}
/*
* Back up over the tab
*/
while (tty->column > col) {
30003ecc: cafffff6 bgt 30003eac <erase+0x168>
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
30003ed0: e3560000 cmp r6, #0
30003ed4: 1affffbb bne 30003dc8 <erase+0x84>
30003ed8: 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);
30003edc: e5d40043 ldrb r0, [r4, #67] ; 0x43 <== NOT EXECUTED 30003ee0: e1a01004 mov r1, r4 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
30003ee4: 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);
30003ee8: eaffff70 b 30003cb0 <echo> <== NOT EXECUTED
30003eec: 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);
30003ef0: e59f005c ldr r0, [pc, #92] ; 30003f54 <erase+0x210> <== NOT EXECUTED 30003ef4: e3a01003 mov r1, #3 <== NOT EXECUTED 30003ef8: e1a02004 mov r2, r4 <== NOT EXECUTED 30003efc: ebfffec9 bl 30003a28 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
30003f00: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30003f04: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
30003f08: 12433001 subne r3, r3, #1 <== NOT EXECUTED 30003f0c: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
30003f10: e5973000 ldr r3, [r7] <== NOT EXECUTED 30003f14: e7d33005 ldrb r3, [r3, r5] <== NOT EXECUTED 30003f18: e3130020 tst r3, #32 <== NOT EXECUTED 30003f1c: 0affffbf beq 30003e20 <erase+0xdc> <== NOT EXECUTED 30003f20: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED 30003f24: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED 30003f28: 0affffa4 beq 30003dc0 <erase+0x7c> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
30003f2c: e59f0020 ldr r0, [pc, #32] ; 30003f54 <erase+0x210> <== NOT EXECUTED 30003f30: e3a01003 mov r1, #3 <== NOT EXECUTED 30003f34: e1a02004 mov r2, r4 <== NOT EXECUTED 30003f38: ebfffeba bl 30003a28 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
30003f3c: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30003f40: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
30003f44: 12433001 subne r3, r3, #1 <== NOT EXECUTED 30003f48: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30003f4c: eaffffbb b 30003e40 <erase+0xfc> <== NOT EXECUTED
30002998 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
30002998: e92d000e push {r1, r2, r3}
3000299c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
300029a0: e59f31cc ldr r3, [pc, #460] ; 30002b74 <fcntl+0x1dc>
int fcntl(
int fd,
int cmd,
...
)
{
300029a4: e24dd004 sub sp, sp, #4
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
300029a8: e5932000 ldr r2, [r3]
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
300029ac: e28d3028 add r3, sp, #40 ; 0x28
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
300029b0: e1500002 cmp r0, r2
int fcntl(
int fd,
int cmd,
...
)
{
300029b4: e59d4024 ldr r4, [sp, #36] ; 0x24
int ret; va_list ap; va_start( ap, cmd );
300029b8: e58d3000 str r3, [sp]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
300029bc: 2a000060 bcs 30002b44 <fcntl+0x1ac>
iop = rtems_libio_iop( fd );
300029c0: e59f71b0 ldr r7, [pc, #432] ; 30002b78 <fcntl+0x1e0> 300029c4: e0600180 rsb r0, r0, r0, lsl #3 300029c8: e5976000 ldr r6, [r7] 300029cc: e0865180 add r5, r6, r0, lsl #3
rtems_libio_check_is_open(iop);
300029d0: e595c014 ldr ip, [r5, #20] 300029d4: e31c0c01 tst ip, #256 ; 0x100
300029d8: 0a000059 beq 30002b44 <fcntl+0x1ac>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
300029dc: e3540009 cmp r4, #9 300029e0: 979ff104 ldrls pc, [pc, r4, lsl #2] 300029e4: ea000027 b 30002a88 <fcntl+0xf0> 300029e8: 30002a98 .word 0x30002a98 300029ec: 30002afc .word 0x30002afc 300029f0: 30002b0c .word 0x30002b0c 300029f4: 30002b2c .word 0x30002b2c 300029f8: 30002a34 .word 0x30002a34 300029fc: 30002a10 .word 0x30002a10 30002a00: 30002a10 .word 0x30002a10 30002a04: 30002a10 .word 0x30002a10 30002a08: 30002a10 .word 0x30002a10 30002a0c: 30002a10 .word 0x30002a10
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
30002a10: eb00309e bl 3000ec90 <__errno> 30002a14: e3a03086 mov r3, #134 ; 0x86 30002a18: e5803000 str r3, [r0]
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
30002a1c: e3e06000 mvn r6, #0
va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; }
30002a20: e1a00006 mov r0, r6
30002a24: e28dd004 add sp, sp, #4
30002a28: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
30002a2c: e28dd00c add sp, sp, #12
30002a30: 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 ) );
30002a34: e5930000 ldr r0, [r3] 30002a38: eb000181 bl 30003044 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
30002a3c: e5952014 ldr r2, [r5, #20] 30002a40: e59f3134 ldr r3, [pc, #308] ; 30002b7c <fcntl+0x1e4> 30002a44: e3c22c02 bic r2, r2, #512 ; 0x200 30002a48: e0003003 and r3, r0, r3 30002a4c: e3c22001 bic r2, r2, #1 30002a50: e1833002 orr r3, r3, r2 30002a54: e5853014 str r3, [r5, #20]
rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0;
30002a58: 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 );
30002a5c: e1a00004 mov r0, r4 30002a60: e5953020 ldr r3, [r5, #32] 30002a64: e1a01005 mov r1, r5 30002a68: e1a0e00f mov lr, pc 30002a6c: e593f030 ldr pc, [r3, #48] ; 0x30
if (err) {
30002a70: e2504000 subs r4, r0, #0
30002a74: 0affffe9 beq 30002a20 <fcntl+0x88>
errno = err;
30002a78: eb003084 bl 3000ec90 <__errno> <== NOT EXECUTED
ret = -1;
30002a7c: e3e06000 mvn r6, #0 <== NOT EXECUTED
*/
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
if (err) {
errno = err;
30002a80: e5804000 str r4, [r0] <== NOT EXECUTED 30002a84: eaffffe5 b 30002a20 <fcntl+0x88> <== NOT EXECUTED
errno = ENOTSUP;
ret = -1;
break;
default:
errno = EINVAL;
30002a88: eb003080 bl 3000ec90 <__errno> 30002a8c: e3a03016 mov r3, #22 30002a90: e5803000 str r3, [r0] 30002a94: eaffffe0 b 30002a1c <fcntl+0x84>
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
30002a98: e593a000 ldr sl, [r3]
if ( fd2 )
30002a9c: e35a0000 cmp sl, #0
30002aa0: 0a00002c beq 30002b58 <fcntl+0x1c0>
diop = rtems_libio_iop( fd2 );
30002aa4: e152000a cmp r2, sl 30002aa8: 806aa18a rsbhi sl, sl, sl, lsl #3 30002aac: 8086a18a addhi sl, r6, sl, lsl #3 30002ab0: 81a0900a movhi r9, sl 30002ab4: 93a09000 movls r9, #0 30002ab8: 91a0a009 movls sl, r9
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
30002abc: e28a8018 add r8, sl, #24
30002ac0: e2857018 add r7, r5, #24
30002ac4: e8b7000f ldm r7!, {r0, r1, r2, r3}
ret = (int) (diop - rtems_libio_iops);
30002ac8: e0666009 rsb r6, r6, r9
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
30002acc: e8a8000f stmia r8!, {r0, r1, r2, r3}
ret = (int) (diop - rtems_libio_iops);
30002ad0: e1a061c6 asr r6, r6, #3 30002ad4: e0863186 add r3, r6, r6, lsl #3 30002ad8: e0833303 add r3, r3, r3, lsl #6 30002adc: e0863183 add r3, r6, r3, lsl #3
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
30002ae0: e5972000 ldr r2, [r7]
ret = (int) (diop - rtems_libio_iops);
30002ae4: e0833783 add r3, r3, r3, lsl #15 30002ae8: e0866183 add r6, r6, r3, lsl #3
ret = -1;
break;
}
}
diop->flags = iop->flags;
30002aec: e58ac014 str ip, [sl, #20]
diop->pathinfo = iop->pathinfo;
30002af0: e5882000 str r2, [r8]
ret = (int) (diop - rtems_libio_iops);
30002af4: e2666000 rsb r6, r6, #0 30002af8: ea00000e b 30002b38 <fcntl+0x1a0>
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
30002afc: e31c0b02 tst ip, #2048 ; 0x800 30002b00: 03a06000 moveq r6, #0 30002b04: 13a06001 movne r6, #1 30002b08: eaffffd3 b 30002a5c <fcntl+0xc4>
* 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 ) )
30002b0c: e5936000 ldr r6, [r3] 30002b10: e3560000 cmp r6, #0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
30002b14: 138ccb02 orrne ip, ip, #2048 ; 0x800
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
30002b18: 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;
30002b1c: 1585c014 strne ip, [r5, #20]
rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0;
30002b20: 13a06000 movne r6, #0
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
30002b24: 0585c014 streq ip, [r5, #20] 30002b28: eaffffcb b 30002a5c <fcntl+0xc4>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
30002b2c: e1a0000c mov r0, ip 30002b30: eb000150 bl 30003078 <rtems_libio_to_fcntl_flags> 30002b34: 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) {
30002b38: e3560000 cmp r6, #0
30002b3c: aaffffc6 bge 30002a5c <fcntl+0xc4>
30002b40: eaffffb6 b 30002a20 <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);
30002b44: eb003051 bl 3000ec90 <__errno> 30002b48: e3a03009 mov r3, #9 30002b4c: e5803000 str r3, [r0] 30002b50: e3e06000 mvn r6, #0 30002b54: eaffffb1 b 30002a20 <fcntl+0x88>
fd2 = va_arg( ap, int );
if ( fd2 )
diop = rtems_libio_iop( fd2 );
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
30002b58: eb000159 bl 300030c4 <rtems_libio_allocate>
if ( diop == 0 ) {
30002b5c: e250a000 subs sl, r0, #0
30002b60: 0affffad beq 30002a1c <fcntl+0x84>
30002b64: e595c014 ldr ip, [r5, #20] 30002b68: e1a0900a mov r9, sl 30002b6c: e5976000 ldr r6, [r7] 30002b70: eaffffd1 b 30002abc <fcntl+0x124>
3000c348 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3000c348: 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) {
3000c34c: e59f5460 ldr r5, [pc, #1120] ; 3000c7b4 <fifo_open+0x46c>
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3000c350: e24dd00c sub sp, sp, #12
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
3000c354: e5958000 ldr r8, [r5]
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3000c358: e1a04000 mov r4, r0
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
3000c35c: e3580000 cmp r8, #0
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3000c360: e1a06001 mov r6, r1
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
3000c364: 0a000024 beq 3000c3fc <fifo_open+0xb4>
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3000c368: e3a01000 mov r1, #0 3000c36c: e1a00008 mov r0, r8 3000c370: e1a02001 mov r2, r1 3000c374: ebffed93 bl 300079c8 <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
3000c378: e250a000 subs sl, r0, #0
3000c37c: 1a0000e1 bne 3000c708 <fifo_open+0x3c0>
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
3000c380: e5945000 ldr r5, [r4]
if (pipe == NULL) {
3000c384: e3550000 cmp r5, #0
3000c388: 0a00007f beq 3000c58c <fifo_open+0x244>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
3000c38c: e3a01000 mov r1, #0 3000c390: e5950028 ldr r0, [r5, #40] ; 0x28 3000c394: e1a02001 mov r2, r1 3000c398: ebffed8a bl 300079c8 <rtems_semaphore_obtain>
err = -EINTR;
if (*pipep == NULL) {
3000c39c: e5943000 ldr r3, [r4]
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
3000c3a0: e3500000 cmp r0, #0 3000c3a4: 01a07000 moveq r7, r0 3000c3a8: 13e07003 mvnne r7, #3
err = -EINTR;
if (*pipep == NULL) {
3000c3ac: e3530000 cmp r3, #0
3000c3b0: 0a0000c4 beq 3000c6c8 <fifo_open+0x380>
else
*pipep = pipe;
}
out:
pipe_unlock();
3000c3b4: ebffffa9 bl 3000c260 <pipe_unlock>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
3000c3b8: e3570000 cmp r7, #0
3000c3bc: 1a00000b bne 3000c3f0 <fifo_open+0xa8>
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
3000c3c0: e5963014 ldr r3, [r6, #20]
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
3000c3c4: e5945000 ldr r5, [r4]
switch (LIBIO_ACCMODE(iop)) {
3000c3c8: e2033006 and r3, r3, #6 3000c3cc: e3530004 cmp r3, #4
3000c3d0: 0a000015 beq 3000c42c <fifo_open+0xe4>
3000c3d4: e3530006 cmp r3, #6
3000c3d8: 0a000057 beq 3000c53c <fifo_open+0x1f4>
3000c3dc: e3530002 cmp r3, #2
3000c3e0: 0a000035 beq 3000c4bc <fifo_open+0x174>
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
3000c3e4: e5950028 ldr r0, [r5, #40] ; 0x28 3000c3e8: ebffedbf bl 30007aec <rtems_semaphore_release>
return 0;
3000c3ec: e3a07000 mov r7, #0
out_error:
pipe_release(pipep, iop);
return err;
}
3000c3f0: e1a00007 mov r0, r7
3000c3f4: e28dd00c add sp, sp, #12
3000c3f8: 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 );
3000c3fc: e59f73b4 ldr r7, [pc, #948] ; 3000c7b8 <fifo_open+0x470> 3000c400: e1a01008 mov r1, r8 3000c404: e5970000 ldr r0, [r7] 3000c408: e1a02008 mov r2, r8 3000c40c: ebffed6d bl 300079c8 <rtems_semaphore_obtain>
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
3000c410: e5953000 ldr r3, [r5] 3000c414: e3530000 cmp r3, #0
3000c418: 0a0000af beq 3000c6dc <fifo_open+0x394>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
3000c41c: e5970000 ldr r0, [r7] <== NOT EXECUTED 3000c420: ebffedb1 bl 30007aec <rtems_semaphore_release> <== NOT EXECUTED 3000c424: e5958000 ldr r8, [r5] <== NOT EXECUTED 3000c428: eaffffce b 3000c368 <fifo_open+0x20> <== NOT EXECUTED
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
3000c42c: e5953014 ldr r3, [r5, #20]
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
3000c430: e5951024 ldr r1, [r5, #36] ; 0x24
if (pipe->Writers ++ == 0)
3000c434: e2832001 add r2, r3, #1
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
3000c438: e2811001 add r1, r1, #1
if (pipe->Writers ++ == 0)
3000c43c: e3530000 cmp r3, #0
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
3000c440: e5851024 str r1, [r5, #36] ; 0x24
if (pipe->Writers ++ == 0)
3000c444: e5852014 str r2, [r5, #20]
3000c448: 0a0000b0 beq 3000c710 <fifo_open+0x3c8>
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
3000c44c: e5953010 ldr r3, [r5, #16] 3000c450: e3530000 cmp r3, #0
3000c454: 1affffe2 bne 3000c3e4 <fifo_open+0x9c>
3000c458: e5963014 ldr r3, [r6, #20] 3000c45c: e3130001 tst r3, #1
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
3000c460: 05957020 ldreq r7, [r5, #32]
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
3000c464: 0a000007 beq 3000c488 <fifo_open+0x140>
3000c468: ea0000c0 b 3000c770 <fifo_open+0x428>
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
3000c46c: e5950028 ldr r0, [r5, #40] ; 0x28 3000c470: ebffed54 bl 300079c8 <rtems_semaphore_obtain> 3000c474: e3500000 cmp r0, #0
3000c478: 1a00000a bne 3000c4a8 <fifo_open+0x160>
goto out_error;
} while (prevCounter == pipe->readerCounter);
3000c47c: e5953020 ldr r3, [r5, #32] 3000c480: e1530007 cmp r3, r7
3000c484: 1affffd6 bne 3000c3e4 <fifo_open+0x9c>
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
3000c488: e5950028 ldr r0, [r5, #40] ; 0x28 3000c48c: ebffed96 bl 30007aec <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
3000c490: e3a01000 mov r1, #0 3000c494: e5950030 ldr r0, [r5, #48] ; 0x30 3000c498: eb00071f bl 3000e11c <rtems_barrier_wait> 3000c49c: e2501000 subs r1, r0, #0
goto out_error;
if (! PIPE_LOCK(pipe))
3000c4a0: e1a02001 mov r2, r1
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
3000c4a4: 0afffff0 beq 3000c46c <fifo_open+0x124>
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
3000c4a8: e3e07003 mvn r7, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
3000c4ac: e1a00004 mov r0, r4 3000c4b0: e1a01006 mov r1, r6 3000c4b4: ebffff6d bl 3000c270 <pipe_release>
return err;
3000c4b8: eaffffcc b 3000c3f0 <fifo_open+0xa8>
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
3000c4bc: e5953010 ldr r3, [r5, #16]
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
3000c4c0: e5951020 ldr r1, [r5, #32]
if (pipe->Readers ++ == 0)
3000c4c4: e2832001 add r2, r3, #1
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
3000c4c8: e2811001 add r1, r1, #1
if (pipe->Readers ++ == 0)
3000c4cc: e3530000 cmp r3, #0
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
3000c4d0: e5851020 str r1, [r5, #32]
if (pipe->Readers ++ == 0)
3000c4d4: e5852010 str r2, [r5, #16]
3000c4d8: 0a000094 beq 3000c730 <fifo_open+0x3e8>
PIPE_WAKEUPWRITERS(pipe);
if (pipe->Writers == 0) {
3000c4dc: e5953014 ldr r3, [r5, #20] 3000c4e0: e3530000 cmp r3, #0
3000c4e4: 1affffbe bne 3000c3e4 <fifo_open+0x9c>
/* Not an error */
if (LIBIO_NODELAY(iop))
3000c4e8: e5963014 ldr r3, [r6, #20] 3000c4ec: e3130001 tst r3, #1
3000c4f0: 1affffbb bne 3000c3e4 <fifo_open+0x9c>
break;
prevCounter = pipe->writerCounter;
3000c4f4: e5957024 ldr r7, [r5, #36] ; 0x24 3000c4f8: ea000006 b 3000c518 <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))
3000c4fc: e5950028 ldr r0, [r5, #40] ; 0x28 3000c500: ebffed30 bl 300079c8 <rtems_semaphore_obtain> 3000c504: e3500000 cmp r0, #0
3000c508: 1affffe6 bne 3000c4a8 <fifo_open+0x160>
goto out_error;
} while (prevCounter == pipe->writerCounter);
3000c50c: e5953024 ldr r3, [r5, #36] ; 0x24 3000c510: e1530007 cmp r3, r7
3000c514: 1affffb2 bne 3000c3e4 <fifo_open+0x9c>
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
3000c518: e5950028 ldr r0, [r5, #40] ; 0x28 3000c51c: ebffed72 bl 30007aec <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
3000c520: e3a01000 mov r1, #0 3000c524: e595002c ldr r0, [r5, #44] ; 0x2c 3000c528: eb0006fb bl 3000e11c <rtems_barrier_wait> 3000c52c: e2501000 subs r1, r0, #0
goto out_error;
if (! PIPE_LOCK(pipe))
3000c530: e1a02001 mov r2, r1
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
3000c534: 0afffff0 beq 3000c4fc <fifo_open+0x1b4>
3000c538: eaffffda b 3000c4a8 <fifo_open+0x160> <== NOT EXECUTED
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
3000c53c: e5953010 ldr r3, [r5, #16]
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
3000c540: e5951020 ldr r1, [r5, #32]
if (pipe->Readers ++ == 0)
3000c544: e2832001 add r2, r3, #1
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
3000c548: e2811001 add r1, r1, #1
if (pipe->Readers ++ == 0)
3000c54c: e3530000 cmp r3, #0
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
3000c550: e5851020 str r1, [r5, #32]
if (pipe->Readers ++ == 0)
3000c554: e5852010 str r2, [r5, #16]
3000c558: 0a000070 beq 3000c720 <fifo_open+0x3d8>
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
3000c55c: e5953014 ldr r3, [r5, #20]
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
3000c560: e5951024 ldr r1, [r5, #36] ; 0x24
if (pipe->Writers ++ == 0)
3000c564: e2832001 add r2, r3, #1
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
3000c568: e2811001 add r1, r1, #1
if (pipe->Writers ++ == 0)
3000c56c: e3530000 cmp r3, #0
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
3000c570: e5851024 str r1, [r5, #36] ; 0x24
if (pipe->Writers ++ == 0)
3000c574: e5852014 str r2, [r5, #20]
3000c578: 1affff99 bne 3000c3e4 <fifo_open+0x9c>
PIPE_WAKEUPREADERS(pipe);
3000c57c: e595002c ldr r0, [r5, #44] ; 0x2c 3000c580: e28d1008 add r1, sp, #8 3000c584: eb0006cc bl 3000e0bc <rtems_barrier_release> 3000c588: eaffff95 b 3000c3e4 <fifo_open+0x9c>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
3000c58c: e3a00034 mov r0, #52 ; 0x34 3000c590: ebffe00a bl 300045c0 <malloc>
if (pipe == NULL)
3000c594: e3500000 cmp r0, #0
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
3000c598: e1a05000 mov r5, r0 3000c59c: e1a08000 mov r8, r0
if (pipe == NULL)
3000c5a0: 0a00007e beq 3000c7a0 <fifo_open+0x458>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
3000c5a4: e1a02000 mov r2, r0 3000c5a8: e482a004 str sl, [r2], #4 3000c5ac: e2822004 add r2, r2, #4 3000c5b0: e482a004 str sl, [r2], #4 3000c5b4: e482a004 str sl, [r2], #4 3000c5b8: e482a004 str sl, [r2], #4 3000c5bc: e482a004 str sl, [r2], #4 3000c5c0: e482a004 str sl, [r2], #4 3000c5c4: e482a004 str sl, [r2], #4 3000c5c8: e482a004 str sl, [r2], #4 3000c5cc: e482a004 str sl, [r2], #4 3000c5d0: e482a004 str sl, [r2], #4 3000c5d4: e482a004 str sl, [r2], #4
pipe->Size = PIPE_BUF;
3000c5d8: 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));
3000c5dc: e582a000 str sl, [r2]
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
3000c5e0: 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;
3000c5e4: e5853004 str r3, [r5, #4]
pipe->Buffer = malloc(pipe->Size);
3000c5e8: ebffdff4 bl 300045c0 <malloc>
if (! pipe->Buffer)
3000c5ec: 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);
3000c5f0: e5850000 str r0, [r5]
if (! pipe->Buffer)
3000c5f4: 0a000067 beq 3000c798 <fifo_open+0x450>
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
3000c5f8: e59f71bc ldr r7, [pc, #444] ; 3000c7bc <fifo_open+0x474>
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
3000c5fc: e59f01bc ldr r0, [pc, #444] ; 3000c7c0 <fifo_open+0x478>
rtems_build_name ('P', 'I', 'r', c),
3000c600: e5d73000 ldrb r3, [r7]
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
3000c604: e1a0100a mov r1, sl 3000c608: e1830000 orr r0, r3, r0 3000c60c: e1a0200a mov r2, sl 3000c610: e285302c add r3, r5, #44 ; 0x2c 3000c614: eb00064a bl 3000df44 <rtems_barrier_create> 3000c618: e2501000 subs r1, r0, #0
3000c61c: 1a00005b bne 3000c790 <fifo_open+0x448>
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),
3000c620: 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(
3000c624: e59f0198 ldr r0, [pc, #408] ; 3000c7c4 <fifo_open+0x47c> 3000c628: e1a02001 mov r2, r1 3000c62c: e1830000 orr r0, r3, r0 3000c630: e2853030 add r3, r5, #48 ; 0x30 3000c634: eb000642 bl 3000df44 <rtems_barrier_create> 3000c638: e2503000 subs r3, r0, #0
3000c63c: 1a000051 bne 3000c788 <fifo_open+0x440>
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,
3000c640: e5d72000 ldrb r2, [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(
3000c644: e59f017c ldr r0, [pc, #380] ; 3000c7c8 <fifo_open+0x480> 3000c648: e285c028 add ip, r5, #40 ; 0x28 3000c64c: e1820000 orr r0, r2, r0 3000c650: e3a01001 mov r1, #1 3000c654: e3a02010 mov r2, #16 3000c658: e58dc000 str ip, [sp] 3000c65c: ebffec3f bl 30007760 <rtems_semaphore_create> 3000c660: e3500000 cmp r0, #0
3000c664: 1a000045 bne 3000c780 <fifo_open+0x438>
/* 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
3000c668: e28d8004 add r8, sp, #4
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
3000c66c: e595102c ldr r1, [r5, #44] ; 0x2c 3000c670: e1a02008 mov r2, r8 3000c674: e59f0150 ldr r0, [pc, #336] ; 3000c7cc <fifo_open+0x484> 3000c678: ebfff2cf bl 300091bc <_Objects_Get>
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
3000c67c: e590304c ldr r3, [r0, #76] ; 0x4c 3000c680: e3833201 orr r3, r3, #268435456 ; 0x10000000 3000c684: e580304c str r3, [r0, #76] ; 0x4c
_Thread_Enable_dispatch();
3000c688: ebfff5b8 bl 30009d70 <_Thread_Enable_dispatch> 3000c68c: e1a02008 mov r2, r8 3000c690: e5951030 ldr r1, [r5, #48] ; 0x30 3000c694: e59f0130 ldr r0, [pc, #304] ; 3000c7cc <fifo_open+0x484> 3000c698: ebfff2c7 bl 300091bc <_Objects_Get>
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
3000c69c: e590304c ldr r3, [r0, #76] ; 0x4c 3000c6a0: e3833201 orr r3, r3, #268435456 ; 0x10000000 3000c6a4: e580304c str r3, [r0, #76] ; 0x4c
_Thread_Enable_dispatch();
3000c6a8: ebfff5b0 bl 30009d70 <_Thread_Enable_dispatch>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
3000c6ac: e5d73000 ldrb r3, [r7] 3000c6b0: e353007a cmp r3, #122 ; 0x7a 3000c6b4: e2832001 add r2, r3, #1
c = 'a';
3000c6b8: 03a03061 moveq r3, #97 ; 0x61
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
3000c6bc: e5c72000 strb r2, [r7]
c = 'a';
3000c6c0: 05c73000 strbeq r3, [r7] 3000c6c4: eaffff30 b 3000c38c <fifo_open+0x44>
if (! PIPE_LOCK(pipe))
err = -EINTR;
if (*pipep == NULL) {
if (err)
3000c6c8: e3570000 cmp r7, #0
3000c6cc: 1a00001b bne 3000c740 <fifo_open+0x3f8>
pipe_free(pipe);
else
*pipep = pipe;
3000c6d0: e5845000 str r5, [r4]
}
out:
pipe_unlock();
3000c6d4: ebfffee1 bl 3000c260 <pipe_unlock> 3000c6d8: eaffff38 b 3000c3c0 <fifo_open+0x78>
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
sc = rtems_semaphore_create(
3000c6dc: e1a03008 mov r3, r8 3000c6e0: e3a01001 mov r1, #1 3000c6e4: e3a02054 mov r2, #84 ; 0x54 3000c6e8: e59f00e0 ldr r0, [pc, #224] ; 3000c7d0 <fifo_open+0x488> 3000c6ec: e58d5000 str r5, [sp] 3000c6f0: ebffec1a bl 30007760 <rtems_semaphore_create> 3000c6f4: e1a08000 mov r8, r0 3000c6f8: e5970000 ldr r0, [r7] 3000c6fc: ebffecfa bl 30007aec <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
3000c700: e3580000 cmp r8, #0
3000c704: 0a000028 beq 3000c7ac <fifo_open+0x464>
)
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
3000c708: e3e0700b mvn r7, #11 3000c70c: eaffff37 b 3000c3f0 <fifo_open+0xa8>
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
3000c710: e595002c ldr r0, [r5, #44] ; 0x2c 3000c714: e28d1008 add r1, sp, #8 3000c718: eb000667 bl 3000e0bc <rtems_barrier_release> 3000c71c: eaffff4a b 3000c44c <fifo_open+0x104>
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
3000c720: e5950030 ldr r0, [r5, #48] ; 0x30 3000c724: e28d1008 add r1, sp, #8 3000c728: eb000663 bl 3000e0bc <rtems_barrier_release> 3000c72c: eaffff8a b 3000c55c <fifo_open+0x214>
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
3000c730: e5950030 ldr r0, [r5, #48] ; 0x30 3000c734: e28d1008 add r1, sp, #8 3000c738: eb00065f bl 3000e0bc <rtems_barrier_release> 3000c73c: eaffff66 b 3000c4dc <fifo_open+0x194>
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
3000c740: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED 3000c744: eb000630 bl 3000e00c <rtems_barrier_delete> <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
3000c748: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED 3000c74c: eb00062e bl 3000e00c <rtems_barrier_delete> <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
3000c750: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 3000c754: ebffec72 bl 30007924 <rtems_semaphore_delete> <== NOT EXECUTED
free(pipe->Buffer);
3000c758: e5950000 ldr r0, [r5] <== NOT EXECUTED 3000c75c: ebffdd7d bl 30003d58 <free> <== NOT EXECUTED
free(pipe);
3000c760: e1a00005 mov r0, r5 <== NOT EXECUTED 3000c764: ebffdd7b bl 30003d58 <free> <== NOT EXECUTED
else
*pipep = pipe;
}
out:
pipe_unlock();
3000c768: ebfffebc bl 3000c260 <pipe_unlock> <== NOT EXECUTED 3000c76c: eaffff1f b 3000c3f0 <fifo_open+0xa8> <== NOT EXECUTED
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
3000c770: e5950028 ldr r0, [r5, #40] ; 0x28 3000c774: ebffecdc bl 30007aec <rtems_semaphore_release>
err = -ENXIO;
3000c778: e3e07005 mvn r7, #5
goto out_error;
3000c77c: eaffff4a b 3000c4ac <fifo_open+0x164>
if (c ++ == 'z')
c = 'a';
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
3000c780: e5950030 ldr r0, [r5, #48] ; 0x30 3000c784: eb000620 bl 3000e00c <rtems_barrier_delete>
err_wbar: rtems_barrier_delete(pipe->readBarrier);
3000c788: e598002c ldr r0, [r8, #44] ; 0x2c 3000c78c: eb00061e bl 3000e00c <rtems_barrier_delete>
err_rbar: free(pipe->Buffer);
3000c790: e5980000 ldr r0, [r8] 3000c794: ebffdd6f bl 30003d58 <free>
err_buf: free(pipe);
3000c798: e1a00008 mov r0, r8 3000c79c: ebffdd6d bl 30003d58 <free>
)
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
3000c7a0: e3e0700b mvn r7, #11
else
*pipep = pipe;
}
out:
pipe_unlock();
3000c7a4: ebfffead bl 3000c260 <pipe_unlock> 3000c7a8: eaffff10 b 3000c3f0 <fifo_open+0xa8>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
3000c7ac: e5958000 ldr r8, [r5] 3000c7b0: eafffeec b 3000c368 <fifo_open+0x20>
30002c08 <fpathconf>:
{
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
30002c08: e59f310c ldr r3, [pc, #268] ; 30002d1c <fpathconf+0x114>
long fpathconf(
int fd,
int name
)
{
30002c0c: 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);
30002c10: e5933000 ldr r3, [r3] 30002c14: e1500003 cmp r0, r3
30002c18: 2a000035 bcs 30002cf4 <fpathconf+0xec> iop = rtems_libio_iop(fd);
30002c1c: e59f30fc ldr r3, [pc, #252] ; 30002d20 <fpathconf+0x118> 30002c20: e0600180 rsb r0, r0, r0, lsl #3 30002c24: e5933000 ldr r3, [r3] 30002c28: e0830180 add r0, r3, r0, lsl #3
rtems_libio_check_is_open(iop);
30002c2c: e5903014 ldr r3, [r0, #20] 30002c30: e3130c01 tst r3, #256 ; 0x100
30002c34: 0a00002e beq 30002cf4 <fpathconf+0xec> rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
30002c38: e3130002 tst r3, #2
30002c3c: 0a000031 beq 30002d08 <fpathconf+0x100>
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
30002c40: e5903028 ldr r3, [r0, #40] ; 0x28
switch ( name ) {
30002c44: e351000b cmp r1, #11 30002c48: 979ff101 ldrls pc, [pc, r1, lsl #2] 30002c4c: ea00000d b 30002c88 <fpathconf+0x80> 30002c50: 30002c9c .word 0x30002c9c 30002c54: 30002ca4 .word 0x30002ca4 30002c58: 30002cac .word 0x30002cac 30002c5c: 30002cb4 .word 0x30002cb4 30002c60: 30002cbc .word 0x30002cbc 30002c64: 30002cc4 .word 0x30002cc4 30002c68: 30002ccc .word 0x30002ccc 30002c6c: 30002cd4 .word 0x30002cd4 30002c70: 30002cdc .word 0x30002cdc 30002c74: 30002ce4 .word 0x30002ce4 30002c78: 30002cec .word 0x30002cec 30002c7c: 30002c80 .word 0x30002c80
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
30002c80: e5930060 ldr r0, [r3, #96] ; 0x60
break;
30002c84: e49df004 pop {pc} ; (ldr pc, [sp], #4)
default:
rtems_set_errno_and_return_minus_one( EINVAL );
30002c88: eb003000 bl 3000ec90 <__errno> 30002c8c: e3a03016 mov r3, #22 30002c90: e5803000 str r3, [r0] 30002c94: e3e00000 mvn r0, #0
break;
}
return return_value;
}
30002c98: 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;
30002c9c: e5930038 ldr r0, [r3, #56] ; 0x38
break;
30002ca0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
30002ca4: e593003c ldr r0, [r3, #60] ; 0x3c
break;
30002ca8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
30002cac: e5930040 ldr r0, [r3, #64] ; 0x40
break;
30002cb0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_NAME_MAX:
return_value = the_limits->name_max;
30002cb4: e5930044 ldr r0, [r3, #68] ; 0x44
break;
30002cb8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PATH_MAX:
return_value = the_limits->path_max;
30002cbc: e5930048 ldr r0, [r3, #72] ; 0x48
break;
30002cc0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
30002cc4: e593004c ldr r0, [r3, #76] ; 0x4c
break;
30002cc8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
30002ccc: e5930054 ldr r0, [r3, #84] ; 0x54
break;
30002cd0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
30002cd4: e5930058 ldr r0, [r3, #88] ; 0x58
break;
30002cd8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
30002cdc: e5930064 ldr r0, [r3, #100] ; 0x64
break;
30002ce0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
30002ce4: e5930050 ldr r0, [r3, #80] ; 0x50
break;
30002ce8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
30002cec: e593005c ldr r0, [r3, #92] ; 0x5c
break;
30002cf0: 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);
30002cf4: eb002fe5 bl 3000ec90 <__errno>
30002cf8: e3a03009 mov r3, #9
30002cfc: e5803000 str r3, [r0]
30002d00: e3e00000 mvn r0, #0
30002d04: e49df004 pop {pc} ; (ldr pc, [sp], #4)
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
30002d08: eb002fe0 bl 3000ec90 <__errno>
30002d0c: e3a03016 mov r3, #22
30002d10: e5803000 str r3, [r0]
30002d14: e3e00000 mvn r0, #0
30002d18: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30003f5c <iproc>:
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
if (tty->termios.c_iflag & ISTRIP)
30003f5c: e5913030 ldr r3, [r1, #48] ; 0x30
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
30003f60: e92d4030 push {r4, r5, lr}
if (tty->termios.c_iflag & ISTRIP)
30003f64: e3130020 tst r3, #32
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
30003f68: e20040ff and r4, r0, #255 ; 0xff
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
30003f6c: 1200407f andne r4, r0, #127 ; 0x7f
if (tty->termios.c_iflag & IUCLC)
30003f70: e3130c02 tst r3, #512 ; 0x200
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
30003f74: e1a05001 mov r5, r1
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
30003f78: 0a000007 beq 30003f9c <iproc+0x40>
c = tolower (c);
30003f7c: e59f21a0 ldr r2, [pc, #416] ; 30004124 <iproc+0x1c8> 30003f80: e5922000 ldr r2, [r2] 30003f84: e0822004 add r2, r2, r4 30003f88: e5d22001 ldrb r2, [r2, #1] 30003f8c: e2022003 and r2, r2, #3 30003f90: e3520001 cmp r2, #1 30003f94: 02844020 addeq r4, r4, #32 30003f98: e20440ff and r4, r4, #255 ; 0xff
if (c == '\r') {
30003f9c: e354000d cmp r4, #13
30003fa0: 0a000014 beq 30003ff8 <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)) {
30003fa4: e354000a cmp r4, #10
30003fa8: 0a000036 beq 30004088 <iproc+0x12c>
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
30003fac: e3540000 cmp r4, #0
30003fb0: 1a000016 bne 30004010 <iproc+0xb4>
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
30003fb4: e59f216c ldr r2, [pc, #364] ; 30004128 <iproc+0x1cc> 30003fb8: e5953020 ldr r3, [r5, #32] 30003fbc: e5922008 ldr r2, [r2, #8] 30003fc0: e2422001 sub r2, r2, #1 30003fc4: e1530002 cmp r3, r2
30003fc8: aa000008 bge 30003ff0 <iproc+0x94>
if (tty->termios.c_lflag & ECHO)
30003fcc: e595203c ldr r2, [r5, #60] ; 0x3c 30003fd0: e3120008 tst r2, #8
30003fd4: 1a00002e bne 30004094 <iproc+0x138>
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
30003fd8: e595101c ldr r1, [r5, #28] <== NOT EXECUTED 30003fdc: e2832001 add r2, r3, #1 <== NOT EXECUTED 30003fe0: e7c14003 strb r4, [r1, r3] <== NOT EXECUTED
} return 0;
30003fe4: 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;
30003fe8: e5852020 str r2, [r5, #32] <== NOT EXECUTED
30003fec: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
} return 0;
30003ff0: e3a00000 mov r0, #0 <== NOT EXECUTED
}
30003ff4: 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)
30003ff8: e3130080 tst r3, #128 ; 0x80
return 0;
30003ffc: 13a00000 movne r0, #0
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
30004000: 18bd8030 popne {r4, r5, pc}
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
30004004: e3130c01 tst r3, #256 ; 0x100 30004008: 03a0400d moveq r4, #13 3000400c: 13a0400a movne r4, #10
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
30004010: e595303c ldr r3, [r5, #60] ; 0x3c 30004014: e3130002 tst r3, #2
30004018: 0affffe5 beq 30003fb4 <iproc+0x58>
if (c == tty->termios.c_cc[VERASE]) {
3000401c: e5d52043 ldrb r2, [r5, #67] ; 0x43 30004020: e1520004 cmp r2, r4
30004024: 0a000039 beq 30004110 <iproc+0x1b4>
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
30004028: e5d52044 ldrb r2, [r5, #68] ; 0x44 3000402c: e1520004 cmp r2, r4
30004030: 0a000025 beq 300040cc <iproc+0x170>
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
30004034: e5d52045 ldrb r2, [r5, #69] ; 0x45 30004038: e1520004 cmp r2, r4
return 1;
3000403c: 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]) {
30004040: 08bd8030 popeq {r4, r5, pc}
return 1;
} else if (c == '\n') {
30004044: e354000a cmp r4, #10
30004048: 0a000024 beq 300040e0 <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]) ||
3000404c: e5d5204c ldrb r2, [r5, #76] ; 0x4c 30004050: e1520004 cmp r2, r4
30004054: 0a000002 beq 30004064 <iproc+0x108>
30004058: e5d52051 ldrb r2, [r5, #81] ; 0x51 3000405c: e1520004 cmp r2, r4
30004060: 1affffd3 bne 30003fb4 <iproc+0x58>
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
30004064: e3130008 tst r3, #8 <== NOT EXECUTED 30004068: 1a000013 bne 300040bc <iproc+0x160> <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
3000406c: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED 30004070: e595101c ldr r1, [r5, #28] <== NOT EXECUTED 30004074: e2832001 add r2, r3, #1 <== NOT EXECUTED 30004078: e7c14003 strb r4, [r1, r3] <== NOT EXECUTED
return 1;
3000407c: 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;
30004080: e5852020 str r2, [r5, #32] <== NOT EXECUTED
return 1;
30004084: 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';
30004088: e3130040 tst r3, #64 ; 0x40 3000408c: 13a0400d movne r4, #13 30004090: eaffffde b 30004010 <iproc+0xb4>
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
30004094: e1a00004 mov r0, r4 30004098: e1a01005 mov r1, r5 3000409c: ebffff03 bl 30003cb0 <echo> 300040a0: e5953020 ldr r3, [r5, #32]
tty->cbuf[tty->ccount++] = c;
300040a4: e595101c ldr r1, [r5, #28] 300040a8: e2832001 add r2, r3, #1 300040ac: e7c14003 strb r4, [r1, r3]
} return 0;
300040b0: 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;
300040b4: e5852020 str r2, [r5, #32]
300040b8: 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);
300040bc: e1a00004 mov r0, r4 <== NOT EXECUTED 300040c0: e1a01005 mov r1, r5 <== NOT EXECUTED 300040c4: ebfffef9 bl 30003cb0 <echo> <== NOT EXECUTED 300040c8: eaffffe7 b 3000406c <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);
300040cc: e1a00005 mov r0, r5 300040d0: e3a01001 mov r1, #1 300040d4: ebffff1a bl 30003d44 <erase>
return 0;
300040d8: e3a00000 mov r0, #0
300040dc: 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))
300040e0: e3130048 tst r3, #72 ; 0x48
echo (c, tty);
300040e4: 11a00004 movne r0, r4 300040e8: 11a01005 movne r1, r5 300040ec: 1bfffeef blne 30003cb0 <echo>
tty->cbuf[tty->ccount++] = c;
300040f0: e5953020 ldr r3, [r5, #32] 300040f4: e595101c ldr r1, [r5, #28] 300040f8: e3a0000a mov r0, #10 300040fc: e2832001 add r2, r3, #1 30004100: e7c10003 strb r0, [r1, r3]
return 1;
30004104: 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;
30004108: e5852020 str r2, [r5, #32]
return 1;
3000410c: 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);
30004110: e1a00005 mov r0, r5 30004114: e3a01000 mov r1, #0 30004118: ebffff09 bl 30003d44 <erase>
return 0;
3000411c: e3a00000 mov r0, #0
30004120: e8bd8030 pop {r4, r5, pc}
30021be4 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
30021be4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30021be8: e24dd00c sub sp, sp, #12
30021bec: e1a04000 mov r4, r0
30021bf0: e1a05001 mov r5, r1
30021bf4: e1a08002 mov r8, r2
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
30021bf8: ebffff40 bl 30021900 <getpid> 30021bfc: e1500004 cmp r0, r4
30021c00: 1a000092 bne 30021e50 <killinfo+0x26c>
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
30021c04: e3550000 cmp r5, #0
30021c08: 0a000095 beq 30021e64 <killinfo+0x280>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
30021c0c: e2454001 sub r4, r5, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
30021c10: e354001f cmp r4, #31
30021c14: 8a000092 bhi 30021e64 <killinfo+0x280>
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 )
30021c18: e59f6270 ldr r6, [pc, #624] ; 30021e90 <killinfo+0x2ac> 30021c1c: e1a07085 lsl r7, r5, #1 30021c20: e0873005 add r3, r7, r5 30021c24: e0863103 add r3, r6, r3, lsl #2 30021c28: e5933008 ldr r3, [r3, #8] 30021c2c: e3530001 cmp r3, #1
return 0;
30021c30: 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 )
30021c34: 0a00006c beq 30021dec <killinfo+0x208>
/*
* 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 ) )
30021c38: e3550008 cmp r5, #8 30021c3c: 13550004 cmpne r5, #4
30021c40: 0a00006b beq 30021df4 <killinfo+0x210>
30021c44: e355000b cmp r5, #11
30021c48: 0a000069 beq 30021df4 <killinfo+0x210>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
30021c4c: e3a03001 mov r3, #1
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
30021c50: e3580000 cmp r8, #0
/* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER;
30021c54: e58d3004 str r3, [sp, #4]
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
30021c58: e58d5000 str r5, [sp] 30021c5c: e1a04413 lsl r4, r3, r4
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
30021c60: 15983000 ldrne r3, [r8]
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
30021c64: 058d8008 streq r8, [sp, #8]
} else {
siginfo->si_value = *value;
30021c68: 158d3008 strne r3, [sp, #8] 30021c6c: e59f3220 ldr r3, [pc, #544] ; 30021e94 <killinfo+0x2b0> 30021c70: e5932000 ldr r2, [r3] 30021c74: e2822001 add r2, r2, #1 30021c78: 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;
30021c7c: e59f3214 ldr r3, [pc, #532] ; 30021e98 <killinfo+0x2b4> 30021c80: e5930004 ldr r0, [r3, #4]
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
30021c84: e59030fc ldr r3, [r0, #252] ; 0xfc 30021c88: e59330d0 ldr r3, [r3, #208] ; 0xd0 30021c8c: e1d43003 bics r3, r4, r3
30021c90: 1a000048 bne 30021db8 <killinfo+0x1d4>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
30021c94: e59fc200 ldr ip, [pc, #512] ; 30021e9c <killinfo+0x2b8> 30021c98: e49c3004 ldr r3, [ip], #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 );
30021c9c: e153000c cmp r3, ip
30021ca0: 0a000013 beq 30021cf4 <killinfo+0x110>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
30021ca4: e5932030 ldr r2, [r3, #48] ; 0x30
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;
30021ca8: e1a00003 mov r0, r3
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
30021cac: 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;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
30021cb0: e59320fc ldr r2, [r3, #252] ; 0xfc
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
30021cb4: 1a00003f bne 30021db8 <killinfo+0x1d4>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
30021cb8: e59220d0 ldr r2, [r2, #208] ; 0xd0 30021cbc: e1d42002 bics r2, r4, r2
30021cc0: 0a000008 beq 30021ce8 <killinfo+0x104>
30021cc4: ea00003b b 30021db8 <killinfo+0x1d4>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
30021cc8: e5932030 ldr r2, [r3, #48] ; 0x30 <== 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;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
30021ccc: e59310fc ldr r1, [r3, #252] ; 0xfc <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
30021cd0: 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;
30021cd4: e1a00003 mov r0, r3 <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
30021cd8: 1a000036 bne 30021db8 <killinfo+0x1d4> <== NOT EXECUTED
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
30021cdc: e59120d0 ldr r2, [r1, #208] ; 0xd0 <== NOT EXECUTED 30021ce0: e1d42002 bics r2, r4, r2 <== NOT EXECUTED 30021ce4: 1a000033 bne 30021db8 <killinfo+0x1d4> <== NOT EXECUTED
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 ) {
30021ce8: 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 );
30021cec: e153000c cmp r3, ip
30021cf0: 1afffff4 bne 30021cc8 <killinfo+0xe4> * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
30021cf4: e59f31a4 ldr r3, [pc, #420] ; 30021ea0 <killinfo+0x2bc> 30021cf8: e59fa1a4 ldr sl, [pc, #420] ; 30021ea4 <killinfo+0x2c0> 30021cfc: e5d3e000 ldrb lr, [r3]
* * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL;
30021d00: e3a08000 mov r8, #0
interested_priority = PRIORITY_MAXIMUM + 1;
30021d04: e28ee001 add lr, lr, #1
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 ] )
30021d08: e5ba3004 ldr r3, [sl, #4]! 30021d0c: e3530000 cmp r3, #0
30021d10: 0a000022 beq 30021da0 <killinfo+0x1bc>
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
30021d14: e5933004 ldr r3, [r3, #4]
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
30021d18: e1d3c1b0 ldrh ip, [r3, #16]
object_table = the_info->local_table;
30021d1c: e593101c ldr r1, [r3, #28]
for ( index = 1 ; index <= maximum ; index++ ) {
30021d20: e35c0000 cmp ip, #0
30021d24: 0a00001d beq 30021da0 <killinfo+0x1bc>
30021d28: e3a02001 mov r2, #1
the_thread = (Thread_Control *) object_table[ index ];
30021d2c: e5b13004 ldr r3, [r1, #4]!
if ( !the_thread )
30021d30: e3530000 cmp r3, #0
30021d34: 0a000016 beq 30021d94 <killinfo+0x1b0>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
30021d38: e5930014 ldr r0, [r3, #20] 30021d3c: e150000e cmp r0, lr
30021d40: 8a000013 bhi 30021d94 <killinfo+0x1b0>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
30021d44: e59390fc ldr r9, [r3, #252] ; 0xfc 30021d48: e59990d0 ldr r9, [r9, #208] ; 0xd0 30021d4c: e1d49009 bics r9, r4, r9
30021d50: 0a00000f beq 30021d94 <killinfo+0x1b0>
*
* 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 ) {
30021d54: e150000e cmp r0, lr
30021d58: 3a000036 bcc 30021e38 <killinfo+0x254>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
30021d5c: e3580000 cmp r8, #0
30021d60: 0a00000b beq 30021d94 <killinfo+0x1b0>
30021d64: e5989010 ldr r9, [r8, #16] 30021d68: e3590000 cmp r9, #0
30021d6c: 0a000008 beq 30021d94 <killinfo+0x1b0>
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
30021d70: e593b010 ldr fp, [r3, #16] 30021d74: e35b0000 cmp fp, #0
30021d78: 0a00002e beq 30021e38 <killinfo+0x254>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
30021d7c: e3190201 tst r9, #268435456 ; 0x10000000
30021d80: 1a000003 bne 30021d94 <killinfo+0x1b0>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
30021d84: e20bb201 and fp, fp, #268435456 ; 0x10000000
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
30021d88: e35b0000 cmp fp, #0 30021d8c: 11a0e000 movne lr, r0 30021d90: 11a08003 movne r8, r3
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
30021d94: e2822001 add r2, r2, #1 30021d98: e15c0002 cmp ip, r2
30021d9c: 2affffe2 bcs 30021d2c <killinfo+0x148>
* + 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++) {
30021da0: e59f3100 ldr r3, [pc, #256] ; 30021ea8 <killinfo+0x2c4> 30021da4: e15a0003 cmp sl, r3
30021da8: 1affffd6 bne 30021d08 <killinfo+0x124>
}
}
}
}
if ( interested ) {
30021dac: e3580000 cmp r8, #0
30021db0: 0a000005 beq 30021dcc <killinfo+0x1e8>
30021db4: 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 ) ) {
30021db8: e1a01005 mov r1, r5 30021dbc: e1a0200d mov r2, sp 30021dc0: eb000045 bl 30021edc <_POSIX_signals_Unblock_thread> 30021dc4: e3500000 cmp r0, #0
30021dc8: 1a000005 bne 30021de4 <killinfo+0x200>
/*
* 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 );
30021dcc: e1a00004 mov r0, r4
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
30021dd0: 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 );
30021dd4: eb000036 bl 30021eb4 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
30021dd8: e7963105 ldr r3, [r6, r5, lsl #2] 30021ddc: e3530002 cmp r3, #2
30021de0: 0a000007 beq 30021e04 <killinfo+0x220>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
30021de4: ebffacbe bl 3000d0e4 <_Thread_Enable_dispatch>
return 0;
30021de8: e3a00000 mov r0, #0
}
30021dec: e28dd00c add sp, sp, #12
30021df0: 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 );
30021df4: eb0000bc bl 300220ec <pthread_self> 30021df8: e1a01005 mov r1, r5 30021dfc: eb000081 bl 30022008 <pthread_kill> 30021e00: eafffff9 b 30021dec <killinfo+0x208>
_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 );
30021e04: e59f00a0 ldr r0, [pc, #160] ; 30021eac <killinfo+0x2c8> 30021e08: ebffa610 bl 3000b650 <_Chain_Get>
if ( !psiginfo ) {
30021e0c: e250c000 subs ip, r0, #0
30021e10: 0a000018 beq 30021e78 <killinfo+0x294>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
30021e14: e28c3008 add r3, ip, #8
30021e18: e1a0200d mov r2, sp
30021e1c: e8920007 ldm r2, {r0, r1, r2}
30021e20: e8830007 stm r3, {r0, r1, r2}
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
30021e24: e59f0084 ldr r0, [pc, #132] ; 30021eb0 <killinfo+0x2cc> 30021e28: e1a0100c mov r1, ip 30021e2c: e0800105 add r0, r0, r5, lsl #2 30021e30: ebffa5f3 bl 3000b604 <_Chain_Append> 30021e34: eaffffea b 30021de4 <killinfo+0x200>
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
30021e38: e2822001 add r2, r2, #1 30021e3c: 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 ) ) {
30021e40: e1a0e000 mov lr, r0 30021e44: e1a08003 mov r8, r3
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
30021e48: 2affffb7 bcs 30021d2c <killinfo+0x148>
30021e4c: eaffffd3 b 30021da0 <killinfo+0x1bc>
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
rtems_set_errno_and_return_minus_one( ESRCH );
30021e50: ebffc52d bl 3001330c <__errno> 30021e54: e3a03003 mov r3, #3 30021e58: e5803000 str r3, [r0] 30021e5c: e3e00000 mvn r0, #0 30021e60: eaffffe1 b 30021dec <killinfo+0x208>
*/
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
30021e64: ebffc528 bl 3001330c <__errno> 30021e68: e3a03016 mov r3, #22 30021e6c: e5803000 str r3, [r0] 30021e70: e3e00000 mvn r0, #0 30021e74: eaffffdc b 30021dec <killinfo+0x208>
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();
30021e78: ebffac99 bl 3000d0e4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
30021e7c: ebffc522 bl 3001330c <__errno> 30021e80: e3a0300b mov r3, #11 30021e84: e5803000 str r3, [r0] 30021e88: e3e00000 mvn r0, #0 30021e8c: eaffffd6 b 30021dec <killinfo+0x208>
30002370 <malloc>:
size_t size
)
{
void *return_this;
MSBUMP(malloc_calls, 1);
30002370: e59f30d4 ldr r3, [pc, #212] ; 3000244c <malloc+0xdc>
#include "malloc_p.h"
void *malloc(
size_t size
)
{
30002374: e92d4030 push {r4, r5, lr}
void *return_this;
MSBUMP(malloc_calls, 1);
30002378: e5932004 ldr r2, [r3, #4]
#include "malloc_p.h"
void *malloc(
size_t size
)
{
3000237c: e1a04000 mov r4, r0
void *return_this;
MSBUMP(malloc_calls, 1);
30002380: e2822001 add r2, r2, #1 30002384: e5832004 str r2, [r3, #4]
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
30002388: ebffffb0 bl 30002250 <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
3000238c: e3540000 cmp r4, #0
return (void *) 0;
30002390: 01a05004 moveq r5, r4
malloc_deferred_frees_process();
/*
* Validate the parameters
*/
if ( !size )
30002394: 0a000018 beq 300023fc <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()) &&
30002398: e59f30b0 ldr r3, [pc, #176] ; 30002450 <malloc+0xe0> 3000239c: e5933000 ldr r3, [r3] 300023a0: e3530003 cmp r3, #3
300023a4: 0a000024 beq 3000243c <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 );
300023a8: e59f30a4 ldr r3, [pc, #164] ; 30002454 <malloc+0xe4> 300023ac: e3a02000 mov r2, #0 300023b0: e5930000 ldr r0, [r3] 300023b4: e1a01004 mov r1, r4 300023b8: e1a03002 mov r3, r2 300023bc: eb00137f bl 300071c0 <_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 ) {
300023c0: e2505000 subs r5, r0, #0
300023c4: 0a00000e beq 30002404 <malloc+0x94>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
300023c8: e59f3088 ldr r3, [pc, #136] ; 30002458 <malloc+0xe8> 300023cc: e5933000 ldr r3, [r3] 300023d0: e3530000 cmp r3, #0
(*rtems_malloc_dirty_helper)( return_this, size );
300023d4: 11a00005 movne r0, r5 300023d8: 11a01004 movne r1, r4 300023dc: 11a0e00f movne lr, pc 300023e0: 112fff13 bxne r3
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
300023e4: e59f3070 ldr r3, [pc, #112] ; 3000245c <malloc+0xec> 300023e8: e5933000 ldr r3, [r3] 300023ec: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
300023f0: 11a00005 movne r0, r5 300023f4: 11a0e00f movne lr, pc 300023f8: 1593f004 ldrne pc, [r3, #4]
return return_this;
}
300023fc: e1a00005 mov r0, r5
30002400: e8bd8030 pop {r4, r5, pc}
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
30002404: e59f3054 ldr r3, [pc, #84] ; 30002460 <malloc+0xf0> 30002408: e5933000 ldr r3, [r3] 3000240c: e3530000 cmp r3, #0
30002410: 0a000005 beq 3000242c <malloc+0xbc>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
30002414: e1a00004 mov r0, r4 30002418: e1a0e00f mov lr, pc 3000241c: e593f004 ldr pc, [r3, #4]
if ( !return_this ) {
30002420: e3500000 cmp r0, #0 30002424: 11a05000 movne r5, r0
30002428: 1affffe6 bne 300023c8 <malloc+0x58>
errno = ENOMEM;
3000242c: eb002df1 bl 3000dbf8 <__errno> 30002430: e3a0300c mov r3, #12 30002434: e5803000 str r3, [r0]
return (void *) 0;
30002438: eaffffef b 300023fc <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() )
3000243c: ebffff6f bl 30002200 <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()) &&
30002440: e2505000 subs r5, r0, #0
30002444: 1affffd7 bne 300023a8 <malloc+0x38>
30002448: eaffffeb b 300023fc <malloc+0x8c> <== NOT EXECUTED
3000cbdc <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
3000cbdc: e92d4030 push {r4, r5, lr}
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
3000cbe0: e5905018 ldr r5, [r0, #24]
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
3000cbe4: e1a04000 mov r4, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
3000cbe8: e595304c ldr r3, [r5, #76] ; 0x4c 3000cbec: e3530006 cmp r3, #6
3000cbf0: 0a00000d beq 3000cc2c <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 ))
3000cbf4: e1a00005 mov r0, r5
3000cbf8: e284200c add r2, r4, #12
3000cbfc: e8920006 ldm r2, {r1, r2}
3000cc00: ebfffee7 bl 3000c7a4 <IMFS_memfile_extend>
3000cc04: e3500000 cmp r0, #0
3000cc08: 1a000018 bne 3000cc70 <memfile_lseek+0x94>
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
3000cc0c: e2853050 add r3, r5, #80 ; 0x50
3000cc10: e893000c ldm r3, {r2, r3}
3000cc14: e984000c stmib r4, {r2, r3}
3000cc18: e284300c add r3, r4, #12
3000cc1c: e893000c ldm r3, {r2, r3}
} return iop->offset; }
3000cc20: e1a00002 mov r0, r2
3000cc24: e1a01003 mov r1, r3
3000cc28: 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)
3000cc2c: e5951054 ldr r1, [r5, #84] ; 0x54
3000cc30: e280300c add r3, r0, #12
3000cc34: e893000c ldm r3, {r2, r3}
3000cc38: e1530001 cmp r3, r1
3000cc3c: e5950050 ldr r0, [r5, #80] ; 0x50
3000cc40: ca000002 bgt 3000cc50 <memfile_lseek+0x74> 3000cc44: 1afffff5 bne 3000cc20 <memfile_lseek+0x44>
3000cc48: e1520000 cmp r2, r0
3000cc4c: 9afffff3 bls 3000cc20 <memfile_lseek+0x44>
iop->offset = the_jnode->info.linearfile.size;
3000cc50: e1a02000 mov r2, r0 <== NOT EXECUTED 3000cc54: e1a03001 mov r3, r1 <== NOT EXECUTED 3000cc58: e1a05000 mov r5, r0 <== NOT EXECUTED 3000cc5c: e584000c str r0, [r4, #12] <== NOT EXECUTED 3000cc60: 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;
}
3000cc64: e1a00002 mov r0, r2 <== NOT EXECUTED
3000cc68: e1a01003 mov r1, r3 <== NOT EXECUTED
3000cc6c: 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 );
3000cc70: eb0003e0 bl 3000dbf8 <__errno> 3000cc74: e3a0301c mov r3, #28 3000cc78: e5803000 str r3, [r0] 3000cc7c: e3e02000 mvn r2, #0 3000cc80: e3e03000 mvn r3, #0 3000cc84: eaffffe5 b 3000cc20 <memfile_lseek+0x44>
3000cac8 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
3000cac8: 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))
3000cacc: e5903014 ldr r3, [r0, #20]
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
3000cad0: e24dd004 sub sp, sp, #4
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
3000cad4: e3130f81 tst r3, #516 ; 0x204
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
3000cad8: e1a04000 mov r4, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
3000cadc: e5905018 ldr r5, [r0, #24]
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
3000cae0: 0a000002 beq 3000caf0 <memfile_open+0x28>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
3000cae4: e595204c ldr r2, [r5, #76] ; 0x4c 3000cae8: e3520006 cmp r2, #6
3000caec: 0a00000a beq 3000cb1c <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))
3000caf0: e5950050 ldr r0, [r5, #80] ; 0x50 3000caf4: e5952054 ldr r2, [r5, #84] ; 0x54
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
3000caf8: e3130c02 tst r3, #512 ; 0x200
iop->offset = the_jnode->info.file.size;
3000cafc: 1584000c strne r0, [r4, #12] 3000cb00: 15842010 strne r2, [r4, #16] 3000cb04: 15950050 ldrne r0, [r5, #80] ; 0x50 3000cb08: 15952054 ldrne r2, [r5, #84] ; 0x54
iop->size = the_jnode->info.file.size;
3000cb0c: e9840005 stmib r4, {r0, r2}
return 0;
3000cb10: e3a00000 mov r0, #0
}
3000cb14: e28dd004 add sp, sp, #4
3000cb18: 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;
3000cb1c: 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;
3000cb20: 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;
3000cb24: e3a01000 mov r1, #0 <== NOT EXECUTED 3000cb28: 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;
3000cb2c: 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)
3000cb30: 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;
3000cb34: e5953058 ldr r3, [r5, #88] ; 0x58 <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
3000cb38: e585604c str r6, [r5, #76] ; 0x4c <== NOT EXECUTED
the_jnode->info.file.size = 0;
3000cb3c: e5851050 str r1, [r5, #80] ; 0x50 <== NOT EXECUTED 3000cb40: e5852054 str r2, [r5, #84] ; 0x54 <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
3000cb44: e5850058 str r0, [r5, #88] ; 0x58 <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
3000cb48: e585005c str r0, [r5, #92] ; 0x5c <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
3000cb4c: e5850060 str r0, [r5, #96] ; 0x60 <== NOT EXECUTED
if ((count != 0)
3000cb50: 05943014 ldreq r3, [r4, #20] <== NOT EXECUTED 3000cb54: 01a00001 moveq r0, r1 <== NOT EXECUTED 3000cb58: 0affffe6 beq 3000caf8 <memfile_open+0x30> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
3000cb5c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000cb60: e58dc000 str ip, [sp] <== NOT EXECUTED 3000cb64: ebffff5b bl 3000c8d8 <IMFS_memfile_write> <== NOT EXECUTED 3000cb68: e3700001 cmn r0, #1 <== NOT EXECUTED 3000cb6c: 0affffe8 beq 3000cb14 <memfile_open+0x4c> <== NOT EXECUTED 3000cb70: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000cb74: eaffffdd b 3000caf0 <memfile_open+0x28> <== NOT EXECUTED
300025a4 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
300025a4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
300025a8: e3530001 cmp r3, #1
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
300025ac: e24dd030 sub sp, sp, #48 ; 0x30 300025b0: e58d3008 str r3, [sp, #8] 300025b4: e1a07000 mov r7, r0 300025b8: e1a06001 mov r6, r1 300025bc: e1a09002 mov r9, r2
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
300025c0: 8a00009a bhi 30002830 <mount+0x28c>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
300025c4: e1a00002 mov r0, r2 300025c8: eb001ffa bl 3000a5b8 <rtems_filesystem_get_mount_handler>
if ( !mount_h )
300025cc: e3500000 cmp r0, #0 300025d0: e58d0014 str r0, [sp, #20]
300025d4: 0a000095 beq 30002830 <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;
300025d8: e2565000 subs r5, r6, #0 300025dc: 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 : "/";
300025e0: e3550000 cmp r5, #0
300025e4: 0a00008a beq 30002814 <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(
300025e8: e1a00006 mov r0, r6 300025ec: eb00316b bl 3000eba0 <strlen> 300025f0: e2803001 add r3, r0, #1 300025f4: e58d0010 str r0, [sp, #16] 300025f8: e58d300c str r3, [sp, #12] 300025fc: 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;
30002600: e1a00009 mov r0, r9 30002604: eb003165 bl 3000eba0 <strlen>
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
30002608: 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;
3000260c: e280b001 add fp, r0, #1
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
30002610: 01a08007 moveq r8, r7
30002614: 0a000002 beq 30002624 <mount+0x80>
30002618: e1a00007 mov r0, r7 3000261c: eb00315f bl 3000eba0 <strlen> 30002620: 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;
30002624: e59d300c ldr r3, [sp, #12]
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
30002628: e3a00001 mov r0, #1
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
3000262c: e2831074 add r1, r3, #116 ; 0x74 30002630: e081100b add r1, r1, fp
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
30002634: e0811008 add r1, r1, r8 30002638: ebfffe05 bl 30001e54 <calloc>
if ( mt_entry != NULL ) {
3000263c: e2504000 subs r4, r0, #0
30002640: 0a00006e beq 30002800 <mount+0x25c>
char *str = (char *) mt_entry + sizeof( *mt_entry );
30002644: e284a074 add sl, r4, #116 ; 0x74
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
30002648: 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 );
3000264c: e1a01009 mov r1, r9 30002650: e1a0200b mov r2, fp 30002654: e1a0000a mov r0, sl 30002658: e58d3004 str r3, [sp, #4] 3000265c: eb002f93 bl 3000e4b0 <memcpy>
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
30002660: e59d3004 ldr r3, [sp, #4]
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
30002664: e1a01007 mov r1, r7 30002668: e1a02008 mov r2, r8 3000266c: 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;
30002670: e584a06c str sl, [r4, #108] ; 0x6c
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
30002674: e0839008 add r9, r3, r8
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
30002678: eb002f8c bl 3000e4b0 <memcpy>
mt_entry->dev = str;
3000267c: e59d3004 ldr r3, [sp, #4]
str += source_size;
memcpy( str, target, target_size );
30002680: e59d1018 ldr r1, [sp, #24] 30002684: 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;
30002688: e5843070 str r3, [r4, #112] ; 0x70
str += source_size;
memcpy( str, target, target_size );
3000268c: e1a00009 mov r0, r9 30002690: eb002f86 bl 3000e4b0 <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;
30002694: e59fe20c ldr lr, [pc, #524] ; 300028a8 <mount+0x304>
30002698: e284c038 add ip, r4, #56 ; 0x38
3000269c: e8be000f ldm lr!, {r0, r1, r2, r3}
300026a0: e8ac000f stmia ip!, {r0, r1, r2, r3}
300026a4: e8be000f ldm lr!, {r0, r1, r2, r3}
300026a8: e8ac000f stmia ip!, {r0, r1, r2, r3}
300026ac: 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;
300026b0: e59de008 ldr lr, [sp, #8]
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
300026b4: 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;
300026b8: 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;
300026bc: e584402c str r4, [r4, #44] ; 0x2c
mt_entry->options = options;
300026c0: e584e030 str lr, [r4, #48] ; 0x30
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
300026c4: 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 ) {
300026c8: 1a000024 bne 30002760 <mount+0x1bc>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
300026cc: e59f31d8 ldr r3, [pc, #472] ; 300028ac <mount+0x308>
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
300026d0: e5932000 ldr r2, [r3]
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
300026d4: e2833004 add r3, r3, #4 300026d8: 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;
300026dc: 01a07005 moveq r7, r5
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
300026e0: 1a000057 bne 30002844 <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 ) ) {
300026e4: e1a00004 mov r0, r4 300026e8: e59d1054 ldr r1, [sp, #84] ; 0x54 300026ec: e59d3014 ldr r3, [sp, #20] 300026f0: e1a0e00f mov lr, pc 300026f4: e12fff13 bx r3 300026f8: e2506000 subs r6, r0, #0
300026fc: 1a000057 bne 30002860 <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 );
30002700: e59f71a8 ldr r7, [pc, #424] ; 300028b0 <mount+0x30c> 30002704: e1a02006 mov r2, r6 30002708: e1a01006 mov r1, r6 3000270c: e5970000 ldr r0, [r7] 30002710: eb000bdc bl 30005688 <rtems_semaphore_obtain> 30002714: e59f0190 ldr r0, [pc, #400] ; 300028ac <mount+0x308> 30002718: e1a01004 mov r1, r4 3000271c: eb000e4c bl 30006054 <_Chain_Append>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
30002720: e5970000 ldr r0, [r7] 30002724: eb000c20 bl 300057ac <rtems_semaphore_release>
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
30002728: e3550000 cmp r5, #0
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
3000272c: 11a00006 movne r0, r6
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
30002730: 1a000008 bne 30002758 <mount+0x1b4>
rtems_filesystem_root = mt_entry->mt_fs_root;
30002734: e59f3178 ldr r3, [pc, #376] ; 300028b4 <mount+0x310>
30002738: e284401c add r4, r4, #28
3000273c: e593c000 ldr ip, [r3]
30002740: e8b4000f ldm r4!, {r0, r1, r2, r3}
30002744: e28cc018 add ip, ip, #24
30002748: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000274c: e5943000 ldr r3, [r4]
return 0;
30002750: e1a00005 mov r0, r5
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
rtems_filesystem_root = mt_entry->mt_fs_root;
30002754: e58c3000 str r3, [ip]
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
}
30002758: e28dd030 add sp, sp, #48 ; 0x30
3000275c: 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(
30002760: e28d701c add r7, sp, #28 30002764: e3a0c001 mov ip, #1 30002768: e1a00006 mov r0, r6 3000276c: e59d1010 ldr r1, [sp, #16] 30002770: e3a02007 mov r2, #7 30002774: e1a03007 mov r3, r7 30002778: e58dc000 str ip, [sp] 3000277c: ebfffde2 bl 30001f0c <rtems_filesystem_evaluate_path> 30002780: e3700001 cmn r0, #1
30002784: 0a000031 beq 30002850 <mount+0x2ac>
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
30002788: e1a00007 mov r0, r7 3000278c: e59d3028 ldr r3, [sp, #40] ; 0x28 30002790: e1a0e00f mov lr, pc 30002794: e593f010 ldr pc, [r3, #16] 30002798: e3500001 cmp r0, #1
3000279c: 1a000039 bne 30002888 <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 ) ) {
300027a0: e59f0110 ldr r0, [pc, #272] ; 300028b8 <mount+0x314> 300027a4: e59d101c ldr r1, [sp, #28] 300027a8: ebffff5f bl 3000252c <rtems_filesystem_mount_iterate> 300027ac: e3500000 cmp r0, #0
300027b0: 1a000038 bne 30002898 <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;
300027b4: e59d201c ldr r2, [sp, #28]
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
300027b8: e59d3028 ldr r3, [sp, #40] ; 0x28
* 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;
300027bc: e5842008 str r2, [r4, #8]
mt_entry->mt_point_node.handlers = loc.handlers;
300027c0: e59d2024 ldr r2, [sp, #36] ; 0x24
mt_entry->mt_point_node.ops = loc.ops;
300027c4: e5843014 str r3, [r4, #20]
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
mt_entry->mt_point_node.handlers = loc.handlers;
300027c8: e5842010 str r2, [r4, #16]
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
300027cc: e59d202c ldr r2, [sp, #44] ; 0x2c
/*
* 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 ) ) {
300027d0: e1a00004 mov r0, r4
*/
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;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
300027d4: 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 ) ) {
300027d8: e1a0e00f mov lr, pc 300027dc: e593f020 ldr pc, [r3, #32] 300027e0: e3500000 cmp r0, #0
300027e4: 0affffbe beq 300026e4 <mount+0x140>
return 0;
cleanup_and_bail:
free( mt_entry );
300027e8: e1a00004 mov r0, r4 300027ec: ebfffe05 bl 30002008 <free>
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
300027f0: e1a00007 mov r0, r7 300027f4: ebfffdfe bl 30001ff4 <rtems_filesystem_freenode>
return -1;
300027f8: e3e00000 mvn r0, #0 300027fc: eaffffd5 b 30002758 <mount+0x1b4>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
30002800: eb002cfc bl 3000dbf8 <__errno> <== NOT EXECUTED 30002804: e3a0300c mov r3, #12 <== NOT EXECUTED 30002808: e5803000 str r3, [r0] <== NOT EXECUTED 3000280c: e3e00000 mvn r0, #0 <== NOT EXECUTED 30002810: eaffffd0 b 30002758 <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 : "/";
30002814: e59fe0a0 ldr lr, [pc, #160] ; 300028bc <mount+0x318> 30002818: e3a03002 mov r3, #2 3000281c: e58de018 str lr, [sp, #24] 30002820: e3a0e001 mov lr, #1 30002824: e58d300c str r3, [sp, #12] 30002828: e58de010 str lr, [sp, #16] 3000282c: eaffff73 b 30002600 <mount+0x5c>
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
if ( !mount_h )
rtems_set_errno_and_return_minus_one( EINVAL );
30002830: eb002cf0 bl 3000dbf8 <__errno> 30002834: e3a03016 mov r3, #22 30002838: e5803000 str r3, [r0] 3000283c: e3e00000 mvn r0, #0 30002840: eaffffc4 b 30002758 <mount+0x1b4>
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
errno = EINVAL;
30002844: eb002ceb bl 3000dbf8 <__errno> <== NOT EXECUTED 30002848: e3a03016 mov r3, #22 <== NOT EXECUTED 3000284c: e5803000 str r3, [r0] <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
30002850: e1a00004 mov r0, r4 <== NOT EXECUTED 30002854: ebfffdeb bl 30002008 <free> <== NOT EXECUTED
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
30002858: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000285c: eaffffbd b 30002758 <mount+0x1b4> <== NOT EXECUTED
if ( (*mount_h)( mt_entry, data ) ) {
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
30002860: e59d3028 ldr r3, [sp, #40] ; 0x28 30002864: e1a00004 mov r0, r4 30002868: e1a0e00f mov lr, pc 3000286c: e593f028 ldr pc, [r3, #40] ; 0x28
return 0;
cleanup_and_bail:
free( mt_entry );
30002870: e1a00004 mov r0, r4 30002874: ebfffde3 bl 30002008 <free>
if ( loc_to_free )
30002878: e3570000 cmp r7, #0
rtems_filesystem_freenode( loc_to_free );
return -1;
3000287c: 03e00000 mvneq r0, #0
cleanup_and_bail:
free( mt_entry );
if ( loc_to_free )
30002880: 0affffb4 beq 30002758 <mount+0x1b4>
30002884: eaffffd9 b 300027f0 <mount+0x24c>
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
errno = ENOTDIR;
30002888: eb002cda bl 3000dbf8 <__errno> 3000288c: e3a03014 mov r3, #20 30002890: e5803000 str r3, [r0]
goto cleanup_and_bail;
30002894: eaffffd3 b 300027e8 <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;
30002898: eb002cd6 bl 3000dbf8 <__errno> 3000289c: e3a03010 mov r3, #16 300028a0: e5803000 str r3, [r0]
goto cleanup_and_bail;
300028a4: eaffffcf b 300027e8 <mount+0x244>
300028c4 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
300028c4: e92d4010 push {r4, lr}
300028c8: e1a04000 mov r4, r0
switch ( fileno(fp) ) {
300028cc: eb002dcc bl 3000e004 <fileno> 300028d0: e3500002 cmp r0, #2
300028d4: 9a000003 bls 300028e8 <newlib_free_buffers+0x24>
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
300028d8: e1a00004 mov r0, r4 <== NOT EXECUTED 300028dc: eb002d13 bl 3000dd30 <fclose> <== NOT EXECUTED
} return 0; }
300028e0: e3a00000 mov r0, #0
300028e4: e8bd8010 pop {r4, pc}
{
switch ( fileno(fp) ) {
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
300028e8: e1d430bc ldrh r3, [r4, #12] 300028ec: e3130080 tst r3, #128 ; 0x80
300028f0: 0afffffa beq 300028e0 <newlib_free_buffers+0x1c>
free( fp->_bf._base );
300028f4: e5940010 ldr r0, [r4, #16]
300028f8: ebfffdc2 bl 30002008 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
300028fc: e1d420bc ldrh r2, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
30002900: e3a03000 mov r3, #0 <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
30002904: e3c22080 bic r2, r2, #128 ; 0x80 <== NOT EXECUTED 30002908: e1c420bc strh r2, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
3000290c: e5843000 str r3, [r4] <== NOT EXECUTED 30002910: e5843010 str r3, [r4, #16] <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
30002914: e3a00000 mov r0, #0 <== NOT EXECUTED
30002918: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30003b40 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
30003b40: e92d4010 push {r4, lr}
int i;
if (tty->termios.c_oflag & OPOST) {
30003b44: e5913034 ldr r3, [r1, #52] ; 0x34
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
30003b48: e24dd004 sub sp, sp, #4
int i;
if (tty->termios.c_oflag & OPOST) {
30003b4c: e3130001 tst r3, #1
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
30003b50: e1a04001 mov r4, r1 30003b54: e5cd0000 strb r0, [sp]
int i;
if (tty->termios.c_oflag & OPOST) {
30003b58: 0a000014 beq 30003bb0 <oproc+0x70>
switch (c) {
30003b5c: e5dd1000 ldrb r1, [sp] 30003b60: e2412008 sub r2, r1, #8 30003b64: e3520005 cmp r2, #5 30003b68: 979ff102 ldrls pc, [pc, r2, lsl #2] 30003b6c: ea000005 b 30003b88 <oproc+0x48> 30003b70: 30003c38 .word 0x30003c38 30003b74: 30003c00 .word 0x30003c00 30003b78: 30003c4c .word 0x30003c4c 30003b7c: 30003b88 .word 0x30003b88 30003b80: 30003b88 .word 0x30003b88 30003b84: 30003bc8 .word 0x30003bc8
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
30003b88: e3130002 tst r3, #2
30003b8c: 1a00003a bne 30003c7c <oproc+0x13c>
30003b90: e59f310c ldr r3, [pc, #268] ; 30003ca4 <oproc+0x164> 30003b94: e5933000 ldr r3, [r3]
c = toupper(c);
if (!iscntrl(c))
30003b98: e0831001 add r1, r3, r1 30003b9c: e5d13001 ldrb r3, [r1, #1] 30003ba0: e3130020 tst r3, #32
tty->column++;
30003ba4: 05943028 ldreq r3, [r4, #40] ; 0x28 30003ba8: 02833001 addeq r3, r3, #1 30003bac: 05843028 streq r3, [r4, #40] ; 0x28
break;
}
}
rtems_termios_puts (&c, 1, tty);
30003bb0: e1a0000d mov r0, sp 30003bb4: e3a01001 mov r1, #1 30003bb8: e1a02004 mov r2, r4 30003bbc: ebffff99 bl 30003a28 <rtems_termios_puts>
}
30003bc0: e28dd004 add sp, sp, #4
30003bc4: e8bd8010 pop {r4, pc}
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
30003bc8: e3130010 tst r3, #16 <== NOT EXECUTED 30003bcc: 0a000002 beq 30003bdc <oproc+0x9c> <== NOT EXECUTED 30003bd0: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED 30003bd4: e3520000 cmp r2, #0 <== NOT EXECUTED 30003bd8: 0afffff8 beq 30003bc0 <oproc+0x80> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
30003bdc: e2132008 ands r2, r3, #8 <== NOT EXECUTED
c = '\n';
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
break;
}
tty->column = 0;
30003be0: 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) {
30003be4: 0afffff1 beq 30003bb0 <oproc+0x70> <== NOT EXECUTED
c = '\n';
if (tty->termios.c_oflag & ONLRET)
30003be8: 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';
30003bec: e3a0300a mov r3, #10 <== NOT EXECUTED 30003bf0: e5cd3000 strb r3, [sp] <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
30003bf4: 13a03000 movne r3, #0 <== NOT EXECUTED 30003bf8: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30003bfc: eaffffeb b 30003bb0 <oproc+0x70> <== NOT EXECUTED
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
30003c00: e5942028 ldr r2, [r4, #40] ; 0x28
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
30003c04: e2033b06 and r3, r3, #6144 ; 0x1800
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
30003c08: e2021007 and r1, r2, #7
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
30003c0c: e3530b06 cmp r3, #6144 ; 0x1800
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
30003c10: e2611008 rsb r1, r1, #8
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
rtems_termios_puts ( " ", i, tty);
return;
}
tty->column += i;
30003c14: 10811002 addne r1, r1, r2 30003c18: 15841028 strne r1, [r4, #40] ; 0x28
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
30003c1c: 1affffe3 bne 30003bb0 <oproc+0x70>
tty->column += i;
30003c20: e0812002 add r2, r1, r2 30003c24: e5842028 str r2, [r4, #40] ; 0x28
rtems_termios_puts ( " ", i, tty);
30003c28: e59f0078 ldr r0, [pc, #120] ; 30003ca8 <oproc+0x168> 30003c2c: e1a02004 mov r2, r4 30003c30: ebffff7c bl 30003a28 <rtems_termios_puts>
return;
30003c34: eaffffe1 b 30003bc0 <oproc+0x80>
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
30003c38: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30003c3c: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
30003c40: c2433001 subgt r3, r3, #1 <== NOT EXECUTED 30003c44: c5843028 strgt r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30003c48: eaffffd8 b 30003bb0 <oproc+0x70> <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
30003c4c: e3130020 tst r3, #32
tty->column = 0;
30003c50: 13a02000 movne r2, #0 30003c54: 15842028 strne r2, [r4, #40] ; 0x28
if (tty->termios.c_oflag & ONLCR) {
30003c58: e3130004 tst r3, #4
30003c5c: 0affffd3 beq 30003bb0 <oproc+0x70>
rtems_termios_puts ("\r", 1, tty);
30003c60: e59f0044 ldr r0, [pc, #68] ; 30003cac <oproc+0x16c> 30003c64: e3a01001 mov r1, #1 30003c68: e1a02004 mov r2, r4 30003c6c: ebffff6d bl 30003a28 <rtems_termios_puts>
tty->column = 0;
30003c70: e3a03000 mov r3, #0 30003c74: e5843028 str r3, [r4, #40] ; 0x28 30003c78: eaffffcc b 30003bb0 <oproc+0x70>
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
c = toupper(c);
30003c7c: e59f3020 ldr r3, [pc, #32] ; 30003ca4 <oproc+0x164> <== NOT EXECUTED 30003c80: e5933000 ldr r3, [r3] <== NOT EXECUTED 30003c84: e0832001 add r2, r3, r1 <== NOT EXECUTED 30003c88: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED 30003c8c: e2022003 and r2, r2, #3 <== NOT EXECUTED 30003c90: e3520002 cmp r2, #2 <== NOT EXECUTED 30003c94: 02411020 subeq r1, r1, #32 <== NOT EXECUTED 30003c98: e20110ff and r1, r1, #255 ; 0xff <== NOT EXECUTED 30003c9c: e5cd1000 strb r1, [sp] <== NOT EXECUTED 30003ca0: eaffffbc b 30003b98 <oproc+0x58> <== NOT EXECUTED
3000cba0 <pipe_ioctl>:
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
3000cba0: e59f3058 ldr r3, [pc, #88] ; 3000cc00 <pipe_ioctl+0x60>
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
3000cba4: e92d4070 push {r4, r5, r6, lr}
if (cmd == FIONREAD) {
3000cba8: e1510003 cmp r1, r3
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
3000cbac: e1a05000 mov r5, r0 3000cbb0: e1a04002 mov r4, r2
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
3000cbb4: 13e00015 mvnne r0, #21
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
3000cbb8: 18bd8070 popne {r4, r5, r6, pc}
if (buffer == NULL)
3000cbbc: e3520000 cmp r2, #0
return -EFAULT;
3000cbc0: 03e0000d mvneq r0, #13
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
3000cbc4: 08bd8070 popeq {r4, r5, r6, pc}
return -EFAULT;
if (! PIPE_LOCK(pipe))
3000cbc8: e3a01000 mov r1, #0 3000cbcc: e5950028 ldr r0, [r5, #40] ; 0x28 3000cbd0: e1a02001 mov r2, r1 3000cbd4: ebffeb7b bl 300079c8 <rtems_semaphore_obtain> 3000cbd8: e2506000 subs r6, r0, #0
3000cbdc: 0a000001 beq 3000cbe8 <pipe_ioctl+0x48>
return -EINTR;
3000cbe0: e3e00003 mvn r0, #3
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
3000cbe4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
3000cbe8: e595300c ldr r3, [r5, #12]
PIPE_UNLOCK(pipe);
3000cbec: e5950028 ldr r0, [r5, #40] ; 0x28
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
3000cbf0: e5843000 str r3, [r4]
PIPE_UNLOCK(pipe);
3000cbf4: ebffebbc bl 30007aec <rtems_semaphore_release>
return 0;
3000cbf8: e1a00006 mov r0, r6
3000cbfc: e8bd8070 pop {r4, r5, r6, pc}
3000c7d4 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
3000c7d4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000c7d8: e1a09001 mov r9, r1
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
3000c7dc: e3a01000 mov r1, #0
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
3000c7e0: e24dd008 sub sp, sp, #8 3000c7e4: e1a04000 mov r4, r0 3000c7e8: e1a05002 mov r5, r2
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
3000c7ec: e5900028 ldr r0, [r0, #40] ; 0x28 3000c7f0: e1a02001 mov r2, r1
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
3000c7f4: e1a08003 mov r8, r3
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
3000c7f8: ebffec72 bl 300079c8 <rtems_semaphore_obtain> 3000c7fc: e250a000 subs sl, r0, #0
return -EINTR;
3000c800: 13e07003 mvnne r7, #3
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
3000c804: 1a000027 bne 3000c8a8 <pipe_read+0xd4>
return -EINTR;
while (read < count) {
3000c808: e3550000 cmp r5, #0 3000c80c: 01a07005 moveq r7, r5 3000c810: 01a06007 moveq r6, r7
3000c814: 0a00001f beq 3000c898 <pipe_read+0xc4>
3000c818: e1a0700a mov r7, sl
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
3000c81c: e28db004 add fp, sp, #4
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
3000c820: e594200c ldr r2, [r4, #12] 3000c824: e3520000 cmp r2, #0
3000c828: 1a000021 bne 3000c8b4 <pipe_read+0xe0>
/* Not an error */
if (pipe->Writers == 0)
3000c82c: e5946014 ldr r6, [r4, #20] 3000c830: e3560000 cmp r6, #0
3000c834: 0a000017 beq 3000c898 <pipe_read+0xc4>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
3000c838: e5986014 ldr r6, [r8, #20] 3000c83c: e2166001 ands r6, r6, #1
3000c840: 1a00003b bne 3000c934 <pipe_read+0x160>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
3000c844: e5943018 ldr r3, [r4, #24]
PIPE_UNLOCK(pipe);
3000c848: e5940028 ldr r0, [r4, #40] ; 0x28
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
3000c84c: e2833001 add r3, r3, #1 3000c850: e5843018 str r3, [r4, #24]
PIPE_UNLOCK(pipe);
3000c854: ebffeca4 bl 30007aec <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
3000c858: e1a01006 mov r1, r6 3000c85c: e594002c ldr r0, [r4, #44] ; 0x2c 3000c860: eb00062d bl 3000e11c <rtems_barrier_wait>
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
3000c864: e1a01006 mov r1, r6 3000c868: e1a02001 mov r2, r1
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
3000c86c: e2506000 subs r6, r0, #0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
3000c870: 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))
3000c874: 13e06003 mvnne r6, #3
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
3000c878: ebffec52 bl 300079c8 <rtems_semaphore_obtain> 3000c87c: e3500000 cmp r0, #0
3000c880: 1a00002d bne 3000c93c <pipe_read+0x168>
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
3000c884: e5943018 ldr r3, [r4, #24]
if (ret != 0)
3000c888: e3560000 cmp r6, #0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
3000c88c: e2433001 sub r3, r3, #1 3000c890: e5843018 str r3, [r4, #24]
if (ret != 0)
3000c894: 0affffe1 beq 3000c820 <pipe_read+0x4c>
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
3000c898: e5940028 ldr r0, [r4, #40] ; 0x28 3000c89c: ebffec92 bl 30007aec <rtems_semaphore_release>
out_nolock:
if (read > 0)
return read;
return ret;
3000c8a0: e3570000 cmp r7, #0 3000c8a4: d1a07006 movle r7, r6
}
3000c8a8: e1a00007 mov r0, r7
3000c8ac: e28dd008 add sp, sp, #8
3000c8b0: 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;
3000c8b4: e5941008 ldr r1, [r4, #8] 3000c8b8: e5943004 ldr r3, [r4, #4]
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
3000c8bc: e06a6005 rsb r6, sl, r5 3000c8c0: e1520006 cmp r2, r6 3000c8c4: 31a06002 movcc r6, r2
chunk1 = pipe->Size - pipe->Start;
3000c8c8: e0613003 rsb r3, r1, r3
if (chunk > chunk1) {
3000c8cc: e1560003 cmp r6, r3
3000c8d0: ca00001b bgt 3000c944 <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);
3000c8d4: e5943000 ldr r3, [r4] 3000c8d8: e089000a add r0, r9, sl 3000c8dc: e0831001 add r1, r3, r1 3000c8e0: e1a02006 mov r2, r6 3000c8e4: eb001247 bl 30011208 <memcpy>
pipe->Start += chunk;
3000c8e8: e5940008 ldr r0, [r4, #8]
pipe->Start %= pipe->Size;
3000c8ec: e5941004 ldr r1, [r4, #4] 3000c8f0: e0860000 add r0, r6, r0 3000c8f4: eb003e3c bl 3001c1ec <__umodsi3>
pipe->Length -= chunk;
3000c8f8: e594300c ldr r3, [r4, #12]
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
3000c8fc: e5840008 str r0, [r4, #8]
pipe->Length -= chunk;
3000c900: e0663003 rsb r3, r6, r3
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
3000c904: e3530000 cmp r3, #0
pipe->Start = 0;
3000c908: 05843008 streq r3, [r4, #8]
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
pipe->Length -= chunk;
3000c90c: e584300c str r3, [r4, #12]
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
3000c910: e594301c ldr r3, [r4, #28] 3000c914: e3530000 cmp r3, #0
3000c918: 1a000016 bne 3000c978 <pipe_read+0x1a4>
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
3000c91c: e0877006 add r7, r7, r6
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
3000c920: e1570005 cmp r7, r5 3000c924: e1a0a007 mov sl, r7
3000c928: 3affffbc bcc 3000c820 <pipe_read+0x4c>
3000c92c: e3a06000 mov r6, #0 3000c930: eaffffd8 b 3000c898 <pipe_read+0xc4>
/* Not an error */
if (pipe->Writers == 0)
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
3000c934: e3e0600a mvn r6, #10 3000c938: eaffffd6 b 3000c898 <pipe_read+0xc4>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
3000c93c: e3e06003 mvn r6, #3 <== NOT EXECUTED 3000c940: eaffffd6 b 3000c8a0 <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);
3000c944: e5940000 ldr r0, [r4] 3000c948: e1a02003 mov r2, r3 3000c94c: e0801001 add r1, r0, r1 3000c950: e089000a add r0, r9, sl 3000c954: e58d3000 str r3, [sp] 3000c958: eb00122a bl 30011208 <memcpy>
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
3000c95c: e59d3000 ldr r3, [sp] 3000c960: e5941000 ldr r1, [r4] 3000c964: e08a0003 add r0, sl, r3 3000c968: e0890000 add r0, r9, r0 3000c96c: e0632006 rsb r2, r3, r6 3000c970: eb001224 bl 30011208 <memcpy> 3000c974: eaffffdb b 3000c8e8 <pipe_read+0x114>
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
3000c978: e5940030 ldr r0, [r4, #48] ; 0x30 3000c97c: e1a0100b mov r1, fp 3000c980: eb0005cd bl 3000e0bc <rtems_barrier_release> 3000c984: eaffffe4 b 3000c91c <pipe_read+0x148>
3000c988 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
3000c988: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
3000c98c: e2524000 subs r4, r2, #0
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
3000c990: e24dd008 sub sp, sp, #8 3000c994: e1a05000 mov r5, r0 3000c998: e1a06001 mov r6, r1
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
3000c99c: 01a07004 moveq r7, r4
)
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
3000c9a0: 1a000002 bne 3000c9b0 <pipe_write+0x28>
#endif
if (written > 0)
return written;
return ret;
}
3000c9a4: e1a00007 mov r0, r7
3000c9a8: e28dd008 add sp, sp, #8
3000c9ac: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
3000c9b0: e3a01000 mov r1, #0 3000c9b4: e5900028 ldr r0, [r0, #40] ; 0x28 3000c9b8: e1a02001 mov r2, r1 3000c9bc: e58d3000 str r3, [sp] 3000c9c0: ebffec00 bl 300079c8 <rtems_semaphore_obtain> 3000c9c4: e2509000 subs r9, r0, #0 3000c9c8: e59d3000 ldr r3, [sp]
return -EINTR;
3000c9cc: 13e07003 mvnne r7, #3
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
3000c9d0: 1afffff3 bne 3000c9a4 <pipe_write+0x1c>
return -EINTR;
if (pipe->Readers == 0) {
3000c9d4: e5957010 ldr r7, [r5, #16] 3000c9d8: e3570000 cmp r7, #0
3000c9dc: 0a000057 beq 3000cb40 <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;
3000c9e0: e5958004 ldr r8, [r5, #4] 3000c9e4: e1a07009 mov r7, r9 3000c9e8: e1540008 cmp r4, r8 3000c9ec: 91a0a004 movls sl, r4 3000c9f0: 83a0a001 movhi sl, #1
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
3000c9f4: 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) {
3000c9f8: e595100c ldr r1, [r5, #12] 3000c9fc: e0612008 rsb r2, r1, r8 3000ca00: e152000a cmp r2, sl
3000ca04: 2a000021 bcs 3000ca90 <pipe_write+0x108>
if (LIBIO_NODELAY(iop)) {
3000ca08: e5938014 ldr r8, [r3, #20] 3000ca0c: e2188001 ands r8, r8, #1
3000ca10: 1a000052 bne 3000cb60 <pipe_write+0x1d8>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
3000ca14: e595201c ldr r2, [r5, #28]
PIPE_UNLOCK(pipe);
3000ca18: e5950028 ldr r0, [r5, #40] ; 0x28
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
3000ca1c: e2822001 add r2, r2, #1 3000ca20: e585201c str r2, [r5, #28]
PIPE_UNLOCK(pipe);
3000ca24: e58d3000 str r3, [sp] 3000ca28: ebffec2f bl 30007aec <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
3000ca2c: e1a01008 mov r1, r8 3000ca30: e5950030 ldr r0, [r5, #48] ; 0x30 3000ca34: eb0005b8 bl 3000e11c <rtems_barrier_wait>
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
3000ca38: e1a01008 mov r1, r8 3000ca3c: e1a02001 mov r2, r1
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
3000ca40: e2508000 subs r8, r0, #0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
3000ca44: 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))
3000ca48: 13e08003 mvnne r8, #3
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
3000ca4c: ebffebdd bl 300079c8 <rtems_semaphore_obtain> 3000ca50: e3500000 cmp r0, #0 3000ca54: e59d3000 ldr r3, [sp]
3000ca58: 1a00003e bne 3000cb58 <pipe_write+0x1d0>
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
3000ca5c: e595201c ldr r2, [r5, #28]
if (ret != 0)
3000ca60: e3580000 cmp r8, #0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
3000ca64: e2422001 sub r2, r2, #1 3000ca68: e585201c str r2, [r5, #28]
if (ret != 0)
3000ca6c: 1a00002c bne 3000cb24 <pipe_write+0x19c>
goto out_locked;
if (pipe->Readers == 0) {
3000ca70: e5952010 ldr r2, [r5, #16] 3000ca74: e3520000 cmp r2, #0
3000ca78: 0a000030 beq 3000cb40 <pipe_write+0x1b8>
3000ca7c: e5958004 ldr r8, [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) {
3000ca80: e595100c ldr r1, [r5, #12] 3000ca84: e0612008 rsb r2, r1, r8 3000ca88: e152000a cmp r2, sl
3000ca8c: 3affffdd bcc 3000ca08 <pipe_write+0x80>
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
3000ca90: e5950008 ldr r0, [r5, #8]
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
3000ca94: e069a004 rsb sl, r9, r4
chunk1 = pipe->Size - PIPE_WSTART(pipe);
3000ca98: e0810000 add r0, r1, r0 3000ca9c: e1a01008 mov r1, r8
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
3000caa0: e152000a cmp r2, sl 3000caa4: 31a0a002 movcc sl, r2
chunk1 = pipe->Size - PIPE_WSTART(pipe);
3000caa8: e58d3000 str r3, [sp] 3000caac: eb003dce bl 3001c1ec <__umodsi3> 3000cab0: e0608008 rsb r8, r0, r8
if (chunk > chunk1) {
3000cab4: e15a0008 cmp sl, r8
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
3000cab8: e1a0c000 mov ip, r0
if (chunk > chunk1) {
3000cabc: e59d3000 ldr r3, [sp]
3000cac0: da000028 ble 3000cb68 <pipe_write+0x1e0>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
3000cac4: e5950000 ldr r0, [r5] 3000cac8: e0861009 add r1, r6, r9 3000cacc: e1a02008 mov r2, r8 3000cad0: e080000c add r0, r0, ip 3000cad4: eb0011cb bl 30011208 <memcpy>
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
3000cad8: e0881009 add r1, r8, r9 3000cadc: e5950000 ldr r0, [r5] 3000cae0: e0861001 add r1, r6, r1 3000cae4: e068200a rsb r2, r8, sl 3000cae8: eb0011c6 bl 30011208 <memcpy> 3000caec: e59d3000 ldr r3, [sp]
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
3000caf0: e595200c ldr r2, [r5, #12]
if (pipe->waitingReaders > 0)
3000caf4: 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;
3000caf8: e082200a add r2, r2, sl
if (pipe->waitingReaders > 0)
3000cafc: 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;
3000cb00: e585200c str r2, [r5, #12]
if (pipe->waitingReaders > 0)
3000cb04: 1a00001f bne 3000cb88 <pipe_write+0x200>
PIPE_WAKEUPREADERS(pipe);
written += chunk;
3000cb08: e087700a add r7, r7, sl
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
3000cb0c: e1540007 cmp r4, r7 3000cb10: e1a09007 mov r9, r7 3000cb14: 85958004 ldrhi r8, [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;
3000cb18: 83a0a001 movhi sl, #1
3000cb1c: 8affffb5 bhi 3000c9f8 <pipe_write+0x70>
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
3000cb20: e3a08000 mov r8, #0
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
3000cb24: e5950028 ldr r0, [r5, #40] ; 0x28 3000cb28: ebffebef bl 30007aec <rtems_semaphore_release>
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
3000cb2c: e3780020 cmn r8, #32
3000cb30: 0a000004 beq 3000cb48 <pipe_write+0x1c0>
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
3000cb34: e3570000 cmp r7, #0 3000cb38: d1a07008 movle r7, r8 3000cb3c: eaffff98 b 3000c9a4 <pipe_write+0x1c>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
3000cb40: e3e0801f mvn r8, #31 3000cb44: eafffff6 b 3000cb24 <pipe_write+0x19c>
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
3000cb48: eb000221 bl 3000d3d4 <getpid> 3000cb4c: e3a0100d mov r1, #13 3000cb50: eb0002ed bl 3000d70c <kill> 3000cb54: eafffff6 b 3000cb34 <pipe_write+0x1ac>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
3000cb58: e3e08003 mvn r8, #3 <== NOT EXECUTED 3000cb5c: eafffff4 b 3000cb34 <pipe_write+0x1ac> <== NOT EXECUTED
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
3000cb60: e3e0800a mvn r8, #10 3000cb64: eaffffee b 3000cb24 <pipe_write+0x19c>
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);
3000cb68: e5950000 ldr r0, [r5] 3000cb6c: e0861009 add r1, r6, r9 3000cb70: e080000c add r0, r0, ip 3000cb74: e1a0200a mov r2, sl 3000cb78: e58d3000 str r3, [sp] 3000cb7c: eb0011a1 bl 30011208 <memcpy> 3000cb80: e59d3000 ldr r3, [sp] 3000cb84: eaffffd9 b 3000caf0 <pipe_write+0x168>
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
3000cb88: e595002c ldr r0, [r5, #44] ; 0x2c 3000cb8c: e1a0100b mov r1, fp 3000cb90: e58d3000 str r3, [sp] 3000cb94: eb000548 bl 3000e0bc <rtems_barrier_release> 3000cb98: e59d3000 ldr r3, [sp] 3000cb9c: eaffffd9 b 3000cb08 <pipe_write+0x180>
3000a904 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
3000a904: e3500000 cmp r0, #0
3000a908: 0a00000e beq 3000a948 <pthread_attr_setschedpolicy+0x44>
3000a90c: e5903000 ldr r3, [r0] 3000a910: e3530000 cmp r3, #0
3000a914: 0a00000b beq 3000a948 <pthread_attr_setschedpolicy+0x44>
return EINVAL;
switch ( policy ) {
3000a918: e3510004 cmp r1, #4
3000a91c: 9a000001 bls 3000a928 <pthread_attr_setschedpolicy+0x24>
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
3000a920: e3a00086 mov r0, #134 ; 0x86
} }
3000a924: e12fff1e bx lr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
3000a928: e3a03001 mov r3, #1 3000a92c: e1a03113 lsl r3, r3, r1 3000a930: e3130017 tst r3, #23
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
3000a934: 15801014 strne r1, [r0, #20]
return 0;
3000a938: 13a00000 movne r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
3000a93c: 112fff1e bxne lr
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
3000a940: e3a00086 mov r0, #134 ; 0x86 <== NOT EXECUTED
} }
3000a944: e12fff1e bx lr <== NOT EXECUTED
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000a948: e3a00016 mov r0, #22 3000a94c: e12fff1e bx lr
30007ae4 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
30007ae4: e3500000 cmp r0, #0
30007ae8: 0a000008 beq 30007b10 <pthread_mutexattr_setpshared+0x2c>
30007aec: e5903000 ldr r3, [r0] 30007af0: e3530000 cmp r3, #0
30007af4: 0a000005 beq 30007b10 <pthread_mutexattr_setpshared+0x2c>
return EINVAL;
switch ( pshared ) {
30007af8: e3510001 cmp r1, #1
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
30007afc: 95801004 strls r1, [r0, #4]
return 0;
30007b00: 93a00000 movls r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
30007b04: 912fff1e bxls lr
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
30007b08: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
30007b0c: e12fff1e bx lr <== NOT EXECUTED
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
30007b10: e3a00016 mov r0, #22 30007b14: e12fff1e bx lr
30006de0 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
30006de0: e92d4030 push {r4, r5, lr}
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
30006de4: e2505000 subs r5, r0, #0
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
30006de8: e24dd00c sub sp, sp, #12
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
30006dec: 0a00001d beq 30006e68 <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 );
30006df0: e1a00001 mov r0, r1 30006df4: e28d1004 add r1, sp, #4 30006df8: eb001a02 bl 3000d608 <_POSIX_Absolute_timeout_to_ticks> 30006dfc: e5951000 ldr r1, [r5] 30006e00: e1a04000 mov r4, r0 30006e04: e28d2008 add r2, sp, #8 30006e08: e59f0098 ldr r0, [pc, #152] ; 30006ea8 <pthread_rwlock_timedrdlock+0xc8> 30006e0c: eb000aa9 bl 300098b8 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
30006e10: e59d3008 ldr r3, [sp, #8] 30006e14: e3530000 cmp r3, #0
30006e18: 1a000012 bne 30006e68 <pthread_rwlock_timedrdlock+0x88>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
30006e1c: 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,
30006e20: e3540003 cmp r4, #3 30006e24: 13a05000 movne r5, #0 30006e28: 03a05001 moveq r5, #1 30006e2c: e58d3000 str r3, [sp] 30006e30: e2800010 add r0, r0, #16 30006e34: e1a02005 mov r2, r5 30006e38: e59d3004 ldr r3, [sp, #4] 30006e3c: eb000737 bl 30008b20 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
30006e40: eb000d7b bl 3000a434 <_Thread_Enable_dispatch>
if ( !do_wait ) {
30006e44: e3550000 cmp r5, #0
30006e48: 1a000011 bne 30006e94 <pthread_rwlock_timedrdlock+0xb4>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
30006e4c: e59f3058 ldr r3, [pc, #88] ; 30006eac <pthread_rwlock_timedrdlock+0xcc> 30006e50: e5933004 ldr r3, [r3, #4] 30006e54: e5930034 ldr r0, [r3, #52] ; 0x34 30006e58: e3500002 cmp r0, #2
30006e5c: 0a000004 beq 30006e74 <pthread_rwlock_timedrdlock+0x94>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
30006e60: eb000046 bl 30006f80 <_POSIX_RWLock_Translate_core_RWLock_return_code> 30006e64: ea000000 b 30006e6c <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;
30006e68: e3a00016 mov r0, #22
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
30006e6c: e28dd00c add sp, sp, #12
30006e70: 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 )
30006e74: e3540000 cmp r4, #0
30006e78: 0afffffa beq 30006e68 <pthread_rwlock_timedrdlock+0x88> return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
30006e7c: e2444001 sub r4, r4, #1 30006e80: e3540001 cmp r4, #1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
30006e84: 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 ||
30006e88: 9afffff7 bls 30006e6c <pthread_rwlock_timedrdlock+0x8c>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
30006e8c: eb00003b bl 30006f80 <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 30006e90: eafffff5 b 30006e6c <pthread_rwlock_timedrdlock+0x8c> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
30006e94: e59f3010 ldr r3, [pc, #16] ; 30006eac <pthread_rwlock_timedrdlock+0xcc> 30006e98: e5933004 ldr r3, [r3, #4] 30006e9c: e5930034 ldr r0, [r3, #52] ; 0x34
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
30006ea0: eb000036 bl 30006f80 <_POSIX_RWLock_Translate_core_RWLock_return_code> 30006ea4: eafffff0 b 30006e6c <pthread_rwlock_timedrdlock+0x8c>
30006eb0 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
30006eb0: e92d4030 push {r4, r5, lr}
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
30006eb4: e2505000 subs r5, r0, #0
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
30006eb8: e24dd00c sub sp, sp, #12
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
30006ebc: 0a00001d beq 30006f38 <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 );
30006ec0: e1a00001 mov r0, r1 30006ec4: e28d1004 add r1, sp, #4 30006ec8: eb0019ce bl 3000d608 <_POSIX_Absolute_timeout_to_ticks> 30006ecc: e5951000 ldr r1, [r5] 30006ed0: e1a04000 mov r4, r0 30006ed4: e28d2008 add r2, sp, #8 30006ed8: e59f0098 ldr r0, [pc, #152] ; 30006f78 <pthread_rwlock_timedwrlock+0xc8> 30006edc: eb000a75 bl 300098b8 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
30006ee0: e59d3008 ldr r3, [sp, #8] 30006ee4: e3530000 cmp r3, #0
30006ee8: 1a000012 bne 30006f38 <pthread_rwlock_timedwrlock+0x88>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
30006eec: 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,
30006ef0: e3540003 cmp r4, #3 30006ef4: 13a05000 movne r5, #0 30006ef8: 03a05001 moveq r5, #1 30006efc: e58d3000 str r3, [sp] 30006f00: e2800010 add r0, r0, #16 30006f04: e1a02005 mov r2, r5 30006f08: e59d3004 ldr r3, [sp, #4] 30006f0c: eb00073a bl 30008bfc <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
30006f10: eb000d47 bl 3000a434 <_Thread_Enable_dispatch>
if ( !do_wait &&
30006f14: e3550000 cmp r5, #0
30006f18: 1a000011 bne 30006f64 <pthread_rwlock_timedwrlock+0xb4>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
30006f1c: e59f3058 ldr r3, [pc, #88] ; 30006f7c <pthread_rwlock_timedwrlock+0xcc> 30006f20: e5933004 ldr r3, [r3, #4] 30006f24: e5930034 ldr r0, [r3, #52] ; 0x34
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
30006f28: e3500002 cmp r0, #2
30006f2c: 0a000004 beq 30006f44 <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(
30006f30: eb000012 bl 30006f80 <_POSIX_RWLock_Translate_core_RWLock_return_code> 30006f34: ea000000 b 30006f3c <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;
30006f38: e3a00016 mov r0, #22
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
30006f3c: e28dd00c add sp, sp, #12
30006f40: 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 )
30006f44: e3540000 cmp r4, #0
30006f48: 0afffffa beq 30006f38 <pthread_rwlock_timedwrlock+0x88> return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
30006f4c: e2444001 sub r4, r4, #1 30006f50: e3540001 cmp r4, #1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
30006f54: 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 ||
30006f58: 9afffff7 bls 30006f3c <pthread_rwlock_timedwrlock+0x8c>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
30006f5c: eb000007 bl 30006f80 <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 30006f60: eafffff5 b 30006f3c <pthread_rwlock_timedwrlock+0x8c> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
30006f64: e59f3010 ldr r3, [pc, #16] ; 30006f7c <pthread_rwlock_timedwrlock+0xcc> 30006f68: e5933004 ldr r3, [r3, #4] 30006f6c: 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(
30006f70: eb000002 bl 30006f80 <_POSIX_RWLock_Translate_core_RWLock_return_code> 30006f74: eafffff0 b 30006f3c <pthread_rwlock_timedwrlock+0x8c>
30007714 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
30007714: e3500000 cmp r0, #0
30007718: 0a000008 beq 30007740 <pthread_rwlockattr_setpshared+0x2c>
return EINVAL;
if ( !attr->is_initialized )
3000771c: e5903000 ldr r3, [r0] 30007720: e3530000 cmp r3, #0
30007724: 0a000005 beq 30007740 <pthread_rwlockattr_setpshared+0x2c>
return EINVAL;
switch ( pshared ) {
30007728: e3510001 cmp r1, #1
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000772c: 95801004 strls r1, [r0, #4]
return 0;
30007730: 93a00000 movls r0, #0
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
30007734: 912fff1e bxls lr
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
30007738: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000773c: e12fff1e bx lr <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
30007740: e3a00016 mov r0, #22 30007744: e12fff1e bx lr
30004104 <readv>:
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
30004104: e59f313c ldr r3, [pc, #316] ; 30004248 <readv+0x144>
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
30004108: e92d41f0 push {r4, r5, r6, r7, r8, lr}
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
3000410c: e5933000 ldr r3, [r3]
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
30004110: e1a04002 mov r4, r2
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
30004114: e1500003 cmp r0, r3
30004118: 2a000045 bcs 30004234 <readv+0x130> iop = rtems_libio_iop( fd );
3000411c: e59f3128 ldr r3, [pc, #296] ; 3000424c <readv+0x148> 30004120: e0600180 rsb r0, r0, r0, lsl #3 30004124: e5933000 ldr r3, [r3] 30004128: e0836180 add r6, r3, r0, lsl #3
rtems_libio_check_is_open( iop );
3000412c: e5963014 ldr r3, [r6, #20] 30004130: e3130c01 tst r3, #256 ; 0x100
30004134: 0a00003e beq 30004234 <readv+0x130> rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
30004138: e3130002 tst r3, #2
3000413c: 0a000036 beq 3000421c <readv+0x118>
/*
* Argument validation on IO vector
*/
if ( !iov )
30004140: e3510000 cmp r1, #0
30004144: 0a000034 beq 3000421c <readv+0x118>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
30004148: e3520000 cmp r2, #0
3000414c: da000032 ble 3000421c <readv+0x118>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
30004150: e3520b01 cmp r2, #1024 ; 0x400
30004154: ca000030 bgt 3000421c <readv+0x118>
30004158: e3a02000 mov r2, #0
rtems_set_errno_and_return_minus_one( EINVAL );
3000415c: 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 )
30004160: e1a03001 mov r3, r1 30004164: e3a07001 mov r7, #1 30004168: e1a01002 mov r1, r2 3000416c: ea000000 b 30004174 <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;
30004170: 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 )
30004174: e5930000 ldr r0, [r3]
* 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++ ) {
30004178: 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 )
3000417c: e3500000 cmp r0, #0
30004180: 0a000025 beq 3000421c <readv+0x118>
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
30004184: e5930004 ldr r0, [r3, #4]
* 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++ ) {
30004188: e2833008 add r3, r3, #8
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
3000418c: e081c000 add ip, r1, r0
if ( total < old )
30004190: e151000c cmp r1, ip
30004194: ca000020 bgt 3000421c <readv+0x118>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
30004198: e3500000 cmp r0, #0 3000419c: 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++ ) {
300041a0: e1540002 cmp r4, r2
300041a4: cafffff1 bgt 30004170 <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 ) {
300041a8: e3570000 cmp r7, #0
return 0;
300041ac: 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 ) {
300041b0: 1a00001d bne 3000422c <readv+0x128>
300041b4: e1a08007 mov r8, r7 300041b8: ea00000d b 300041f4 <readv+0xf0>
);
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
300041bc: 0a000006 beq 300041dc <readv+0xd8>
iop->offset += bytes;
300041c0: e286300c add r3, r6, #12
300041c4: e893000c ldm r3, {r2, r3}
300041c8: e0922000 adds r2, r2, r0
300041cc: e0a33fc0 adc r3, r3, r0, asr #31
300041d0: e586200c str r2, [r6, #12]
300041d4: e5863010 str r3, [r6, #16]
total += bytes;
300041d8: e0888000 add r8, r8, r0
}
if (bytes != iov[ v ].iov_len)
300041dc: e5953004 ldr r3, [r5, #4]
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
300041e0: e2855008 add r5, r5, #8
if ( bytes > 0 ) {
iop->offset += bytes;
total += bytes;
}
if (bytes != iov[ v ].iov_len)
300041e4: e1500003 cmp r0, r3
300041e8: 1a00000f bne 3000422c <readv+0x128>
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
300041ec: e1540007 cmp r4, r7
300041f0: da00000d ble 3000422c <readv+0x128>
bytes = (*iop->pathinfo.handlers->read_h)(
300041f4: e8950006 ldm r5, {r1, r2}
300041f8: e5963020 ldr r3, [r6, #32]
300041fc: e1a00006 mov r0, r6
30004200: e1a0e00f mov lr, pc
30004204: e593f008 ldr pc, [r3, #8]
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
30004208: e3500000 cmp r0, #0
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3000420c: e2877001 add r7, r7, #1
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
30004210: aaffffe9 bge 300041bc <readv+0xb8>
return -1;
30004214: e3e08000 mvn r8, #0
30004218: ea000003 b 3000422c <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 );
3000421c: eb002a9f bl 3000eca0 <__errno> 30004220: e3a03016 mov r3, #22 30004224: e5803000 str r3, [r0] 30004228: e3e08000 mvn r8, #0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
3000422c: e1a00008 mov r0, r8
30004230: 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 );
30004234: eb002a99 bl 3000eca0 <__errno> 30004238: e3a03009 mov r3, #9 3000423c: e5803000 str r3, [r0] 30004240: e3e08000 mvn r8, #0 30004244: eafffff8 b 3000422c <readv+0x128>
300134f8 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
300134f8: 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())) {
300134fc: e59f2118 ldr r2, [pc, #280] ; 3001361c <realloc+0x124>
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30013500: e59f5118 ldr r5, [pc, #280] ; 30013620 <realloc+0x128>
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
30013504: e5922000 ldr r2, [r2]
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30013508: 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())) {
3001350c: e3520003 cmp r2, #3
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30013510: e2833001 add r3, r3, #1
void *realloc(
void *ptr,
size_t size
)
{
30013514: e24dd004 sub sp, sp, #4 30013518: e1a04000 mov r4, r0 3001351c: e1a06001 mov r6, r1
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30013520: 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())) {
30013524: 0a000020 beq 300135ac <realloc+0xb4>
}
/*
* Continue with realloc().
*/
if ( !ptr )
30013528: e3540000 cmp r4, #0
3001352c: 0a00001a beq 3001359c <realloc+0xa4>
return malloc( size );
if ( !size ) {
30013530: e3560000 cmp r6, #0
30013534: 0a00000f beq 30013578 <realloc+0x80>
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
30013538: e59f70e4 ldr r7, [pc, #228] ; 30013624 <realloc+0x12c> 3001353c: e1a01004 mov r1, r4 30013540: e5970000 ldr r0, [r7] 30013544: e1a0200d mov r2, sp 30013548: eb000065 bl 300136e4 <_Protected_heap_Get_block_size> 3001354c: e2508000 subs r8, r0, #0
30013550: 0a00000c beq 30013588 <realloc+0x90>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
30013554: e5970000 ldr r0, [r7] 30013558: e1a01004 mov r1, r4 3001355c: e1a02006 mov r2, r6 30013560: eb000070 bl 30013728 <_Protected_heap_Resize_block> 30013564: e3500000 cmp r0, #0
30013568: 0a00001a beq 300135d8 <realloc+0xe0>
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
3001356c: e1a00004 mov r0, r4
30013570: e28dd004 add sp, sp, #4
30013574: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
*/
if ( !ptr )
return malloc( size );
if ( !size ) {
free( ptr );
30013578: e1a00004 mov r0, r4 <== NOT EXECUTED 3001357c: ebffbaa1 bl 30002008 <free> <== NOT EXECUTED
return (void *) 0;
30013580: e1a04006 mov r4, r6 <== NOT EXECUTED 30013584: eafffff8 b 3001356c <realloc+0x74> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
30013588: ebffe99a bl 3000dbf8 <__errno> 3001358c: e3a03016 mov r3, #22 30013590: e5803000 str r3, [r0]
return (void *) 0;
30013594: e1a04008 mov r4, r8 30013598: eafffff3 b 3001356c <realloc+0x74>
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
3001359c: e1a00006 mov r0, r6 300135a0: ebffbb72 bl 30002370 <malloc> 300135a4: e1a04000 mov r4, r0 300135a8: eaffffef b 3001356c <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)
300135ac: e59f3074 ldr r3, [pc, #116] ; 30013628 <realloc+0x130> 300135b0: e5933000 ldr r3, [r3] 300135b4: e3530000 cmp r3, #0
return (void *) 0;
300135b8: 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)
300135bc: 1affffea bne 3001356c <realloc+0x74>
return (void *) 0;
if (_ISR_Nest_level > 0)
300135c0: e59f2064 ldr r2, [pc, #100] ; 3001362c <realloc+0x134> 300135c4: e5922000 ldr r2, [r2] 300135c8: e3520000 cmp r2, #0
return (void *) 0;
300135cc: 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)
300135d0: 0affffd4 beq 30013528 <realloc+0x30>
300135d4: eaffffe4 b 3001356c <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 );
300135d8: e1a00006 mov r0, r6 300135dc: ebffbb63 bl 30002370 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
300135e0: e5953004 ldr r3, [r5, #4]
if ( !new_area ) {
300135e4: e2507000 subs r7, r0, #0
* and the C Standard.
*/
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
300135e8: e2433001 sub r3, r3, #1 300135ec: e5853004 str r3, [r5, #4]
if ( !new_area ) {
return (void *) 0;
300135f0: 01a04007 moveq r4, r7
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
300135f4: 0affffdc beq 3001356c <realloc+0x74>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
300135f8: e59d2000 ldr r2, [sp] 300135fc: e1a01004 mov r1, r4 30013600: e1560002 cmp r6, r2 30013604: 31a02006 movcc r2, r6 30013608: ebffeba8 bl 3000e4b0 <memcpy>
free( ptr );
3001360c: e1a00004 mov r0, r4 30013610: ebffba7c bl 30002008 <free>
return new_area;
30013614: e1a04007 mov r4, r7 30013618: eaffffd3 b 3001356c <realloc+0x74>
30006914 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
30006914: 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);
30006918: e59f41c4 ldr r4, [pc, #452] ; 30006ae4 <rtems_aio_enqueue+0x1d0>
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
3000691c: e24dd024 sub sp, sp, #36 ; 0x24 30006920: 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);
30006924: e1a00004 mov r0, r4 30006928: eb000255 bl 30007284 <pthread_mutex_lock>
if (result != 0) {
3000692c: e2505000 subs r5, r0, #0
30006930: 1a00002a bne 300069e0 <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);
30006934: eb000484 bl 30007b4c <pthread_self> 30006938: e28d101c add r1, sp, #28 3000693c: e1a0200d mov r2, sp 30006940: eb00037e bl 30007740 <pthread_getschedparam>
req->caller_thread = pthread_self ();
30006944: eb000480 bl 30007b4c <pthread_self>
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
30006948: e5963014 ldr r3, [r6, #20] 3000694c: e59dc000 ldr ip, [sp] 30006950: e5932014 ldr r2, [r3, #20]
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
30006954: 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;
30006958: e062200c rsb r2, r2, ip 3000695c: e586200c str r2, [r6, #12]
req->policy = policy;
30006960: e59d201c ldr r2, [sp, #28]
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
30006964: 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;
30006968: e5862008 str r2, [r6, #8]
req->aiocbp->error_code = EINPROGRESS;
3000696c: 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 ();
30006970: e5860010 str r0, [r6, #16]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio; req->policy = policy; req->aiocbp->error_code = EINPROGRESS;
30006974: e5832030 str r2, [r3, #48] ; 0x30
req->aiocbp->return_value = 0;
30006978: e5835034 str r5, [r3, #52] ; 0x34
if ((aio_request_queue.idle_threads == 0) &&
3000697c: 1a000002 bne 3000698c <rtems_aio_enqueue+0x78>
30006980: e5942064 ldr r2, [r4, #100] ; 0x64 30006984: e3520004 cmp r2, #4
30006988: da000017 ble 300069ec <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,
3000698c: e59f0154 ldr r0, [pc, #340] ; 30006ae8 <rtems_aio_enqueue+0x1d4> 30006990: e5931000 ldr r1, [r3] 30006994: e3a02000 mov r2, #0 30006998: ebfffec3 bl 300064ac <rtems_aio_search_fd>
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
3000699c: e2507000 subs r7, r0, #0
300069a0: 0a00002e beq 30006a60 <rtems_aio_enqueue+0x14c>
{
pthread_mutex_lock (&r_chain->mutex);
300069a4: e287401c add r4, r7, #28 300069a8: e1a00004 mov r0, r4 300069ac: eb000234 bl 30007284 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
300069b0: e2870008 add r0, r7, #8 300069b4: e1a01006 mov r1, r6 300069b8: ebffff90 bl 30006800 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
300069bc: e2870020 add r0, r7, #32 300069c0: eb000119 bl 30006e2c <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
300069c4: e1a00004 mov r0, r4 300069c8: eb00024e bl 30007308 <pthread_mutex_unlock>
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
300069cc: e59f0110 ldr r0, [pc, #272] ; 30006ae4 <rtems_aio_enqueue+0x1d0> 300069d0: eb00024c bl 30007308 <pthread_mutex_unlock>
return 0; }
300069d4: e1a00005 mov r0, r5
300069d8: e28dd024 add sp, sp, #36 ; 0x24
300069dc: 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);
300069e0: e1a00006 mov r0, r6 <== NOT EXECUTED 300069e4: ebfff0d3 bl 30002d38 <free> <== NOT EXECUTED
return result;
300069e8: eafffff9 b 300069d4 <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);
300069ec: e5931000 ldr r1, [r3] 300069f0: e2840048 add r0, r4, #72 ; 0x48 300069f4: e3a02001 mov r2, #1 300069f8: ebfffeab bl 300064ac <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
300069fc: e5903018 ldr r3, [r0, #24]
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);
30006a00: e1a07000 mov r7, r0
if (r_chain->new_fd == 1) {
30006a04: e3530001 cmp r3, #1
30006a08: 1affffe5 bne 300069a4 <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);
30006a0c: e1a01006 mov r1, r6 30006a10: e2800008 add r0, r0, #8 30006a14: eb00089c bl 30008c8c <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL);
30006a18: 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;
30006a1c: e5875018 str r5, [r7, #24]
pthread_mutex_init (&r_chain->mutex, NULL);
30006a20: e287001c add r0, r7, #28 30006a24: eb0001c3 bl 30007138 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
30006a28: e1a01005 mov r1, r5 30006a2c: e2870020 add r0, r7, #32 30006a30: eb0000cd bl 30006d6c <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
30006a34: e28d0020 add r0, sp, #32 30006a38: e2841008 add r1, r4, #8 30006a3c: e59f20a8 ldr r2, [pc, #168] ; 30006aec <rtems_aio_enqueue+0x1d8> 30006a40: e1a03007 mov r3, r7 30006a44: eb000295 bl 300074a0 <pthread_create>
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
30006a48: e2506000 subs r6, r0, #0
30006a4c: 1a000020 bne 30006ad4 <rtems_aio_enqueue+0x1c0> pthread_mutex_unlock (&aio_request_queue.mutex); return result; } ++aio_request_queue.active_threads;
30006a50: e5943064 ldr r3, [r4, #100] ; 0x64 30006a54: e2833001 add r3, r3, #1 30006a58: e5843064 str r3, [r4, #100] ; 0x64 30006a5c: eaffffda b 300069cc <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);
30006a60: e5963014 ldr r3, [r6, #20] 30006a64: e59f0084 ldr r0, [pc, #132] ; 30006af0 <rtems_aio_enqueue+0x1dc> 30006a68: e5931000 ldr r1, [r3] 30006a6c: e3a02001 mov r2, #1 30006a70: ebfffe8d bl 300064ac <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
30006a74: e5903018 ldr r3, [r0, #24]
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
30006a78: e1a08000 mov r8, r0
if (r_chain->new_fd == 1) {
30006a7c: e3530001 cmp r3, #1
30006a80: 0a000003 beq 30006a94 <rtems_aio_enqueue+0x180> pthread_cond_init (&r_chain->cond, NULL); pthread_cond_signal (&aio_request_queue.new_req); ++aio_request_queue.idle_threads; } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req);
30006a84: e2800008 add r0, r0, #8 30006a88: e1a01006 mov r1, r6 30006a8c: ebffff5b bl 30006800 <rtems_aio_insert_prio> 30006a90: eaffffcd b 300069cc <rtems_aio_enqueue+0xb8> 30006a94: e2800008 add r0, r0, #8 30006a98: e1a01006 mov r1, r6 30006a9c: eb00087a bl 30008c8c <_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);
30006aa0: 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;
30006aa4: e5887018 str r7, [r8, #24]
pthread_mutex_init (&r_chain->mutex, NULL);
30006aa8: e288001c add r0, r8, #28 30006aac: eb0001a1 bl 30007138 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
30006ab0: e1a01007 mov r1, r7 30006ab4: e2880020 add r0, r8, #32 30006ab8: eb0000ab bl 30006d6c <pthread_cond_init>
pthread_cond_signal (&aio_request_queue.new_req);
30006abc: e59f0030 ldr r0, [pc, #48] ; 30006af4 <rtems_aio_enqueue+0x1e0> 30006ac0: eb0000d9 bl 30006e2c <pthread_cond_signal>
++aio_request_queue.idle_threads;
30006ac4: e5943068 ldr r3, [r4, #104] ; 0x68 30006ac8: e2833001 add r3, r3, #1 30006acc: e5843068 str r3, [r4, #104] ; 0x68 30006ad0: eaffffbd b 300069cc <rtems_aio_enqueue+0xb8>
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);
30006ad4: e1a00004 mov r0, r4 <== NOT EXECUTED 30006ad8: eb00020a bl 30007308 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
30006adc: e1a05006 mov r5, r6 <== NOT EXECUTED 30006ae0: eaffffbb b 300069d4 <rtems_aio_enqueue+0xc0> <== NOT EXECUTED
30006578 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
30006578: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3000657c: e24dd02c sub sp, sp, #44 ; 0x2c <== NOT EXECUTED
30006580: e1a05000 mov r5, r0 <== NOT EXECUTED
30006584: e280601c add r6, r0, #28 <== NOT EXECUTED
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
30006588: e28d8028 add r8, sp, #40 ; 0x28 <== NOT EXECUTED 3000658c: e28d7004 add r7, sp, #4 <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
30006590: e3e0b000 mvn fp, #0 <== NOT EXECUTED
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
req->aiocbp->error_code = 0;
30006594: e3a09000 mov r9, #0 <== 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);
30006598: e1a00006 mov r0, r6 <== NOT EXECUTED 3000659c: eb000338 bl 30007284 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
300065a0: e250a000 subs sl, r0, #0 <== NOT EXECUTED 300065a4: 1a000021 bne 30006630 <rtems_aio_handle+0xb8> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
300065a8: e5954008 ldr r4, [r5, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
300065ac: e285300c add r3, r5, #12 <== NOT EXECUTED
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
300065b0: e1540003 cmp r4, r3 <== NOT EXECUTED 300065b4: 0a000038 beq 3000669c <rtems_aio_handle+0x124> <== NOT EXECUTED
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
300065b8: eb000563 bl 30007b4c <pthread_self> <== NOT EXECUTED 300065bc: e1a01008 mov r1, r8 <== NOT EXECUTED 300065c0: e1a02007 mov r2, r7 <== NOT EXECUTED 300065c4: eb00045d bl 30007740 <pthread_getschedparam> <== NOT EXECUTED
param.sched_priority = req->priority;
300065c8: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 300065cc: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
pthread_setschedparam (pthread_self(), req->policy, ¶m);
300065d0: eb00055d bl 30007b4c <pthread_self> <== NOT EXECUTED 300065d4: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 300065d8: e1a02007 mov r2, r7 <== NOT EXECUTED 300065dc: eb00055f bl 30007b60 <pthread_setschedparam> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
300065e0: e1a00004 mov r0, r4 <== NOT EXECUTED 300065e4: eb000993 bl 30008c38 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
300065e8: e1a00006 mov r0, r6 <== NOT EXECUTED 300065ec: eb000345 bl 30007308 <pthread_mutex_unlock> <== NOT EXECUTED
switch (req->aiocbp->aio_lio_opcode) {
300065f0: e594a014 ldr sl, [r4, #20] <== NOT EXECUTED 300065f4: e59a302c ldr r3, [sl, #44] ; 0x2c <== NOT EXECUTED 300065f8: e3530002 cmp r3, #2 <== NOT EXECUTED 300065fc: 0a00001e beq 3000667c <rtems_aio_handle+0x104> <== NOT EXECUTED 30006600: e3530003 cmp r3, #3 <== NOT EXECUTED 30006604: 0a000019 beq 30006670 <rtems_aio_handle+0xf8> <== NOT EXECUTED 30006608: e3530001 cmp r3, #1 <== NOT EXECUTED 3000660c: 0a00000a beq 3000663c <rtems_aio_handle+0xc4> <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
30006610: e58ab034 str fp, [sl, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = errno;
30006614: eb002886 bl 30010834 <__errno> <== NOT EXECUTED 30006618: 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);
3000661c: e1a00006 mov r0, r6 <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
30006620: 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);
30006624: eb000316 bl 30007284 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
30006628: e250a000 subs sl, r0, #0 <== NOT EXECUTED 3000662c: 0affffdd beq 300065a8 <rtems_aio_handle+0x30> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
30006630: e3a00000 mov r0, #0 <== NOT EXECUTED
30006634: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
30006638: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
case LIO_READ:
result = pread (req->aiocbp->aio_fildes,
3000663c: e59ac008 ldr ip, [sl, #8] <== NOT EXECUTED 30006640: e59a0000 ldr r0, [sl] <== NOT EXECUTED 30006644: e59a100c ldr r1, [sl, #12] <== NOT EXECUTED 30006648: e59a2010 ldr r2, [sl, #16] <== NOT EXECUTED 3000664c: e59a3004 ldr r3, [sl, #4] <== NOT EXECUTED 30006650: e58dc000 str ip, [sp] <== NOT EXECUTED 30006654: eb002b78 bl 3001143c <pread> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
30006658: e3700001 cmn r0, #1 <== NOT EXECUTED 3000665c: 0a00005e beq 300067dc <rtems_aio_handle+0x264> <== NOT EXECUTED
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
30006660: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 30006664: e5830034 str r0, [r3, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = 0;
30006668: e5839030 str r9, [r3, #48] ; 0x30 <== NOT EXECUTED 3000666c: eaffffc9 b 30006598 <rtems_aio_handle+0x20> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
result = fsync (req->aiocbp->aio_fildes);
30006670: e59a0000 ldr r0, [sl] <== NOT EXECUTED 30006674: eb001ad7 bl 3000d1d8 <fsync> <== NOT EXECUTED
break;
30006678: eafffff6 b 30006658 <rtems_aio_handle+0xe0> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
result = pwrite (req->aiocbp->aio_fildes,
3000667c: e59ac008 ldr ip, [sl, #8] <== NOT EXECUTED 30006680: e59a0000 ldr r0, [sl] <== NOT EXECUTED 30006684: e59a100c ldr r1, [sl, #12] <== NOT EXECUTED 30006688: e59a2010 ldr r2, [sl, #16] <== NOT EXECUTED 3000668c: e59a3004 ldr r3, [sl, #4] <== NOT EXECUTED 30006690: e58dc000 str ip, [sp] <== NOT EXECUTED 30006694: eb002bb0 bl 3001155c <pwrite> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
30006698: eaffffee b 30006658 <rtems_aio_handle+0xe0> <== NOT EXECUTED
wait for a signal on chain, this will unlock the queue.
The fd chain is already unlocked */
struct timespec timeout;
pthread_mutex_unlock (&r_chain->mutex);
3000669c: e1a00006 mov r0, r6 <== NOT EXECUTED 300066a0: eb000318 bl 30007308 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
300066a4: e59f0144 ldr r0, [pc, #324] ; 300067f0 <rtems_aio_handle+0x278><== NOT EXECUTED 300066a8: eb0002f5 bl 30007284 <pthread_mutex_lock> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
300066ac: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 300066b0: e1540003 cmp r4, r3 <== NOT EXECUTED 300066b4: 1affffb7 bne 30006598 <rtems_aio_handle+0x20> <== NOT EXECUTED
{
clock_gettime (CLOCK_REALTIME, &timeout);
300066b8: e28d1020 add r1, sp, #32 <== NOT EXECUTED 300066bc: e3a00001 mov r0, #1 <== NOT EXECUTED 300066c0: eb000154 bl 30006c18 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
300066c4: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
300066c8: e2854020 add r4, r5, #32 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
300066cc: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
300066d0: e1a00004 mov r0, r4 <== NOT EXECUTED 300066d4: e59f1114 ldr r1, [pc, #276] ; 300067f0 <rtems_aio_handle+0x278><== NOT EXECUTED 300066d8: e28d2020 add r2, sp, #32 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
300066dc: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
300066e0: e58da024 str sl, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&r_chain->cond,
300066e4: eb0001ea bl 30006e94 <pthread_cond_timedwait> <== NOT EXECUTED
&aio_request_queue.mutex, &timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
300066e8: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED 300066ec: 1affffa9 bne 30006598 <rtems_aio_handle+0x20> <== NOT EXECUTED 300066f0: e1a00005 mov r0, r5 <== NOT EXECUTED 300066f4: eb00094f bl 30008c38 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex);
300066f8: e1a00006 mov r0, r6 <== NOT EXECUTED 300066fc: eb00023d bl 30006ff8 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
30006700: e1a00004 mov r0, r4 <== NOT EXECUTED 30006704: eb000165 bl 30006ca0 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
30006708: e1a00005 mov r0, r5 <== NOT EXECUTED 3000670c: ebfff189 bl 30002d38 <free> <== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
30006710: e59f20d8 ldr r2, [pc, #216] ; 300067f0 <rtems_aio_handle+0x278><== NOT EXECUTED 30006714: e5923054 ldr r3, [r2, #84] ; 0x54 <== NOT EXECUTED 30006718: e59f20d4 ldr r2, [pc, #212] ; 300067f4 <rtems_aio_handle+0x27c><== NOT EXECUTED 3000671c: e1530002 cmp r3, r2 <== NOT EXECUTED 30006720: 0a000002 beq 30006730 <rtems_aio_handle+0x1b8> <== NOT EXECUTED
r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd; } else /* If there was a request added in the initial fd chain then release the mutex and process it */ pthread_mutex_unlock (&aio_request_queue.mutex);
30006724: e59f00c4 ldr r0, [pc, #196] ; 300067f0 <rtems_aio_handle+0x278><== NOT EXECUTED 30006728: eb0002f6 bl 30007308 <pthread_mutex_unlock> <== NOT EXECUTED 3000672c: eaffff99 b 30006598 <rtems_aio_handle+0x20> <== NOT EXECUTED
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)) {
++aio_request_queue.idle_threads;
30006730: e59f20b8 ldr r2, [pc, #184] ; 300067f0 <rtems_aio_handle+0x278><== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
30006734: e28d1020 add r1, sp, #32 <== NOT EXECUTED
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)) {
++aio_request_queue.idle_threads;
30006738: e5923068 ldr r3, [r2, #104] ; 0x68 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
3000673c: e3a00001 mov r0, #1 <== NOT EXECUTED
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)) {
++aio_request_queue.idle_threads;
30006740: e2833001 add r3, r3, #1 <== NOT EXECUTED 30006744: e5823068 str r3, [r2, #104] ; 0x68 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
30006748: eb000132 bl 30006c18 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
3000674c: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&aio_request_queue.new_req,
30006750: e59f00a0 ldr r0, [pc, #160] ; 300067f8 <rtems_aio_handle+0x280><== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
++aio_request_queue.idle_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
30006754: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&aio_request_queue.new_req,
30006758: e59f1090 ldr r1, [pc, #144] ; 300067f0 <rtems_aio_handle+0x278><== NOT EXECUTED 3000675c: e28d2020 add r2, sp, #32 <== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
++aio_request_queue.idle_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
30006760: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
30006764: e58da024 str sl, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&aio_request_queue.new_req,
30006768: eb0001c9 bl 30006e94 <pthread_cond_timedwait> <== NOT EXECUTED
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
3000676c: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED 30006770: 0a00001b beq 300067e4 <rtems_aio_handle+0x26c> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
30006774: e59f3074 ldr r3, [pc, #116] ; 300067f0 <rtems_aio_handle+0x278><== NOT EXECUTED
return NULL; } /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads;
30006778: e59f2070 ldr r2, [pc, #112] ; 300067f0 <rtems_aio_handle+0x278><== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000677c: e5934054 ldr r4, [r3, #84] ; 0x54 <== NOT EXECUTED
return NULL; } /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads;
30006780: e5933068 ldr r3, [r3, #104] ; 0x68 <== NOT EXECUTED 30006784: e1a00004 mov r0, r4 <== NOT EXECUTED 30006788: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000678c: e5823068 str r3, [r2, #104] ; 0x68 <== NOT EXECUTED 30006790: eb000928 bl 30008c38 <_Chain_Extract> <== NOT EXECUTED
node = rtems_chain_first (&aio_request_queue.idle_req); rtems_chain_extract (node); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
30006794: e3a02001 mov r2, #1 <== NOT EXECUTED 30006798: e5941014 ldr r1, [r4, #20] <== NOT EXECUTED 3000679c: e59f0058 ldr r0, [pc, #88] ; 300067fc <rtems_aio_handle+0x284><== NOT EXECUTED 300067a0: ebffff41 bl 300064ac <rtems_aio_search_fd> <== NOT EXECUTED
((rtems_aio_request_chain *)node)->fildes, 1); r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL);
300067a4: e280601c add r6, r0, #28 <== NOT EXECUTED
/* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads; node = rtems_chain_first (&aio_request_queue.idle_req); rtems_chain_extract (node); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
300067a8: e1a05000 mov r5, r0 <== NOT EXECUTED
((rtems_aio_request_chain *)node)->fildes, 1); r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL);
300067ac: e1a0100a mov r1, sl <== NOT EXECUTED
node = rtems_chain_first (&aio_request_queue.idle_req); rtems_chain_extract (node); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, ((rtems_aio_request_chain *)node)->fildes, 1); r_chain->new_fd = 0;
300067b0: e580a018 str sl, [r0, #24] <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
300067b4: e1a00006 mov r0, r6 <== NOT EXECUTED 300067b8: eb00025e bl 30007138 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
300067bc: e1a0100a mov r1, sl <== NOT EXECUTED 300067c0: e2850020 add r0, r5, #32 <== NOT EXECUTED 300067c4: eb000168 bl 30006d6c <pthread_cond_init> <== NOT EXECUTED
r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd;
300067c8: e2844008 add r4, r4, #8 <== NOT EXECUTED
300067cc: e2853008 add r3, r5, #8 <== NOT EXECUTED
300067d0: e8940007 ldm r4, {r0, r1, r2} <== NOT EXECUTED
300067d4: e8830007 stm r3, {r0, r1, r2} <== NOT EXECUTED
300067d8: eaffff6e b 30006598 <rtems_aio_handle+0x20> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
300067dc: e594a014 ldr sl, [r4, #20] <== NOT EXECUTED 300067e0: eaffff8a b 30006610 <rtems_aio_handle+0x98> <== NOT EXECUTED
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
pthread_mutex_unlock (&aio_request_queue.mutex);
300067e4: e59f0004 ldr r0, [pc, #4] ; 300067f0 <rtems_aio_handle+0x278><== NOT EXECUTED 300067e8: eb0002c6 bl 30007308 <pthread_mutex_unlock> <== NOT EXECUTED
return NULL;
300067ec: eaffff8f b 30006630 <rtems_aio_handle+0xb8> <== NOT EXECUTED
300063a8 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
300063a8: e92d4030 push {r4, r5, lr}
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
300063ac: e59f00e4 ldr r0, [pc, #228] ; 30006498 <rtems_aio_init+0xf0> 300063b0: eb00041a bl 30007420 <pthread_attr_init>
if (result != 0)
300063b4: e2505000 subs r5, r0, #0
300063b8: 0a000001 beq 300063c4 <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;
}
300063bc: e1a00005 mov r0, r5 <== NOT EXECUTED
300063c0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
result = pthread_attr_init (&aio_request_queue.attr);
if (result != 0)
return result;
result =
300063c4: e59f00cc ldr r0, [pc, #204] ; 30006498 <rtems_aio_init+0xf0> 300063c8: e1a01005 mov r1, r5 300063cc: eb000426 bl 3000746c <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
300063d0: e3500000 cmp r0, #0
300063d4: 1a00001b bne 30006448 <rtems_aio_init+0xa0>
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
300063d8: e59f40bc ldr r4, [pc, #188] ; 3000649c <rtems_aio_init+0xf4> 300063dc: e3a01000 mov r1, #0 300063e0: e1a00004 mov r0, r4 300063e4: eb000353 bl 30007138 <pthread_mutex_init>
if (result != 0)
300063e8: e3500000 cmp r0, #0
300063ec: 1a00001d bne 30006468 <rtems_aio_init+0xc0>
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
300063f0: e59f00a8 ldr r0, [pc, #168] ; 300064a0 <rtems_aio_init+0xf8> 300063f4: e3a01000 mov r1, #0 300063f8: eb00025b bl 30006d6c <pthread_cond_init>
if (result != 0) {
300063fc: e2505000 subs r5, r0, #0
30006400: 1a00001f bne 30006484 <rtems_aio_init+0xdc>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
30006404: e59f2098 ldr r2, [pc, #152] ; 300064a4 <rtems_aio_init+0xfc>
head->previous = NULL;
30006408: e3a03000 mov r3, #0 3000640c: e584304c str r3, [r4, #76] ; 0x4c 30006410: 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;
30006414: e5843064 str r3, [r4, #100] ; 0x64
aio_request_queue.idle_threads = 0;
30006418: e5843068 str r3, [r4, #104] ; 0x68
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
3000641c: e59f3084 ldr r3, [pc, #132] ; 300064a8 <rtems_aio_init+0x100>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
30006420: e282000c add r0, r2, #12
head->previous = NULL; tail->previous = head;
30006424: e242c004 sub ip, r2, #4 30006428: e2821008 add r1, r2, #8
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000642c: e5840054 str r0, [r4, #84] ; 0x54 30006430: e5842048 str r2, [r4, #72] ; 0x48
head->previous = NULL; tail->previous = head;
30006434: e584c050 str ip, [r4, #80] ; 0x50 30006438: e584105c str r1, [r4, #92] ; 0x5c 3000643c: e5843060 str r3, [r4, #96] ; 0x60
return result;
}
30006440: e1a00005 mov r0, r5
30006444: e8bd8030 pop {r4, r5, pc}
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
30006448: e59f404c ldr r4, [pc, #76] ; 3000649c <rtems_aio_init+0xf4>
result =
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
3000644c: e59f0044 ldr r0, [pc, #68] ; 30006498 <rtems_aio_init+0xf0>
30006450: eb0003e9 bl 300073fc <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
30006454: e3a01000 mov r1, #0 <== NOT EXECUTED 30006458: e1a00004 mov r0, r4 <== NOT EXECUTED 3000645c: eb000335 bl 30007138 <pthread_mutex_init> <== NOT EXECUTED
if (result != 0)
30006460: e3500000 cmp r0, #0 <== NOT EXECUTED 30006464: 0affffe1 beq 300063f0 <rtems_aio_init+0x48> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
30006468: e2840008 add r0, r4, #8 <== NOT EXECUTED 3000646c: eb0003e2 bl 300073fc <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
30006470: e59f0028 ldr r0, [pc, #40] ; 300064a0 <rtems_aio_init+0xf8><== NOT EXECUTED 30006474: e3a01000 mov r1, #0 <== NOT EXECUTED 30006478: eb00023b bl 30006d6c <pthread_cond_init> <== NOT EXECUTED
if (result != 0) {
3000647c: e2505000 subs r5, r0, #0 <== NOT EXECUTED 30006480: 0affffdf beq 30006404 <rtems_aio_init+0x5c> <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
30006484: e59f0010 ldr r0, [pc, #16] ; 3000649c <rtems_aio_init+0xf4><== NOT EXECUTED 30006488: eb0002da bl 30006ff8 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
3000648c: e59f0004 ldr r0, [pc, #4] ; 30006498 <rtems_aio_init+0xf0> <== NOT EXECUTED 30006490: eb0003d9 bl 300073fc <pthread_attr_destroy> <== NOT EXECUTED 30006494: eaffffda b 30006404 <rtems_aio_init+0x5c> <== NOT EXECUTED
30006800 <rtems_aio_insert_prio>:
}
AIO_printf ("Thread finished\n");
return NULL;
}
30006800: e1a02000 mov r2, r0 30006804: e4923004 ldr r3, [r2], #4
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
30006808: e1a0c001 mov ip, r1
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
3000680c: e1530002 cmp r3, r2
30006810: 0a00000f beq 30006854 <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 &&
30006814: 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;
30006818: e5931014 ldr r1, [r3, #20]
while (req->aiocbp->aio_reqprio > prio &&
3000681c: e5900014 ldr r0, [r0, #20] 30006820: e5911014 ldr r1, [r1, #20] 30006824: e1510000 cmp r1, r0
30006828: ba000002 blt 30006838 <rtems_aio_insert_prio+0x38>
3000682c: ea000006 b 3000684c <rtems_aio_insert_prio+0x4c>
30006830: e1530002 cmp r3, r2 <== NOT EXECUTED 30006834: 0a000004 beq 3000684c <rtems_aio_insert_prio+0x4c> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
30006838: e5933000 ldr r3, [r3] <== 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;
3000683c: e5931014 ldr r1, [r3, #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 &&
30006840: e5911014 ldr r1, [r1, #20] <== NOT EXECUTED 30006844: e1510000 cmp r1, r0 <== NOT EXECUTED 30006848: bafffff8 blt 30006830 <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 );
3000684c: e5930004 ldr r0, [r3, #4] 30006850: e1a0100c mov r1, ip 30006854: ea00090c b 30008c8c <_Chain_Insert>
30006858 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
30006858: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000685c: e5904008 ldr r4, [r0, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
30006860: e280000c add r0, r0, #12 <== NOT EXECUTED
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
30006864: e1540000 cmp r4, r0 <== NOT EXECUTED
30006868: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
3000686c: e1a00004 mov r0, r4 <== NOT EXECUTED 30006870: eb0008f0 bl 30008c38 <_Chain_Extract> <== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
30006874: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 30006878: e3a0608c mov r6, #140 ; 0x8c <== NOT EXECUTED
req->aiocbp->return_value = -1;
3000687c: e3e05000 mvn r5, #0 <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
30006880: e5836030 str r6, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = -1;
30006884: e5835034 str r5, [r3, #52] ; 0x34 <== NOT EXECUTED
free (req);
30006888: e1a00004 mov r0, r4 <== NOT EXECUTED 3000688c: ebfff129 bl 30002d38 <free> <== NOT EXECUTED 30006890: e1a00004 mov r0, r4 <== NOT EXECUTED 30006894: eb0008e7 bl 30008c38 <_Chain_Extract> <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
30006898: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
req->aiocbp->return_value = -1;
free (req);
3000689c: e1a00004 mov r0, r4 <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
300068a0: e5836030 str r6, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = -1;
300068a4: e5835034 str r5, [r3, #52] ; 0x34 <== NOT EXECUTED
free (req);
300068a8: ebfff122 bl 30002d38 <free> <== NOT EXECUTED 300068ac: eafffff7 b 30006890 <rtems_aio_remove_fd+0x38> <== NOT EXECUTED
300068b0 <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)
{
300068b0: e92d4010 push {r4, lr} <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
300068b4: e4904004 ldr r4, [r0], #4 <== 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) {
300068b8: e1540000 cmp r4, r0 <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
300068bc: 03a00001 moveq r0, #1 <== 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) {
300068c0: 1a000003 bne 300068d4 <rtems_aio_remove_req+0x24> <== NOT EXECUTED
300068c4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
300068c8: e5944000 ldr r4, [r4] <== 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) {
300068cc: e1540000 cmp r4, r0 <== NOT EXECUTED 300068d0: 0a00000d beq 3000690c <rtems_aio_remove_req+0x5c> <== NOT EXECUTED 300068d4: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 300068d8: e1530001 cmp r3, r1 <== NOT EXECUTED 300068dc: 1afffff9 bne 300068c8 <rtems_aio_remove_req+0x18> <== NOT EXECUTED 300068e0: e1a00004 mov r0, r4 <== NOT EXECUTED 300068e4: eb0008d3 bl 30008c38 <_Chain_Extract> <== NOT EXECUTED
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
300068e8: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 300068ec: e3a0208c mov r2, #140 ; 0x8c <== NOT EXECUTED 300068f0: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED
current->aiocbp->return_value = -1;
300068f4: e3e02000 mvn r2, #0 <== NOT EXECUTED
free (current);
300068f8: e1a00004 mov r0, r4 <== NOT EXECUTED
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
current->aiocbp->return_value = -1;
300068fc: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
free (current);
30006900: ebfff10c bl 30002d38 <free> <== NOT EXECUTED
}
return AIO_CANCELED;
30006904: e3a00000 mov r0, #0 <== NOT EXECUTED
30006908: e8bd8010 pop {r4, pc} <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
3000690c: e3a00001 mov r0, #1 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
30006910: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30002bfc <rtems_assoc_ptr_by_name>:
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
30002bfc: e92d41f0 push {r4, r5, r6, r7, r8, lr}
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30002c00: e5904000 ldr r4, [r0]
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
30002c04: e1a06000 mov r6, r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30002c08: e3540000 cmp r4, #0
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
30002c0c: e1a07001 mov r7, r1
const rtems_assoc_t *default_ap = 0;
30002c10: 01a06004 moveq r6, r4
if (rtems_assoc_is_default(ap))
30002c14: 0a000011 beq 30002c60 <rtems_assoc_ptr_by_name+0x64>
30002c18: e1a00004 mov r0, r4 30002c1c: e59f106c ldr r1, [pc, #108] ; 30002c90 <rtems_assoc_ptr_by_name+0x94> 30002c20: eb0032a7 bl 3000f6c4 <strcmp> 30002c24: 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;
30002c28: 13a08000 movne r8, #0
if (rtems_assoc_is_default(ap))
30002c2c: 0a00000d beq 30002c68 <rtems_assoc_ptr_by_name+0x6c>
default_ap = ap++;
for ( ; ap->name; ap++)
30002c30: e1a05006 mov r5, r6 30002c34: ea000003 b 30002c48 <rtems_assoc_ptr_by_name+0x4c> 30002c38: e595400c ldr r4, [r5, #12] 30002c3c: e285500c add r5, r5, #12 30002c40: e3540000 cmp r4, #0
30002c44: 0a00000e beq 30002c84 <rtems_assoc_ptr_by_name+0x88>
if (strcmp(ap->name, name) == 0)
30002c48: e1a00004 mov r0, r4 30002c4c: e1a01007 mov r1, r7 30002c50: eb00329b bl 3000f6c4 <strcmp> 30002c54: e3500000 cmp r0, #0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
30002c58: e1a06005 mov r6, r5
if (strcmp(ap->name, name) == 0)
30002c5c: 1afffff5 bne 30002c38 <rtems_assoc_ptr_by_name+0x3c>
return ap;
return default_ap;
}
30002c60: e1a00006 mov r0, r6
30002c64: 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++)
30002c68: e596400c ldr r4, [r6, #12]
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
30002c6c: e286300c add r3, r6, #12
for ( ; ap->name; ap++)
30002c70: e3540000 cmp r4, #0 30002c74: 11a08006 movne r8, r6 30002c78: 11a06003 movne r6, r3
30002c7c: 1affffeb bne 30002c30 <rtems_assoc_ptr_by_name+0x34>
30002c80: eafffff6 b 30002c60 <rtems_assoc_ptr_by_name+0x64> <== NOT EXECUTED
30002c84: e1a06008 mov r6, r8
if (strcmp(ap->name, name) == 0)
return ap;
return default_ap;
}
30002c88: e1a00006 mov r0, r6
30002c8c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
30001f64 <rtems_filesystem_dirname>:
int rtems_filesystem_dirname(
const char *pathname
)
{
30001f64: e92d4030 push {r4, r5, lr}
30001f68: e1a05000 mov r5, r0
int len = strlen( pathname );
30001f6c: eb00330b bl 3000eba0 <strlen>
while ( len ) {
30001f70: e2504000 subs r4, r0, #0
30001f74: 1a000002 bne 30001f84 <rtems_filesystem_dirname+0x20>
30001f78: ea000006 b 30001f98 <rtems_filesystem_dirname+0x34> <== NOT EXECUTED
30001f7c: e3540000 cmp r4, #0
30001f80: 0a000004 beq 30001f98 <rtems_filesystem_dirname+0x34>
len--;
30001f84: e2444001 sub r4, r4, #1
if ( rtems_filesystem_is_separator( pathname[len] ) )
30001f88: e7d50004 ldrb r0, [r5, r4] 30001f8c: eb0003d3 bl 30002ee0 <rtems_filesystem_is_separator> 30001f90: e3500000 cmp r0, #0
30001f94: 0afffff8 beq 30001f7c <rtems_filesystem_dirname+0x18>
break;
}
return len;
}
30001f98: e1a00004 mov r0, r4
30001f9c: e8bd8030 pop {r4, r5, pc}
30001d3c <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 )
{
30001d3c: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_filesystem_umask = 022;
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
30001d40: e59f20e8 ldr r2, [pc, #232] ; 30001e30 <rtems_filesystem_initialize+0xf4>
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
30001d44: e59f60e8 ldr r6, [pc, #232] ; 30001e34 <rtems_filesystem_initialize+0xf8>
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
30001d48: e5922000 ldr r2, [r2]
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
30001d4c: e5963000 ldr r3, [r6]
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
30001d50: e3520000 cmp r2, #0
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
30001d54: 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 )
{
30001d58: e24dd018 sub sp, sp, #24
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
30001d5c: e583202c str r2, [r3, #44] ; 0x2c
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
30001d60: 0a00002c beq 30001e18 <rtems_filesystem_initialize+0xdc>
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
30001d64: e59f30cc ldr r3, [pc, #204] ; 30001e38 <rtems_filesystem_initialize+0xfc>
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
30001d68: e3a05000 mov r5, #0
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
30001d6c: e5933000 ldr r3, [r3]
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
30001d70: e5930008 ldr r0, [r3, #8]
30001d74: e593100c ldr r1, [r3, #12]
30001d78: e893000c ldm r3, {r2, r3}
30001d7c: e58d5000 str r5, [sp]
30001d80: eb000207 bl 300025a4 <mount>
if ( status == -1 )
30001d84: e3700001 cmn r0, #1
30001d88: 0a000026 beq 30001e28 <rtems_filesystem_initialize+0xec>
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
30001d8c: e5963000 ldr r3, [r6]
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
30001d90: 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;
30001d94: 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);
30001d98: e3a01001 mov r1, #1 30001d9c: e1a03004 mov r3, r4 30001da0: e1a02005 mov r2, r5 30001da4: e59f0090 ldr r0, [pc, #144] ; 30001e3c <rtems_filesystem_initialize+0x100> 30001da8: e58d5000 str r5, [sp] 30001dac: eb000056 bl 30001f0c <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
30001db0: e596c000 ldr ip, [r6]
30001db4: e1a07004 mov r7, r4
30001db8: e28cc018 add ip, ip, #24
30001dbc: e8b7000f ldm r7!, {r0, r1, r2, r3}
30001dc0: e597e000 ldr lr, [r7]
30001dc4: e8ac000f stmia ip!, {r0, r1, r2, r3}
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
30001dc8: 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;
30001dcc: e58ce000 str lr, [ip]
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
30001dd0: e1a02005 mov r2, r5 30001dd4: e1a03004 mov r3, r4 30001dd8: e59f005c ldr r0, [pc, #92] ; 30001e3c <rtems_filesystem_initialize+0x100> 30001ddc: e58d5000 str r5, [sp] 30001de0: eb000049 bl 30001f0c <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
30001de4: e8b4000f ldm r4!, {r0, r1, r2, r3}
30001de8: e596c000 ldr ip, [r6]
30001dec: e597e000 ldr lr, [r7]
30001df0: e28cc004 add ip, ip, #4
30001df4: e8ac000f stmia ip!, {r0, r1, r2, r3}
*
* 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);
30001df8: e59f0040 ldr r0, [pc, #64] ; 30001e40 <rtems_filesystem_initialize+0x104>
/* 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;
30001dfc: e58ce000 str lr, [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);
30001e00: e59f103c ldr r1, [pc, #60] ; 30001e44 <rtems_filesystem_initialize+0x108> 30001e04: eb000196 bl 30002464 <mkdir>
if ( status != 0 )
30001e08: e3500000 cmp r0, #0
30001e0c: 1a000003 bne 30001e20 <rtems_filesystem_initialize+0xe4> * 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. */ }
30001e10: e28dd018 add sp, sp, #24
30001e14: e8bd80f0 pop {r4, r5, r6, r7, pc}
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
30001e18: e59f0028 ldr r0, [pc, #40] ; 30001e48 <rtems_filesystem_initialize+0x10c><== NOT EXECUTED 30001e1c: eb000fc2 bl 30005d2c <rtems_fatal_error_occurred> <== NOT EXECUTED
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
if ( status != 0 )
rtems_fatal_error_occurred( 0xABCD0003 );
30001e20: e59f0024 ldr r0, [pc, #36] ; 30001e4c <rtems_filesystem_initialize+0x110><== NOT EXECUTED 30001e24: eb000fc0 bl 30005d2c <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 );
30001e28: e59f0020 ldr r0, [pc, #32] ; 30001e50 <rtems_filesystem_initialize+0x114><== NOT EXECUTED 30001e2c: eb000fbe bl 30005d2c <rtems_fatal_error_occurred> <== NOT EXECUTED
3000a4f4 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
3000a4f4: 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 ) {
3000a4f8: e59f60ac ldr r6, [pc, #172] ; 3000a5ac <rtems_filesystem_iterate+0xb8>
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
3000a4fc: e1a04000 mov r4, 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 ) {
3000a500: e5963000 ldr r3, [r6]
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
3000a504: 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 ) {
3000a508: e3530000 cmp r3, #0
3000a50c: 1a000002 bne 3000a51c <rtems_filesystem_iterate+0x28>
3000a510: ea00000c b 3000a548 <rtems_filesystem_iterate+0x54> <== NOT EXECUTED
3000a514: e3500000 cmp r0, #0
3000a518: 1a000021 bne 3000a5a4 <rtems_filesystem_iterate+0xb0>
stop = (*routine)( table_entry, routine_arg );
3000a51c: e1a00006 mov r0, r6 3000a520: e1a01005 mov r1, r5 3000a524: e1a0e00f mov lr, pc 3000a528: 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 ) {
3000a52c: e5963008 ldr r3, [r6, #8]
stop = (*routine)( table_entry, routine_arg );
3000a530: 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 ) {
3000a534: e3530000 cmp r3, #0 3000a538: e2866008 add r6, r6, #8
3000a53c: 1afffff4 bne 3000a514 <rtems_filesystem_iterate+0x20>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
3000a540: e3500000 cmp r0, #0
3000a544: 1a000016 bne 3000a5a4 <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 );
3000a548: e59f7060 ldr r7, [pc, #96] ; 3000a5b0 <rtems_filesystem_iterate+0xbc> 3000a54c: e3a01000 mov r1, #0
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
3000a550: e59f605c ldr r6, [pc, #92] ; 3000a5b4 <rtems_filesystem_iterate+0xc0> 3000a554: e5970000 ldr r0, [r7] 3000a558: e1a02001 mov r2, r1 3000a55c: ebffec49 bl 30005688 <rtems_semaphore_obtain> 3000a560: e4968004 ldr r8, [r6], #4
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
3000a564: e1580006 cmp r8, r6 3000a568: 03a0a000 moveq sl, #0
3000a56c: 1a000002 bne 3000a57c <rtems_filesystem_iterate+0x88>
3000a570: ea000009 b 3000a59c <rtems_filesystem_iterate+0xa8>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
3000a574: e3500000 cmp r0, #0
3000a578: 1a000007 bne 3000a59c <rtems_filesystem_iterate+0xa8>
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
3000a57c: e2880008 add r0, r8, #8 3000a580: e1a01005 mov r1, r5 3000a584: e1a0e00f mov lr, pc 3000a588: e12fff14 bx r4
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
3000a58c: e5988000 ldr r8, [r8]
!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 );
3000a590: e1a0a000 mov sl, r0
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
3000a594: e1580006 cmp r8, r6
3000a598: 1afffff5 bne 3000a574 <rtems_filesystem_iterate+0x80>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
3000a59c: e5970000 ldr r0, [r7] 3000a5a0: ebffec81 bl 300057ac <rtems_semaphore_release>
}
rtems_libio_unlock();
}
return stop;
}
3000a5a4: e1a0000a mov r0, sl
3000a5a8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
3000252c <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
3000252c: 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 );
30002530: e59f7064 ldr r7, [pc, #100] ; 3000259c <rtems_filesystem_mount_iterate+0x70>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
30002534: e59f4064 ldr r4, [pc, #100] ; 300025a0 <rtems_filesystem_mount_iterate+0x74>
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
30002538: e1a06001 mov r6, r1 3000253c: e3a01000 mov r1, #0 30002540: e1a05000 mov r5, r0 30002544: e1a02001 mov r2, r1 30002548: e5970000 ldr r0, [r7] 3000254c: eb000c4d bl 30005688 <rtems_semaphore_obtain>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
30002550: e4948004 ldr r8, [r4], #4
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
30002554: e1580004 cmp r8, r4
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
rtems_chain_node *node = NULL;
bool stop = false;
30002558: 03a0a000 moveq sl, #0
rtems_libio_lock();
for (
3000255c: 1a000002 bne 3000256c <rtems_filesystem_mount_iterate+0x40>
30002560: ea000009 b 3000258c <rtems_filesystem_mount_iterate+0x60> <== NOT EXECUTED
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
30002564: e3500000 cmp r0, #0
30002568: 1a000007 bne 3000258c <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 );
3000256c: e1a00008 mov r0, r8 30002570: e1a01006 mov r1, r6 30002574: e1a0e00f mov lr, pc 30002578: e12fff15 bx r5
}
rtems_libio_unlock();
return stop;
}
3000257c: e5988000 ldr r8, [r8]
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 );
30002580: e1a0a000 mov sl, r0
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
30002584: e1580004 cmp r8, r4
30002588: 1afffff5 bne 30002564 <rtems_filesystem_mount_iterate+0x38>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
3000258c: e5970000 ldr r0, [r7] 30002590: eb000c85 bl 300057ac <rtems_semaphore_release>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
30002594: e1a0000a mov r0, sl
30002598: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
30001fa0 <rtems_filesystem_prefix_separators>:
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
30001fa0: e92d4070 push {r4, r5, r6, lr}
30001fa4: e1a05000 mov r5, r0
/* * Eat any separators at start of the path. */ int stripped = 0; while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
30001fa8: e5d00000 ldrb r0, [r0] 30001fac: e1a06001 mov r6, r1 30001fb0: e3510000 cmp r1, #0 30001fb4: 13500000 cmpne r0, #0 30001fb8: 03a04000 moveq r4, #0 30001fbc: 13a04001 movne r4, #1
)
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
30001fc0: 13a04000 movne r4, #0
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) ) 30001fc4: 1a000005 bne 30001fe0 <rtems_filesystem_prefix_separators+0x40>
30001fc8: ea000007 b 30001fec <rtems_filesystem_prefix_separators+0x4c><== NOT EXECUTED
30001fcc: e5f50001 ldrb r0, [r5, #1]!
{
pathname++;
pathnamelen--;
stripped++;
30001fd0: e2844001 add r4, r4, #1
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
30001fd4: e1560004 cmp r6, r4 30001fd8: 13500000 cmpne r0, #0
30001fdc: 0a000002 beq 30001fec <rtems_filesystem_prefix_separators+0x4c>
30001fe0: eb0003be bl 30002ee0 <rtems_filesystem_is_separator> 30001fe4: e3500000 cmp r0, #0
30001fe8: 1afffff7 bne 30001fcc <rtems_filesystem_prefix_separators+0x2c>
pathname++;
pathnamelen--;
stripped++;
}
return stripped;
}
30001fec: e1a00004 mov r0, r4
30001ff0: e8bd8070 pop {r4, r5, r6, pc}
30002bd0 <rtems_gxx_key_create>:
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
30002bd0: e92d4070 push {r4, r5, r6, lr}
30002bd4: 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 ) );
30002bd8: e3a00008 mov r0, #8
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
30002bdc: 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 ) );
30002be0: eb000107 bl 30003004 <malloc>
*key = new_key; new_key->val = NULL;
30002be4: 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 ) );
30002be8: e1a04000 mov r4, r0
*key = new_key;
30002bec: 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 );
30002bf0: e1a01004 mov r1, r4 30002bf4: e1a00003 mov r0, r3 30002bf8: 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;
30002bfc: 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 );
30002c00: eb000f42 bl 30006910 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL )
30002c04: e3500000 cmp r0, #0
30002c08: 08bd8070 popeq {r4, r5, r6, pc}
return 0;
free( new_key );
30002c0c: e1a00004 mov r0, r4 <== NOT EXECUTED 30002c10: ebffff87 bl 30002a34 <free> <== NOT EXECUTED
return -1;
30002c14: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
30002c18: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30002b50 <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))
{
30002b50: 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 ) {
30002b54: e5903000 ldr r3, [r0]
/* 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))
{
30002b58: e24dd004 sub sp, sp, #4
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
30002b5c: 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))
{
30002b60: e1a04000 mov r4, r0 30002b64: 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 ) {
30002b68: 0a000002 beq 30002b78 <rtems_gxx_once+0x28>
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
if ( o == 0 )
(*func)();
}
return 0;
}
30002b6c: e3a00000 mov r0, #0
30002b70: e28dd004 add sp, sp, #4
30002b74: 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);
30002b78: e3a00c01 mov r0, #256 ; 0x100 30002b7c: e1a01000 mov r1, r0 30002b80: e1a0200d mov r2, sp 30002b84: eb000eea bl 30006734 <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
30002b88: e5943000 ldr r3, [r4]
if ( *(volatile __gthread_once_t *)once == 0 ) {
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
30002b8c: e1a0600d mov r6, sp
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
30002b90: e3530000 cmp r3, #0
30002b94: 1a000008 bne 30002bbc <rtems_gxx_once+0x6c>
*(volatile __gthread_once_t *)once = 1;
30002b98: e3a03001 mov r3, #1 30002b9c: e5843000 str r3, [r4]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
30002ba0: e3a01c01 mov r1, #256 ; 0x100 30002ba4: e1a0200d mov r2, sp 30002ba8: e59d0000 ldr r0, [sp] 30002bac: eb000ee0 bl 30006734 <rtems_task_mode>
if ( o == 0 )
(*func)();
30002bb0: e1a0e00f mov lr, pc 30002bb4: e12fff15 bx r5 30002bb8: eaffffeb b 30002b6c <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);
30002bbc: e59d0000 ldr r0, [sp] <== NOT EXECUTED 30002bc0: e3a01c01 mov r1, #256 ; 0x100 <== NOT EXECUTED 30002bc4: e1a0200d mov r2, sp <== NOT EXECUTED 30002bc8: eb000ed9 bl 30006734 <rtems_task_mode> <== NOT EXECUTED 30002bcc: eaffffe6 b 30002b6c <rtems_gxx_once+0x1c> <== NOT EXECUTED
300072e4 <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() )
300072e4: e59fc150 ldr ip, [pc, #336] ; 3000743c <rtems_io_register_driver+0x158>
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;
300072e8: e59f3150 ldr r3, [pc, #336] ; 30007440 <rtems_io_register_driver+0x15c>
if ( rtems_interrupt_is_in_progress() )
300072ec: e59cc000 ldr ip, [ip]
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
)
{
300072f0: e92d4030 push {r4, r5, lr}
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
300072f4: 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
)
{
300072f8: e1a04000 mov r4, r0
rtems_device_major_number major_limit = _IO_Number_of_drivers;
300072fc: e5930000 ldr r0, [r3]
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
30007300: 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() )
30007304: 18bd8030 popne {r4, r5, pc}
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
30007308: e3520000 cmp r2, #0
3000730c: 0a00003f beq 30007410 <rtems_io_register_driver+0x12c>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
30007310: e3510000 cmp r1, #0
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
30007314: e5820000 str r0, [r2]
if ( driver_table == NULL )
30007318: 0a00003c beq 30007410 <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;
3000731c: e591c000 ldr ip, [r1] 30007320: e35c0000 cmp ip, #0
30007324: 0a000036 beq 30007404 <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 )
30007328: e1500004 cmp r0, r4
3000732c: 9a000027 bls 300073d0 <rtems_io_register_driver+0xec>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30007330: e59f010c ldr r0, [pc, #268] ; 30007444 <rtems_io_register_driver+0x160> 30007334: e590c000 ldr ip, [r0] 30007338: e28cc001 add ip, ip, #1 3000733c: e580c000 str ip, [r0]
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
30007340: e3540000 cmp r4, #0
30007344: 1a000023 bne 300073d8 <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;
30007348: e593c000 ldr ip, [r3]
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
3000734c: e35c0000 cmp ip, #0
30007350: 0a000030 beq 30007418 <rtems_io_register_driver+0x134>
30007354: e59fe0ec ldr lr, [pc, #236] ; 30007448 <rtems_io_register_driver+0x164> 30007358: e59e3000 ldr r3, [lr] 3000735c: ea000003 b 30007370 <rtems_io_register_driver+0x8c> 30007360: e2844001 add r4, r4, #1 30007364: e15c0004 cmp ip, r4 30007368: e2833018 add r3, r3, #24
3000736c: 9a000005 bls 30007388 <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;
30007370: e5930000 ldr r0, [r3] 30007374: e3500000 cmp r0, #0
30007378: 1afffff8 bne 30007360 <rtems_io_register_driver+0x7c>
3000737c: e5930004 ldr r0, [r3, #4] 30007380: e3500000 cmp r0, #0
30007384: 1afffff5 bne 30007360 <rtems_io_register_driver+0x7c>
}
/* Assigns invalid value in case of failure */
*major = m;
if ( m != n )
30007388: e15c0004 cmp ip, r4 3000738c: 1084c084 addne ip, r4, r4, lsl #1
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
30007390: e5824000 str r4, [r2]
if ( m != n )
30007394: 11a0c18c lslne ip, ip, #3
30007398: 0a00001f beq 3000741c <rtems_io_register_driver+0x138>
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
3000739c: e59e5000 ldr r5, [lr]
300073a0: e1a0e001 mov lr, r1
300073a4: e085c00c add ip, r5, ip
300073a8: e8be000f ldm lr!, {r0, r1, r2, r3}
300073ac: e8ac000f stmia ip!, {r0, r1, r2, r3}
300073b0: e89e0003 ldm lr, {r0, r1}
300073b4: e88c0003 stm ip, {r0, r1}
_Thread_Enable_dispatch();
300073b8: eb000775 bl 30009194 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
300073bc: e3a01000 mov r1, #0 300073c0: e1a00004 mov r0, r4 300073c4: e1a02001 mov r2, r1
}
300073c8: e8bd4030 pop {r4, r5, lr}
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
300073cc: ea0021a9 b 3000fa78 <rtems_io_initialize>
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
300073d0: e3a0000a mov r0, #10
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
300073d4: 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;
300073d8: e59fe068 ldr lr, [pc, #104] ; 30007448 <rtems_io_register_driver+0x164> 300073dc: e0840084 add r0, r4, r4, lsl #1 300073e0: e59e3000 ldr r3, [lr] 300073e4: e1a0c180 lsl ip, r0, #3
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
300073e8: e7930180 ldr r0, [r3, r0, lsl #3]
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
300073ec: 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;
300073f0: e3500000 cmp r0, #0
300073f4: 0a00000b beq 30007428 <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();
300073f8: eb000765 bl 30009194 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
300073fc: e3a0000c mov r0, #12
30007400: 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;
30007404: e591c004 ldr ip, [r1, #4] 30007408: e35c0000 cmp ip, #0
3000740c: 1affffc5 bne 30007328 <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;
30007410: e3a00009 mov r0, #9
30007414: e8bd8030 pop {r4, r5, pc}
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
30007418: 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();
3000741c: eb00075c bl 30009194 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
30007420: 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;
30007424: 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;
30007428: e5933004 ldr r3, [r3, #4] 3000742c: e3530000 cmp r3, #0
30007430: 1afffff0 bne 300073f8 <rtems_io_register_driver+0x114>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
30007434: e5824000 str r4, [r2] 30007438: eaffffd7 b 3000739c <rtems_io_register_driver+0xb8>
30002124 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
30002124: e92d4010 push {r4, lr}
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
30002128: e59f30b8 ldr r3, [pc, #184] ; 300021e8 <rtems_libio_init+0xc4>
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
3000212c: e24dd004 sub sp, sp, #4
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
30002130: e5934000 ldr r4, [r3] 30002134: e3540000 cmp r4, #0
30002138: 0a000017 beq 3000219c <rtems_libio_init+0x78>
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
3000213c: e1a00004 mov r0, r4 30002140: e3a01038 mov r1, #56 ; 0x38 30002144: ebffff42 bl 30001e54 <calloc> 30002148: e59f309c ldr r3, [pc, #156] ; 300021ec <rtems_libio_init+0xc8>
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
3000214c: 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,
30002150: e1a02000 mov r2, r0 30002154: e5830000 str r0, [r3]
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
30002158: 0a000020 beq 300021e0 <rtems_libio_init+0xbc>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
3000215c: e59f308c ldr r3, [pc, #140] ; 300021f0 <rtems_libio_init+0xcc>
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
30002160: 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;
30002164: e5830000 str r0, [r3]
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
30002168: 9a000009 bls 30002194 <rtems_libio_init+0x70>
* rtems_libio_init
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
3000216c: e2803038 add r3, r0, #56 ; 0x38 30002170: 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;
30002174: 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++)
30002178: e1520004 cmp r2, r4
iop->data1 = iop + 1;
3000217c: e5033004 str r3, [r3, #-4] 30002180: 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++)
30002184: 1afffffa bne 30002174 <rtems_libio_init+0x50>
* rtems_libio_init
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
30002188: e2422001 sub r2, r2, #1 3000218c: 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++)
30002190: e0802182 add r2, r0, r2, lsl #3
iop->data1 = iop + 1;
iop->data1 = NULL;
30002194: e3a03000 mov r3, #0 30002198: e5823034 str r3, [r2, #52] ; 0x34
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
3000219c: e59fc050 ldr ip, [pc, #80] ; 300021f4 <rtems_libio_init+0xd0> 300021a0: e59f0050 ldr r0, [pc, #80] ; 300021f8 <rtems_libio_init+0xd4> 300021a4: e3a01001 mov r1, #1 300021a8: e3a02054 mov r2, #84 ; 0x54 300021ac: e3a03000 mov r3, #0 300021b0: e58dc000 str ip, [sp] 300021b4: eb000c99 bl 30005420 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
300021b8: e3500000 cmp r0, #0
300021bc: 1a000006 bne 300021dc <rtems_libio_init+0xb8>
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
300021c0: e59f3034 ldr r3, [pc, #52] ; 300021fc <rtems_libio_init+0xd8> 300021c4: e5933000 ldr r3, [r3] 300021c8: e3530000 cmp r3, #0
(* rtems_fs_init_helper)();
300021cc: 11a0e00f movne lr, pc 300021d0: 112fff13 bxne r3
}
300021d4: e28dd004 add sp, sp, #4
300021d8: 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 );
300021dc: eb000ed2 bl 30005d2c <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);
300021e0: e280001a add r0, r0, #26 300021e4: eb000ed0 bl 30005d2c <rtems_fatal_error_occurred>
3000a1e4 <rtems_libio_to_fcntl_flags>:
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
3000a1e4: e2002006 and r2, r0, #6 3000a1e8: e3520006 cmp r2, #6
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
3000a1ec: e1a03000 mov r3, r0
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
3000a1f0: 03a00002 moveq r0, #2
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
3000a1f4: 0a000002 beq 3000a204 <rtems_libio_to_fcntl_flags+0x20>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
3000a1f8: e3130002 tst r3, #2
fcntl_flags |= O_RDONLY;
3000a1fc: 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) {
3000a200: 0a000006 beq 3000a220 <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 ) {
3000a204: e3130001 tst r3, #1
fcntl_flags |= O_NONBLOCK;
3000a208: 13800901 orrne r0, r0, #16384 ; 0x4000
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
3000a20c: e3130c02 tst r3, #512 ; 0x200
fcntl_flags |= O_APPEND;
3000a210: 13800008 orrne r0, r0, #8
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
3000a214: e3130b01 tst r3, #1024 ; 0x400
fcntl_flags |= O_CREAT;
3000a218: 13800c02 orrne r0, r0, #512 ; 0x200
}
return fcntl_flags;
}
3000a21c: e12fff1e bx lr
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
3000a220: e3130004 tst r3, #4 <== NOT EXECUTED 3000a224: 03a00000 moveq r0, #0 <== NOT EXECUTED 3000a228: 13a00001 movne r0, #1 <== NOT EXECUTED 3000a22c: eafffff4 b 3000a204 <rtems_libio_to_fcntl_flags+0x20> <== NOT EXECUTED
30005988 <rtems_object_get_api_class_name>:
)
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
30005988: e3500001 cmp r0, #1
const char *rtems_object_get_api_class_name(
int the_api,
int the_class
)
{
3000598c: 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 )
30005990: 0a00000d beq 300059cc <rtems_object_get_api_class_name+0x44>
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
30005994: e3500002 cmp r0, #2
30005998: 0a000004 beq 300059b0 <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 )
3000599c: e3500003 cmp r0, #3
api_assoc = rtems_object_api_posix_assoc;
300059a0: 059f003c ldreq r0, [pc, #60] ; 300059e4 <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 )
300059a4: 0a000002 beq 300059b4 <rtems_object_get_api_class_name+0x2c>
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
300059a8: e59f0038 ldr r0, [pc, #56] ; 300059e8 <rtems_object_get_api_class_name+0x60>
300059ac: 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;
300059b0: e59f0034 ldr r0, [pc, #52] ; 300059ec <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 );
300059b4: eb001381 bl 3000a7c0 <rtems_assoc_ptr_by_local>
if ( class_assoc )
300059b8: e3500000 cmp r0, #0
return class_assoc->name;
300059bc: 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 )
300059c0: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
return class_assoc->name;
return "BAD CLASS";
300059c4: e59f0024 ldr r0, [pc, #36] ; 300059f0 <rtems_object_get_api_class_name+0x68>
}
300059c8: 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;
300059cc: e59f0020 ldr r0, [pc, #32] ; 300059f4 <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 );
300059d0: eb00137a bl 3000a7c0 <rtems_assoc_ptr_by_local>
if ( class_assoc )
300059d4: e3500000 cmp r0, #0
return class_assoc->name;
300059d8: 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 )
300059dc: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
300059e0: eafffff7 b 300059c4 <rtems_object_get_api_class_name+0x3c>
300016b8 <rtems_print_buffer>:
void rtems_print_buffer(
const unsigned char *buffer,
int length
)
{
300016b8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int i, mod, max;
if ( !length ) return;
300016bc: e3510000 cmp r1, #0
void rtems_print_buffer(
const unsigned char *buffer,
int length
)
{
300016c0: e24dd078 sub sp, sp, #120 ; 0x78 300016c4: e1a0b000 mov fp, r0
int i, mod, max;
if ( !length ) return;
300016c8: 0a000037 beq 300017ac <rtems_print_buffer+0xf4>
mod = length % 16;
300016cc: e1a03fc1 asr r3, r1, #31 300016d0: e1a03e23 lsr r3, r3, #28 300016d4: e081a003 add sl, r1, r3 300016d8: e20aa00f and sl, sl, #15 300016dc: e063a00a rsb sl, r3, sl
max = length - mod;
300016e0: e06a9001 rsb r9, sl, r1
for ( i=0 ; i<max ; i+=16 )
300016e4: e3590000 cmp r9, #0
300016e8: da00002d ble 300017a4 <rtems_print_buffer+0xec>
300016ec: e59f71f4 ldr r7, [pc, #500] ; 300018e8 <rtems_print_buffer+0x230> 300016f0: e3a08000 mov r8, #0 300016f4: e1a0400d mov r4, sp
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
300016f8: e3a03000 mov r3, #0
static inline void Dump_Line(
const unsigned char *buffer,
int length
);
void rtems_print_buffer(
300016fc: e08b6008 add r6, fp, r8
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
30001700: e5cd3000 strb r3, [sp]
for( i=0 ; i<length ; i++ )
30001704: e3a05000 mov r5, #0
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
30001708: e7d63005 ldrb r3, [r6, r5] 3000170c: e1a0000d mov r0, sp 30001710: e59f11d4 ldr r1, [pc, #468] ; 300018ec <rtems_print_buffer+0x234> 30001714: e1a0200d mov r2, sp
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
30001718: e2855001 add r5, r5, #1
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
3000171c: eb00344a bl 3000e84c <sprintf>
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
30001720: e3550010 cmp r5, #16
30001724: 1afffff7 bne 30001708 <rtems_print_buffer+0x50>
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
30001728: e1a0000d mov r0, sp 3000172c: eb00357d bl 3000ed28 <strlen> 30001730: e59f11b8 ldr r1, [pc, #440] ; 300018f0 <rtems_print_buffer+0x238> 30001734: e0840000 add r0, r4, r0 30001738: e3a02002 mov r2, #2 3000173c: eb0033b1 bl 3000e608 <memcpy>
for( i=0 ; i<length ; i++ )
30001740: e3a05000 mov r5, #0
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
30001744: e7d63005 ldrb r3, [r6, r5] 30001748: e5972000 ldr r2, [r7]
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
3000174c: e1a0000d mov r0, sp
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
30001750: e0822003 add r2, r2, r3 30001754: 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,
30001758: e59f1194 ldr r1, [pc, #404] ; 300018f4 <rtems_print_buffer+0x23c> 3000175c: e3120097 tst r2, #151 ; 0x97 30001760: 03a0302e moveq r3, #46 ; 0x2e 30001764: e1a0200d mov r2, sp
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
30001768: e2855001 add r5, r5, #1
sprintf( line_buffer, "%s%c", line_buffer,
3000176c: eb003436 bl 3000e84c <sprintf>
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
30001770: e3550010 cmp r5, #16
30001774: 1afffff2 bne 30001744 <rtems_print_buffer+0x8c>
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
30001778: e1a0000d mov r0, sp 3000177c: eb003569 bl 3000ed28 <strlen> 30001780: e59f1170 ldr r1, [pc, #368] ; 300018f8 <rtems_print_buffer+0x240> 30001784: e3a02003 mov r2, #3 30001788: e0840000 add r0, r4, r0 3000178c: eb00339d bl 3000e608 <memcpy>
mod = length % 16;
max = length - mod;
for ( i=0 ; i<max ; i+=16 )
30001790: e2888010 add r8, r8, #16
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
printk( line_buffer );
30001794: e1a0000d mov r0, sp 30001798: eb000638 bl 30003080 <printk>
mod = length % 16;
max = length - mod;
for ( i=0 ; i<max ; i+=16 )
3000179c: e1590008 cmp r9, r8
300017a0: caffffd4 bgt 300016f8 <rtems_print_buffer+0x40>
Dump_Line( &buffer[ i ], 16 );
if ( mod )
300017a4: e35a0000 cmp sl, #0
300017a8: 1a000001 bne 300017b4 <rtems_print_buffer+0xfc>
Dump_Line( &buffer[ max ], mod );
}
300017ac: e28dd078 add sp, sp, #120 ; 0x78
300017b0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
300017b4: e3a05000 mov r5, #0
for ( i=0 ; i<max ; i+=16 )
Dump_Line( &buffer[ i ], 16 );
if ( mod )
Dump_Line( &buffer[ max ], mod );
300017b8: e08b9009 add r9, fp, r9
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
300017bc: e5cd5000 strb r5, [sp] 300017c0: d1a0400d movle r4, sp
for( i=0 ; i<length ; i++ )
300017c4: da00000b ble 300017f8 <rtems_print_buffer+0x140>
300017c8: e1a0400d mov r4, sp
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
300017cc: e7d93005 ldrb r3, [r9, r5] 300017d0: e1a0000d mov r0, sp 300017d4: e59f1110 ldr r1, [pc, #272] ; 300018ec <rtems_print_buffer+0x234> 300017d8: e1a0200d mov r2, sp
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
300017dc: e2855001 add r5, r5, #1
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
300017e0: eb003419 bl 3000e84c <sprintf>
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
300017e4: e15a0005 cmp sl, r5
300017e8: cafffff7 bgt 300017cc <rtems_print_buffer+0x114>
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
300017ec: e35a000f cmp sl, #15 300017f0: d1a0500a movle r5, sl
300017f4: ca000034 bgt 300018cc <rtems_print_buffer+0x214>
strcat( line_buffer, " " );
300017f8: e1a0000d mov r0, sp 300017fc: eb003549 bl 3000ed28 <strlen>
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
30001800: e2855001 add r5, r5, #1
strcat( line_buffer, " " );
30001804: e59f10f0 ldr r1, [pc, #240] ; 300018fc <rtems_print_buffer+0x244> 30001808: e0840000 add r0, r4, r0 3000180c: e3a02004 mov r2, #4 30001810: eb00337c bl 3000e608 <memcpy>
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
30001814: e355000f cmp r5, #15
30001818: dafffff6 ble 300017f8 <rtems_print_buffer+0x140>
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
3000181c: e1a0000d mov r0, sp 30001820: eb003540 bl 3000ed28 <strlen> 30001824: e59f10c4 ldr r1, [pc, #196] ; 300018f0 <rtems_print_buffer+0x238> 30001828: e0840000 add r0, r4, r0 3000182c: e3a02002 mov r2, #2 30001830: eb003374 bl 3000e608 <memcpy>
for( i=0 ; i<length ; i++ )
30001834: e35a0000 cmp sl, #0 30001838: d3a0a000 movle sl, #0
3000183c: da000010 ble 30001884 <rtems_print_buffer+0x1cc>
30001840: e59f70a0 ldr r7, [pc, #160] ; 300018e8 <rtems_print_buffer+0x230> 30001844: e3a05000 mov r5, #0
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
30001848: e7d93005 ldrb r3, [r9, r5] 3000184c: e5972000 ldr r2, [r7]
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
30001850: e1a0000d mov r0, sp
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
30001854: e0822003 add r2, r2, r3 30001858: 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,
3000185c: e59f1090 ldr r1, [pc, #144] ; 300018f4 <rtems_print_buffer+0x23c> 30001860: e3120097 tst r2, #151 ; 0x97 30001864: 03a0302e moveq r3, #46 ; 0x2e 30001868: e1a0200d mov r2, sp
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
3000186c: e2855001 add r5, r5, #1
sprintf( line_buffer, "%s%c", line_buffer,
30001870: eb0033f5 bl 3000e84c <sprintf>
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
30001874: e15a0005 cmp sl, r5
30001878: cafffff2 bgt 30001848 <rtems_print_buffer+0x190>
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
3000187c: e35a000f cmp sl, #15
30001880: ca000008 bgt 300018a8 <rtems_print_buffer+0x1f0>
strcat( line_buffer, " " );
30001884: e1a0000d mov r0, sp 30001888: eb003526 bl 3000ed28 <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++ )
3000188c: e28aa001 add sl, sl, #1
strcat( line_buffer, " " );
30001890: e59f1068 ldr r1, [pc, #104] ; 30001900 <rtems_print_buffer+0x248> 30001894: e0840000 add r0, r4, r0 30001898: e3a02002 mov r2, #2 3000189c: eb003359 bl 3000e608 <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++ )
300018a0: e35a000f cmp sl, #15
300018a4: dafffff6 ble 30001884 <rtems_print_buffer+0x1cc>
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
300018a8: e1a0000d mov r0, sp 300018ac: eb00351d bl 3000ed28 <strlen> 300018b0: e59f1040 ldr r1, [pc, #64] ; 300018f8 <rtems_print_buffer+0x240> 300018b4: e0840000 add r0, r4, r0 300018b8: e3a02003 mov r2, #3 300018bc: eb003351 bl 3000e608 <memcpy>
printk( line_buffer );
300018c0: e1a0000d mov r0, sp 300018c4: eb0005ed bl 30003080 <printk> 300018c8: eaffffb7 b 300017ac <rtems_print_buffer+0xf4>
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
300018cc: e1a0000d mov r0, sp <== NOT EXECUTED 300018d0: eb003514 bl 3000ed28 <strlen> <== NOT EXECUTED 300018d4: e59f1014 ldr r1, [pc, #20] ; 300018f0 <rtems_print_buffer+0x238><== NOT EXECUTED 300018d8: e0840000 add r0, r4, r0 <== NOT EXECUTED 300018dc: e3a02002 mov r2, #2 <== NOT EXECUTED 300018e0: eb003348 bl 3000e608 <memcpy> <== NOT EXECUTED 300018e4: eaffffd5 b 30001840 <rtems_print_buffer+0x188> <== NOT EXECUTED
3000227c <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
3000227c: e92d4830 push {r4, r5, fp, lr}
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
30002280: e59f4074 ldr r4, [pc, #116] ; 300022fc <rtems_stack_checker_is_blown+0x80>
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
30002284: e28db00c add fp, sp, #12
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
30002288: e5943004 ldr r3, [r4, #4]
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
3000228c: e59300bc ldr r0, [r3, #188] ; 0xbc 30002290: e15b0000 cmp fp, r0
return false;
30002294: 33a05000 movcc r5, #0
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
30002298: 3a000004 bcc 300022b0 <rtems_stack_checker_is_blown+0x34>
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
3000229c: e59350b8 ldr r5, [r3, #184] ; 0xb8 300022a0: e0805005 add r5, r0, r5
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
300022a4: e15b0005 cmp fp, r5 300022a8: 83a05000 movhi r5, #0 300022ac: 93a05001 movls r5, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
300022b0: e59f3048 ldr r3, [pc, #72] ; 30002300 <rtems_stack_checker_is_blown+0x84> 300022b4: e5933008 ldr r3, [r3, #8] 300022b8: 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;
300022bc: 03a01001 moveq r1, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
300022c0: 0a000005 beq 300022dc <rtems_stack_checker_is_blown+0x60>
pattern_ok = (!memcmp(
300022c4: e59f1038 ldr r1, [pc, #56] ; 30002304 <rtems_stack_checker_is_blown+0x88> 300022c8: e2800008 add r0, r0, #8 300022cc: e3a02010 mov r2, #16 300022d0: eb003b85 bl 300110ec <memcmp> 300022d4: e2701001 rsbs r1, r0, #1 300022d8: 33a01000 movcc r1, #0
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
300022dc: e3550000 cmp r5, #0
300022e0: 0a000003 beq 300022f4 <rtems_stack_checker_is_blown+0x78>
300022e4: e3510000 cmp r1, #0
300022e8: 0a000001 beq 300022f4 <rtems_stack_checker_is_blown+0x78>
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
300022ec: e3a00000 mov r0, #0
300022f0: 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 );
300022f4: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 300022f8: ebffff98 bl 30002160 <Stack_check_report_blown_task> <== NOT EXECUTED
30002368 <rtems_stack_checker_report_usage>:
}
void rtems_stack_checker_report_usage( void )
{
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
30002368: e59f1004 ldr r1, [pc, #4] ; 30002374 <rtems_stack_checker_report_usage+0xc><== NOT EXECUTED 3000236c: e3a00000 mov r0, #0 <== NOT EXECUTED 30002370: eaffffe4 b 30002308 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
30002308 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30002308: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
if ( !print )
3000230c: e2515000 subs r5, r1, #0 <== NOT EXECUTED
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30002310: e1a06000 mov r6, r0 <== NOT EXECUTED
if ( !print )
30002314: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return;
print_context = context;
30002318: e59f4038 ldr r4, [pc, #56] ; 30002358 <rtems_stack_checker_report_usage_with_plugin+0x50><== NOT EXECUTED
print_handler = print;
(*print)( context, "Stack usage by thread\n");
3000231c: e59f1038 ldr r1, [pc, #56] ; 3000235c <rtems_stack_checker_report_usage_with_plugin+0x54><== NOT EXECUTED
)
{
if ( !print )
return;
print_context = context;
30002320: e5840004 str r0, [r4, #4] <== NOT EXECUTED
print_handler = print;
30002324: e5845000 str r5, [r4] <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
30002328: e1a0e00f mov lr, pc <== NOT EXECUTED 3000232c: e12fff15 bx r5 <== NOT EXECUTED
(*print)( context,
30002330: e59f1028 ldr r1, [pc, #40] ; 30002360 <rtems_stack_checker_report_usage_with_plugin+0x58><== NOT EXECUTED 30002334: e1a00006 mov r0, r6 <== NOT EXECUTED 30002338: e1a0e00f mov lr, pc <== NOT EXECUTED 3000233c: e12fff15 bx r5 <== NOT EXECUTED
" ID NAME LOW HIGH CURRENT AVAILABLE USED\n"
);
/* iterate over all threads and dump the usage */
rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage );
30002340: e59f001c ldr r0, [pc, #28] ; 30002364 <rtems_stack_checker_report_usage_with_plugin+0x5c><== NOT EXECUTED 30002344: eb001cb2 bl 30009614 <rtems_iterate_over_all_threads> <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
#endif
print_context = NULL;
30002348: e3a03000 mov r3, #0 <== NOT EXECUTED 3000234c: e5843004 str r3, [r4, #4] <== NOT EXECUTED
print_handler = NULL;
30002350: e5843000 str r3, [r4] <== NOT EXECUTED
30002354: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30002214 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
30002214: 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);
30002218: e59030bc ldr r3, [r0, #188] ; 0xbc
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
3000221c: e28db008 add fp, sp, #8
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
30002220: e15b0003 cmp fp, r3
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
30002224: 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);
30002228: e2830008 add r0, r3, #8
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
3000222c: 3a000003 bcc 30002240 <rtems_stack_checker_switch_extension+0x2c>
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
30002230: e59420b8 ldr r2, [r4, #184] ; 0xb8 30002234: e0833002 add r3, r3, r2 30002238: e15b0003 cmp fp, r3
3000223c: 9a000006 bls 3000225c <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,
30002240: e59f1030 ldr r1, [pc, #48] ; 30002278 <rtems_stack_checker_switch_extension+0x64><== NOT EXECUTED 30002244: e3a02010 mov r2, #16 <== NOT EXECUTED 30002248: eb003ba7 bl 300110ec <memcmp> <== NOT EXECUTED 3000224c: e2701001 rsbs r1, r0, #1 <== NOT EXECUTED 30002250: 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 );
30002254: e1a00004 mov r0, r4 <== NOT EXECUTED 30002258: ebffffc0 bl 30002160 <Stack_check_report_blown_task> <== NOT EXECUTED
/*
* 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,
3000225c: e59f1014 ldr r1, [pc, #20] ; 30002278 <rtems_stack_checker_switch_extension+0x64> 30002260: e3a02010 mov r2, #16 30002264: eb003ba0 bl 300110ec <memcmp>
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
30002268: e3500000 cmp r0, #0
3000226c: 08bd8810 popeq {r4, fp, pc}
30002270: e3a01000 mov r1, #0 <== NOT EXECUTED 30002274: eafffff6 b 30002254 <rtems_stack_checker_switch_extension+0x40><== NOT EXECUTED
3000c3a8 <rtems_string_to_pointer>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
3000c3a8: e92d40f0 push {r4, r5, r6, r7, lr}
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
3000c3ac: e2515000 subs r5, r1, #0
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
3000c3b0: e1a04000 mov r4, r0 3000c3b4: e24dd004 sub sp, sp, #4 3000c3b8: e1a06002 mov r6, r2
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
3000c3bc: 03a00009 moveq r0, #9
)
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
3000c3c0: 0a000013 beq 3000c414 <rtems_string_to_pointer+0x6c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
3000c3c4: eb000bd1 bl 3000f310 <__errno> 3000c3c8: e3a03000 mov r3, #0 3000c3cc: e5803000 str r3, [r0]
*n = 0;
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
3000c3d0: e1a0100d mov r1, sp
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
3000c3d4: e5853000 str r3, [r5]
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
3000c3d8: e1a00004 mov r0, r4 3000c3dc: e3a02010 mov r2, #16 3000c3e0: eb0018f9 bl 300127cc <strtoul>
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
3000c3e4: e3560000 cmp r6, #0
*endptr = end;
3000c3e8: 159d3000 ldrne r3, [sp]
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
3000c3ec: 059d3000 ldreq r3, [sp]
*endptr = end;
3000c3f0: 15863000 strne r3, [r6]
/* nothing was converted */
if ( end == s )
3000c3f4: e1540003 cmp r4, r3
*n = 0;
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
3000c3f8: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
3000c3fc: 03a0000b moveq r0, #11
/* If the user wants the end pointer back, then return it. */
if ( endptr )
*endptr = end;
/* nothing was converted */
if ( end == s )
3000c400: 0a000003 beq 3000c414 <rtems_string_to_pointer+0x6c>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
3000c404: e3770001 cmn r7, #1
3000c408: 0a000003 beq 3000c41c <rtems_string_to_pointer+0x74>
if ( (result == STRING_TO_MIN) && (errno == ERANGE))
return RTEMS_INVALID_NUMBER;
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
3000c40c: e5857000 str r7, [r5]
#else
*n = (STRING_TO_TYPE) result;
#endif
return RTEMS_SUCCESSFUL;
3000c410: e3a00000 mov r0, #0
}
3000c414: e28dd004 add sp, sp, #4
3000c418: e8bd80f0 pop {r4, r5, r6, r7, pc}
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
3000c41c: eb000bbb bl 3000f310 <__errno> <== NOT EXECUTED 3000c420: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000c424: e3530022 cmp r3, #34 ; 0x22 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
3000c428: 03a0000a moveq r0, #10 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
3000c42c: 1afffff6 bne 3000c40c <rtems_string_to_pointer+0x64> <== NOT EXECUTED 3000c430: eafffff7 b 3000c414 <rtems_string_to_pointer+0x6c> <== NOT EXECUTED
30001db0 <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
30001db0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30001db4: e24ddf6a sub sp, sp, #424 ; 0x1a8
30001db8: e1a06001 mov r6, r1
30001dbc: e1a07002 mov r7, r2
30001dc0: e58d0014 str r0, [sp, #20]
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
30001dc4: eb00442d bl 30012e80 <strlen> 30001dc8: e28d2e19 add r2, sp, #400 ; 0x190 30001dcc: e1a01000 mov r1, r0 30001dd0: e58d2008 str r2, [sp, #8] 30001dd4: e59d0014 ldr r0, [sp, #20] 30001dd8: e3a02000 mov r2, #0 30001ddc: e28d3e19 add r3, sp, #400 ; 0x190 30001de0: e58d2000 str r2, [sp] 30001de4: eb0002bd bl 300028e0 <rtems_filesystem_evaluate_path>
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
30001de8: e3500000 cmp r0, #0
return -1;
30001dec: 13e02000 mvnne r2, #0
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
30001df0: e58d0010 str r0, [sp, #16]
return -1;
30001df4: 158d2010 strne r2, [sp, #16]
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
30001df8: 1a000032 bne 30001ec8 <rtems_tarfs_load+0x118>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
30001dfc: e59d319c ldr r3, [sp, #412] ; 0x19c 30001e00: e59f21d0 ldr r2, [pc, #464] ; 30001fd8 <rtems_tarfs_load+0x228> 30001e04: e1530002 cmp r3, r2 30001e08: 059da010 ldreq sl, [sp, #16]
30001e0c: 1a00006a bne 30001fbc <rtems_tarfs_load+0x20c>
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
30001e10: e28a4c02 add r4, sl, #512 ; 0x200
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
30001e14: 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)
30001e18: 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);
30001e1c: e28d5f46 add r5, sp, #280 ; 0x118
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
30001e20: e58d3004 str r3, [sp, #4]
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
30001e24: 8a000027 bhi 30001ec8 <rtems_tarfs_load+0x118>
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
30001e28: e086a00a add sl, r6, sl
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
30001e2c: e28a0c01 add r0, sl, #256 ; 0x100 30001e30: e2800001 add r0, r0, #1 30001e34: e59f11a0 ldr r1, [pc, #416] ; 30001fdc <rtems_tarfs_load+0x22c> 30001e38: e3a02005 mov r2, #5 30001e3c: eb004427 bl 30012ee0 <strncmp> 30001e40: e2508000 subs r8, r0, #0
30001e44: 1a00001f bne 30001ec8 <rtems_tarfs_load+0x118>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
30001e48: e3a02063 mov r2, #99 ; 0x63 30001e4c: e1a0100a mov r1, sl 30001e50: e1a00005 mov r0, r5 30001e54: eb00447d bl 30013050 <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
30001e58: e5cd817b strb r8, [sp, #379] ; 0x17b
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
30001e5c: e3a01008 mov r1, #8 30001e60: 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];
30001e64: e5dab09c ldrb fp, [sl, #156] ; 0x9c
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
30001e68: eb002061 bl 30009ff4 <_rtems_octal2ulong>
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
30001e6c: 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);
30001e70: e1a09000 mov r9, r0
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
30001e74: e28a007c add r0, sl, #124 ; 0x7c 30001e78: eb00205d bl 30009ff4 <_rtems_octal2ulong>
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
30001e7c: 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);
30001e80: e1a08000 mov r8, r0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
30001e84: e28a0094 add r0, sl, #148 ; 0x94 30001e88: eb002059 bl 30009ff4 <_rtems_octal2ulong> 30001e8c: e1a03000 mov r3, r0
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
30001e90: e1a0000a mov r0, sl 30001e94: e58d300c str r3, [sp, #12] 30001e98: eb002162 bl 3000a428 <_rtems_tar_header_checksum> 30001e9c: e59d300c ldr r3, [sp, #12] 30001ea0: e1500003 cmp r0, r3
30001ea4: 1a000007 bne 30001ec8 <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) {
30001ea8: e35b0035 cmp fp, #53 ; 0x35
30001eac: 0a00001a beq 30001f1c <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) {
30001eb0: e35b0030 cmp fp, #48 ; 0x30
30001eb4: 0a000006 beq 30001ed4 <rtems_tarfs_load+0x124>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
30001eb8: e1a0a004 mov sl, r4
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
30001ebc: e28a4c02 add r4, sl, #512 ; 0x200 30001ec0: e1540007 cmp r4, r7
30001ec4: 9affffd7 bls 30001e28 <rtems_tarfs_load+0x78>
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
30001ec8: e59d0010 ldr r0, [sp, #16]
30001ecc: e28ddf6a add sp, sp, #424 ; 0x1a8
30001ed0: 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;
30001ed4: e59dc008 ldr ip, [sp, #8]
30001ed8: e59de004 ldr lr, [sp, #4]
30001edc: e8bc000f ldm ip!, {r0, r1, r2, r3}
30001ee0: e8ae000f stmia lr!, {r0, r1, r2, r3}
30001ee4: e59cc000 ldr ip, [ip]
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
30001ee8: e1a00005 mov r0, r5 30001eec: e28d1f5f add r1, sp, #380 ; 0x17c 30001ef0: e28d2f69 add r2, sp, #420 ; 0x1a4
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
30001ef4: e58ec000 str ip, [lr]
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
30001ef8: eb00237d bl 3000acf4 <IMFS_evaluate_for_make> 30001efc: e250a000 subs sl, r0, #0
30001f00: 0a00001c beq 30001f78 <rtems_tarfs_load+0x1c8>
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
}
nblocks = (((file_size) + 511) & ~511) / 512;
30001f04: e2888f7f add r8, r8, #508 ; 0x1fc <== NOT EXECUTED 30001f08: e2888003 add r8, r8, #3 <== NOT EXECUTED 30001f0c: e1a084a8 lsr r8, r8, #9 <== NOT EXECUTED
offset += 512 * nblocks;
30001f10: 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)
30001f14: e1a0a004 mov sl, r4 30001f18: eaffffe7 b 30001ebc <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);
30001f1c: e59d1014 ldr r1, [sp, #20] 30001f20: e28d0018 add r0, sp, #24 30001f24: eb004211 bl 30012770 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
30001f28: e28d0018 add r0, sp, #24 30001f2c: eb0043d3 bl 30012e80 <strlen> 30001f30: e28def6a add lr, sp, #424 ; 0x1a8 30001f34: e08e3000 add r3, lr, r0 30001f38: e5533191 ldrb r3, [r3, #-401] ; 0x191 30001f3c: e353002f cmp r3, #47 ; 0x2f
30001f40: 0a000004 beq 30001f58 <rtems_tarfs_load+0x1a8>
strcat(full_filename, "/");
30001f44: e28d2018 add r2, sp, #24 <== NOT EXECUTED 30001f48: e0820000 add r0, r2, r0 <== NOT EXECUTED 30001f4c: e59f108c ldr r1, [pc, #140] ; 30001fe0 <rtems_tarfs_load+0x230><== NOT EXECUTED 30001f50: e3a02002 mov r2, #2 <== NOT EXECUTED 30001f54: eb003eee bl 30011b14 <memcpy> <== NOT EXECUTED
strcat(full_filename, filename);
30001f58: e1a01005 mov r1, r5 30001f5c: e28d0018 add r0, sp, #24 30001f60: eb00414b bl 30012494 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
30001f64: e28d0018 add r0, sp, #24 30001f68: e59f1074 ldr r1, [pc, #116] ; 30001fe4 <rtems_tarfs_load+0x234> 30001f6c: eb0004be bl 3000326c <mkdir>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
30001f70: e1a0a004 mov sl, r4 30001f74: eaffffd0 b 30001ebc <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,
30001f78: e1a03b89 lsl r3, r9, #23 30001f7c: 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(
30001f80: e3833902 orr r3, r3, #32768 ; 0x8000 30001f84: e3a01006 mov r1, #6 30001f88: e28d0f5f add r0, sp, #380 ; 0x17c 30001f8c: e59d21a4 ldr r2, [sp, #420] ; 0x1a4 30001f90: e58da000 str sl, [sp] 30001f94: eb0021a7 bl 3000a638 <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;
30001f98: e5808050 str r8, [r0, #80] ; 0x50
node->info.linearfile.direct = &tar_image[offset];
}
nblocks = (((file_size) + 511) & ~511) / 512;
30001f9c: e2888f7f add r8, r8, #508 ; 0x1fc 30001fa0: 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];
30001fa4: e0863004 add r3, r6, r4
}
nblocks = (((file_size) + 511) & ~511) / 512;
30001fa8: 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;
30001fac: e580a054 str sl, [r0, #84] ; 0x54
node->info.linearfile.direct = &tar_image[offset];
30001fb0: e5803058 str r3, [r0, #88] ; 0x58
}
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
30001fb4: e0844488 add r4, r4, r8, lsl #9 30001fb8: eaffffd5 b 30001f14 <rtems_tarfs_load+0x164>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
30001fbc: e59f2024 ldr r2, [pc, #36] ; 30001fe8 <rtems_tarfs_load+0x238> 30001fc0: e1530002 cmp r3, r2 30001fc4: 01a0a000 moveq sl, r0
30001fc8: 0affff90 beq 30001e10 <rtems_tarfs_load+0x60>
return -1;
30001fcc: e3e03000 mvn r3, #0 30001fd0: e58d3010 str r3, [sp, #16] 30001fd4: eaffffbb b 30001ec8 <rtems_tarfs_load+0x118>
3000d6cc <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
3000d6cc: 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 )
3000d6d0: e2525000 subs r5, r2, #0
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
3000d6d4: e1a04000 mov r4, r0 3000d6d8: 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;
3000d6dc: 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 )
3000d6e0: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
3000d6e4: e59f9148 ldr r9, [pc, #328] ; 3000d834 <rtems_task_mode+0x168> 3000d6e8: 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;
3000d6ec: e5d7a074 ldrb sl, [r7, #116] ; 0x74
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
3000d6f0: 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 )
3000d6f4: 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;
3000d6f8: 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;
3000d6fc: 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;
3000d700: 03a0ac01 moveq sl, #256 ; 0x100 3000d704: 13a0a000 movne sl, #0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
3000d708: e3530000 cmp r3, #0
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
3000d70c: 138aac02 orrne sl, sl, #512 ; 0x200
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
3000d710: e35b0000 cmp fp, #0 3000d714: 03a0bb01 moveq fp, #1024 ; 0x400 3000d718: 13a0b000 movne fp, #0
old_mode |= _ISR_Get_level();
3000d71c: ebffee80 bl 30009124 <_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;
3000d720: e18bb000 orr fp, fp, r0
old_mode |= _ISR_Get_level();
3000d724: e18ba00a orr sl, fp, sl
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
3000d728: 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;
3000d72c: e585a000 str sl, [r5]
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
3000d730: 0a000003 beq 3000d744 <rtems_task_mode+0x78>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
3000d734: e3140c01 tst r4, #256 ; 0x100 3000d738: 13a03000 movne r3, #0 3000d73c: 03a03001 moveq r3, #1 3000d740: e5c73074 strb r3, [r7, #116] ; 0x74
if ( mask & RTEMS_TIMESLICE_MASK ) {
3000d744: e3160c02 tst r6, #512 ; 0x200
3000d748: 1a000028 bne 3000d7f0 <rtems_task_mode+0x124>
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
3000d74c: e3160080 tst r6, #128 ; 0x80
3000d750: 1a00002f bne 3000d814 <rtems_task_mode+0x148>
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
3000d754: e2166b01 ands r6, r6, #1024 ; 0x400
3000d758: 0a000012 beq 3000d7a8 <rtems_task_mode+0xdc>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
3000d75c: 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 ) {
3000d760: e5d82008 ldrb r2, [r8, #8]
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
3000d764: 13a03000 movne r3, #0 3000d768: 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 ) {
3000d76c: e1520003 cmp r2, r3
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
3000d770: 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 ) {
3000d774: 0a00000b beq 3000d7a8 <rtems_task_mode+0xdc>
asr->is_enabled = is_asr_enabled;
3000d778: e5c83008 strb r3, [r8, #8]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
3000d77c: e10f3000 mrs r3, CPSR 3000d780: e3832080 orr r2, r3, #128 ; 0x80 3000d784: e129f002 msr CPSR_fc, r2
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
3000d788: e5981018 ldr r1, [r8, #24]
information->signals_pending = information->signals_posted;
3000d78c: e5982014 ldr r2, [r8, #20]
information->signals_posted = _signals;
3000d790: 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;
3000d794: e5882018 str r2, [r8, #24]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3000d798: e129f003 msr CPSR_fc, r3
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
3000d79c: e5986014 ldr r6, [r8, #20] 3000d7a0: e3560000 cmp r6, #0
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
3000d7a4: 13a06001 movne r6, #1
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
3000d7a8: e59f3088 ldr r3, [pc, #136] ; 3000d838 <rtems_task_mode+0x16c> 3000d7ac: e5933000 ldr r3, [r3] 3000d7b0: e3530003 cmp r3, #3
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
3000d7b4: 13a00000 movne r0, #0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
3000d7b8: 18bd8ff0 popne {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
Thread_Control *executing;
executing = _Thread_Executing;
if ( are_signals_pending ||
3000d7bc: e3560000 cmp r6, #0
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
3000d7c0: e5993004 ldr r3, [r9, #4]
if ( are_signals_pending ||
3000d7c4: 1a000015 bne 3000d820 <rtems_task_mode+0x154>
3000d7c8: e59f2064 ldr r2, [pc, #100] ; 3000d834 <rtems_task_mode+0x168> 3000d7cc: e5922008 ldr r2, [r2, #8] 3000d7d0: e1530002 cmp r3, r2
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
3000d7d4: 01a00006 moveq r0, r6
3000d7d8: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
3000d7dc: e5d33074 ldrb r3, [r3, #116] ; 0x74 3000d7e0: e3530000 cmp r3, #0
3000d7e4: 1a00000d bne 3000d820 <rtems_task_mode+0x154>
3000d7e8: e1a00006 mov r0, r6 <== NOT EXECUTED
}
3000d7ec: 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) ) {
3000d7f0: e2143c02 ands r3, r4, #512 ; 0x200
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000d7f4: 159f3040 ldrne r3, [pc, #64] ; 3000d83c <rtems_task_mode+0x170>
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;
3000d7f8: 13a02001 movne r2, #1
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000d7fc: 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;
3000d800: 1587207c strne r2, [r7, #124] ; 0x7c
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000d804: 15873078 strne r3, [r7, #120] ; 0x78
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
3000d808: 0587307c streq r3, [r7, #124] ; 0x7c
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
3000d80c: e3160080 tst r6, #128 ; 0x80
3000d810: 0affffcf beq 3000d754 <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 ) );
3000d814: e2040080 and r0, r4, #128 ; 0x80 3000d818: ebffee3c bl 30009110 <_CPU_ISR_Set_level> 3000d81c: eaffffcc b 3000d754 <rtems_task_mode+0x88>
_Thread_Dispatch_necessary = true;
3000d820: e3a03001 mov r3, #1 3000d824: e5c93010 strb r3, [r9, #16]
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
3000d828: ebffe859 bl 30007994 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
3000d82c: e3a00000 mov r0, #0
3000d830: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000347c <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
3000347c: 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(
30003480: e59f51a4 ldr r5, [pc, #420] ; 3000362c <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;
30003484: e5903000 ldr r3, [r0]
rtems_status_code sc;
sc = rtems_semaphore_obtain(
30003488: e3a01000 mov r1, #0
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
3000348c: 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(
30003490: e1a02001 mov r2, r1 30003494: 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;
30003498: e5934034 ldr r4, [r3, #52] ; 0x34
rtems_status_code sc;
sc = rtems_semaphore_obtain(
3000349c: eb000879 bl 30005688 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
300034a0: e3500000 cmp r0, #0
300034a4: 1a00005f bne 30003628 <rtems_termios_close+0x1ac>
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
300034a8: e5943008 ldr r3, [r4, #8] 300034ac: e2433001 sub r3, r3, #1 300034b0: e3530000 cmp r3, #0 300034b4: e5843008 str r3, [r4, #8]
300034b8: 1a00002f bne 3000357c <rtems_termios_close+0x100>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
300034bc: e59420cc ldr r2, [r4, #204] ; 0xcc 300034c0: e59f3168 ldr r3, [pc, #360] ; 30003630 <rtems_termios_close+0x1b4> 300034c4: e0833282 add r3, r3, r2, lsl #5 300034c8: e5931004 ldr r1, [r3, #4] 300034cc: e3510000 cmp r1, #0
300034d0: 0a00003e beq 300035d0 <rtems_termios_close+0x154>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
300034d4: e1a00004 mov r0, r4 300034d8: e1a0e00f mov lr, pc 300034dc: e12fff11 bx r1
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
300034e0: e59430b4 ldr r3, [r4, #180] ; 0xb4 300034e4: e3530002 cmp r3, #2
300034e8: 0a000044 beq 30003600 <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)
300034ec: e594309c ldr r3, [r4, #156] ; 0x9c 300034f0: e3530000 cmp r3, #0
(*tty->device.lastClose)(tty->major, tty->minor, arg);
300034f4: 1594000c ldrne r0, [r4, #12] 300034f8: 15941010 ldrne r1, [r4, #16] 300034fc: 11a02006 movne r2, r6 30003500: 11a0e00f movne lr, pc 30003504: 112fff13 bxne r3
if (tty->forw == NULL) {
30003508: e5943000 ldr r3, [r4] 3000350c: e3530000 cmp r3, #0
30003510: 0a000026 beq 300035b0 <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;
30003514: e5942004 ldr r2, [r4, #4] 30003518: e5832004 str r2, [r3, #4] 3000351c: e5942004 ldr r2, [r4, #4]
}
if (tty->back == NULL) {
30003520: e3520000 cmp r2, #0
30003524: 0a00001b beq 30003598 <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;
30003528: e5823000 str r3, [r2]
}
rtems_semaphore_delete (tty->isem);
3000352c: e5940014 ldr r0, [r4, #20] 30003530: eb00082b bl 300055e4 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
30003534: e5940018 ldr r0, [r4, #24] 30003538: eb000829 bl 300055e4 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
3000353c: e594008c ldr r0, [r4, #140] ; 0x8c 30003540: eb000827 bl 300055e4 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
30003544: e59430a0 ldr r3, [r4, #160] ; 0xa0 30003548: e3530000 cmp r3, #0
3000354c: 0a00000e beq 3000358c <rtems_termios_close+0x110>
30003550: e59430b4 ldr r3, [r4, #180] ; 0xb4 30003554: e3530002 cmp r3, #2
30003558: 0a00000b beq 3000358c <rtems_termios_close+0x110>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
free (tty->rawInBuf.theBuf);
3000355c: e5940058 ldr r0, [r4, #88] ; 0x58 30003560: ebfffaa8 bl 30002008 <free>
free (tty->rawOutBuf.theBuf);
30003564: e594007c ldr r0, [r4, #124] ; 0x7c 30003568: ebfffaa6 bl 30002008 <free>
free (tty->cbuf);
3000356c: e594001c ldr r0, [r4, #28] 30003570: ebfffaa4 bl 30002008 <free>
free (tty);
30003574: e1a00004 mov r0, r4 30003578: ebfffaa2 bl 30002008 <free>
} rtems_semaphore_release (rtems_termios_ttyMutex);
3000357c: e5950000 ldr r0, [r5] 30003580: eb000889 bl 300057ac <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
30003584: e3a00000 mov r0, #0
30003588: 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);
3000358c: e5940068 ldr r0, [r4, #104] ; 0x68 30003590: eb000813 bl 300055e4 <rtems_semaphore_delete> 30003594: eafffff0 b 3000355c <rtems_termios_close+0xe0>
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
30003598: e59f2094 ldr r2, [pc, #148] ; 30003634 <rtems_termios_close+0x1b8>
if ( rtems_termios_ttyHead != NULL ) {
3000359c: e3530000 cmp r3, #0
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
300035a0: e5823000 str r3, [r2]
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
300035a4: 13a02000 movne r2, #0 300035a8: 15832004 strne r2, [r3, #4] 300035ac: eaffffde b 3000352c <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;
300035b0: e5942004 ldr r2, [r4, #4] 300035b4: e59f107c ldr r1, [pc, #124] ; 30003638 <rtems_termios_close+0x1bc>
if ( rtems_termios_ttyTail != NULL ) {
300035b8: 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;
300035bc: e5812000 str r2, [r1]
if ( rtems_termios_ttyTail != NULL ) {
300035c0: 0afffff4 beq 30003598 <rtems_termios_close+0x11c>
rtems_termios_ttyTail->forw = NULL;
300035c4: e5823000 str r3, [r2] 300035c8: e5943000 ldr r3, [r4] 300035cc: eaffffd5 b 30003528 <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);
300035d0: e5940018 ldr r0, [r4, #24] 300035d4: e1a02001 mov r2, r1 300035d8: eb00082a bl 30005688 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
300035dc: e3500000 cmp r0, #0
300035e0: 1a000010 bne 30003628 <rtems_termios_close+0x1ac>
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
300035e4: e1a00004 mov r0, r4 300035e8: ebfffe57 bl 30002f4c <drainOutput>
rtems_semaphore_release (tty->osem);
300035ec: e5940018 ldr r0, [r4, #24] 300035f0: eb00086d bl 300057ac <rtems_semaphore_release>
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
300035f4: e59430b4 ldr r3, [r4, #180] ; 0xb4 300035f8: e3530002 cmp r3, #2
300035fc: 1affffba bne 300034ec <rtems_termios_close+0x70>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
30003600: e59400c4 ldr r0, [r4, #196] ; 0xc4 30003604: e3a01001 mov r1, #1 30003608: eb0006fb bl 300051fc <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
3000360c: e3500000 cmp r0, #0
30003610: 1a000004 bne 30003628 <rtems_termios_close+0x1ac>
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
30003614: e59400c8 ldr r0, [r4, #200] ; 0xc8 30003618: e3a01001 mov r1, #1 3000361c: eb0006f6 bl 300051fc <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
30003620: e3500000 cmp r0, #0
30003624: 0affffb0 beq 300034ec <rtems_termios_close+0x70>
rtems_fatal_error_occurred (sc);
30003628: eb0009bf bl 30005d2c <rtems_fatal_error_occurred> <== NOT EXECUTED
30004c0c <rtems_termios_dequeue_characters>:
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
30004c0c: e590c090 ldr ip, [r0, #144] ; 0x90
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
30004c10: e59020b4 ldr r2, [r0, #180] ; 0xb4
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
30004c14: e08c1001 add r1, ip, r1
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
30004c18: 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)
{
30004c1c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
30004c20: e5801090 str r1, [r0, #144] ; 0x90
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
30004c24: 0a00000c beq 30004c5c <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 ) {
30004c28: e59030cc ldr r3, [r0, #204] ; 0xcc 30004c2c: e3530005 cmp r3, #5
30004c30: 0a000001 beq 30004c3c <rtems_termios_dequeue_characters+0x30>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
30004c34: 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);
30004c38: eaffff55 b 30004994 <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) {
30004c3c: e59f303c ldr r3, [pc, #60] ; 30004c80 <rtems_termios_dequeue_characters+0x74> 30004c40: e59330b4 ldr r3, [r3, #180] ; 0xb4 30004c44: e3530000 cmp r3, #0
30004c48: 0a00000a beq 30004c78 <rtems_termios_dequeue_characters+0x6c>
rtems_termios_linesw[tty->t_line].l_start(tty);
30004c4c: e1a0e00f mov lr, pc 30004c50: e12fff13 bx r3
}
return 0; /* nothing to output in IRQ... */
30004c54: e3a00000 mov r0, #0
30004c58: 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);
30004c5c: e59000c8 ldr r0, [r0, #200] ; 0xc8 30004c60: e1a01002 mov r1, r2 30004c64: eb000164 bl 300051fc <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
30004c68: e2503000 subs r3, r0, #0
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
30004c6c: 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)
30004c70: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred (sc);
30004c74: eb00042c bl 30005d2c <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... */
30004c78: e1a00003 mov r0, r3 <== NOT EXECUTED
}
return rtems_termios_refill_transmitter(tty);
}
30004c7c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30004618 <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)
{
30004618: 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) {
3000461c: e59030cc ldr r3, [r0, #204] ; 0xcc 30004620: e59f72d8 ldr r7, [pc, #728] ; 30004900 <rtems_termios_enqueue_raw_characters+0x2e8>
* 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)
{
30004624: e24dd008 sub sp, sp, #8
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) {
30004628: e0873283 add r3, r7, r3, lsl #5 3000462c: e5939010 ldr r9, [r3, #16]
* 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)
{
30004630: e1a04000 mov r4, r0
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) {
30004634: 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)
{
30004638: e1a05001 mov r5, r1 3000463c: 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) {
30004640: 0a00001e beq 300046c0 <rtems_termios_enqueue_raw_characters+0xa8>
while (len--) {
30004644: e3520000 cmp r2, #0
30004648: 0a00000b beq 3000467c <rtems_termios_enqueue_raw_characters+0x64>
3000464c: e3a08000 mov r8, #0 30004650: ea000002 b 30004660 <rtems_termios_enqueue_raw_characters+0x48> 30004654: e59430cc ldr r3, [r4, #204] ; 0xcc 30004658: e0873283 add r3, r7, r3, lsl #5 3000465c: e5939010 ldr r9, [r3, #16]
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
30004660: e7d50008 ldrb r0, [r5, r8] 30004664: e1a01004 mov r1, r4 30004668: e2888001 add r8, r8, #1 3000466c: e1a0e00f mov lr, pc 30004670: 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--) {
30004674: e1580006 cmp r8, r6
30004678: 1afffff5 bne 30004654 <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 )) {
3000467c: e594a0e4 ldr sl, [r4, #228] ; 0xe4 30004680: e35a0000 cmp sl, #0
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
30004684: 13a0a000 movne sl, #0
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
30004688: 1a000009 bne 300046b4 <rtems_termios_enqueue_raw_characters+0x9c>
3000468c: e59430dc ldr r3, [r4, #220] ; 0xdc 30004690: e3530000 cmp r3, #0
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
30004694: 01a0a003 moveq sl, r3
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
30004698: 0a000005 beq 300046b4 <rtems_termios_enqueue_raw_characters+0x9c>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
3000469c: e2840030 add r0, r4, #48 ; 0x30 300046a0: e59410e0 ldr r1, [r4, #224] ; 0xe0 300046a4: e1a0e00f mov lr, pc 300046a8: e12fff13 bx r3
tty->tty_rcvwakeup = 1;
300046ac: e3a03001 mov r3, #1 300046b0: e58430e4 str r3, [r4, #228] ; 0xe4
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
300046b4: e1a0000a mov r0, sl
300046b8: e28dd008 add sp, sp, #8
300046bc: 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);
300046c0: e2803030 add r3, r0, #48 ; 0x30 300046c4: e58d3000 str r3, [sp]
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
300046c8: 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,
300046cc: e280304a add r3, r0, #74 ; 0x4a 300046d0: e58d3004 str r3, [sp, #4] 300046d4: e1a0b009 mov fp, r9
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
300046d8: 0a000042 beq 300047e8 <rtems_termios_enqueue_raw_characters+0x1d0>
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
300046dc: e59430b8 ldr r3, [r4, #184] ; 0xb8
}
return 0;
}
while (len--) {
c = *buf++;
300046e0: 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) {
300046e4: e3130c02 tst r3, #512 ; 0x200
300046e8: 0a000005 beq 30004704 <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]) {
300046ec: e5d4304a ldrb r3, [r4, #74] ; 0x4a 300046f0: e1530008 cmp r3, r8
300046f4: 0a000056 beq 30004854 <rtems_termios_enqueue_raw_characters+0x23c>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
300046f8: e5d43049 ldrb r3, [r4, #73] ; 0x49 300046fc: e1530008 cmp r3, r8
30004700: 0a00003f beq 30004804 <rtems_termios_enqueue_raw_characters+0x1ec>
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
30004704: e3590000 cmp r9, #0
30004708: 1a000041 bne 30004814 <rtems_termios_enqueue_raw_characters+0x1fc>
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
3000470c: e5940060 ldr r0, [r4, #96] ; 0x60 30004710: e5941064 ldr r1, [r4, #100] ; 0x64 30004714: e2800001 add r0, r0, #1 30004718: eb00331b bl 3001138c <__umodsi3> 3000471c: e1a07000 mov r7, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30004720: e10fa000 mrs sl, CPSR 30004724: e38a3080 orr r3, sl, #128 ; 0x80 30004728: e129f003 msr CPSR_fc, r3
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
3000472c: e594305c ldr r3, [r4, #92] ; 0x5c 30004730: e5940064 ldr r0, [r4, #100] ; 0x64
% tty->rawInBuf.Size) > tty->highwater) &&
30004734: e5941064 ldr r1, [r4, #100] ; 0x64
}
} 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)
30004738: e0630000 rsb r0, r3, r0
% tty->rawInBuf.Size) > tty->highwater) &&
3000473c: e0800007 add r0, r0, r7 30004740: eb003311 bl 3001138c <__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)
30004744: e59430c0 ldr r3, [r4, #192] ; 0xc0 30004748: e1500003 cmp r0, r3
3000474c: 9a00000e bls 3000478c <rtems_termios_enqueue_raw_characters+0x174>
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
30004750: 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) &&
30004754: e3130001 tst r3, #1 <== NOT EXECUTED 30004758: 1a00000b bne 3000478c <rtems_termios_enqueue_raw_characters+0x174><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
3000475c: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
30004760: e59f319c ldr r3, [pc, #412] ; 30004904 <rtems_termios_enqueue_raw_characters+0x2ec><== NOT EXECUTED
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
30004764: e3822001 orr r2, r2, #1 <== NOT EXECUTED 30004768: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
3000476c: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED 30004770: e0023003 and r3, r2, r3 <== NOT EXECUTED 30004774: e3530b01 cmp r3, #1024 ; 0x400 <== NOT EXECUTED 30004778: 0a000047 beq 3000489c <rtems_termios_enqueue_raw_characters+0x284><== 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) ) {
3000477c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30004780: e2033f41 and r3, r3, #260 ; 0x104 <== NOT EXECUTED 30004784: e3530c01 cmp r3, #256 ; 0x100 <== NOT EXECUTED 30004788: 0a000052 beq 300048d8 <rtems_termios_enqueue_raw_characters+0x2c0><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3000478c: e129f00a msr CPSR_fc, sl
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
30004790: e594305c ldr r3, [r4, #92] ; 0x5c 30004794: e1530007 cmp r3, r7
dropped++;
30004798: 028bb001 addeq fp, fp, #1
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
3000479c: 0a00000e beq 300047dc <rtems_termios_enqueue_raw_characters+0x1c4>
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
300047a0: e5943058 ldr r3, [r4, #88] ; 0x58 300047a4: 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 )) {
300047a8: e59430e4 ldr r3, [r4, #228] ; 0xe4
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
300047ac: 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 )) {
300047b0: e3530000 cmp r3, #0
300047b4: 1a000008 bne 300047dc <rtems_termios_enqueue_raw_characters+0x1c4>
300047b8: e59430dc ldr r3, [r4, #220] ; 0xdc 300047bc: e3530000 cmp r3, #0
300047c0: 0a000005 beq 300047dc <rtems_termios_enqueue_raw_characters+0x1c4>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
300047c4: e59d0000 ldr r0, [sp] <== NOT EXECUTED 300047c8: e59410e0 ldr r1, [r4, #224] ; 0xe0 <== NOT EXECUTED 300047cc: e1a0e00f mov lr, pc <== NOT EXECUTED 300047d0: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
300047d4: e3a03001 mov r3, #1 <== NOT EXECUTED 300047d8: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
300047dc: e2466001 sub r6, r6, #1
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
300047e0: e3560000 cmp r6, #0
300047e4: 1affffbc bne 300046dc <rtems_termios_enqueue_raw_characters+0xc4>
}
}
}
}
tty->rawInBufDropped += dropped;
300047e8: e5943078 ldr r3, [r4, #120] ; 0x78
rtems_semaphore_release (tty->rawInBuf.Semaphore);
300047ec: e5940068 ldr r0, [r4, #104] ; 0x68
}
}
}
}
tty->rawInBufDropped += dropped;
300047f0: e083300b add r3, r3, fp 300047f4: e5843078 str r3, [r4, #120] ; 0x78 300047f8: e1a0a00b mov sl, fp
rtems_semaphore_release (tty->rawInBuf.Semaphore);
300047fc: eb0003ea bl 300057ac <rtems_semaphore_release>
return dropped;
30004800: eaffffab b 300046b4 <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;
30004804: e59430b8 ldr 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--) {
30004808: e3a09001 mov r9, #1 <== NOT EXECUTED
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
3000480c: e3c33010 bic r3, r3, #16 <== NOT EXECUTED 30004810: e58430b8 str r3, [r4, #184] ; 0xb8 <== 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) {
30004814: e59430b8 ldr r3, [r4, #184] ; 0xb8 30004818: e2033030 and r3, r3, #48 ; 0x30 3000481c: e3530020 cmp r3, #32
30004820: 1affffed bne 300047dc <rtems_termios_enqueue_raw_characters+0x1c4>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30004824: e10f7000 mrs r7, CPSR <== NOT EXECUTED 30004828: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED 3000482c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
30004830: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30004834: 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;
30004838: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
3000483c: 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;
30004840: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30004844: 1a00000c bne 3000487c <rtems_termios_enqueue_raw_characters+0x264><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
30004848: 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;
3000484c: e2466001 sub r6, r6, #1 <== NOT EXECUTED 30004850: eaffffe2 b 300047e0 <rtems_termios_enqueue_raw_characters+0x1c8><== 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]) {
30004854: e5d42049 ldrb r2, [r4, #73] ; 0x49
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--) {
30004858: e3a09001 mov r9, #1
/* 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]) {
3000485c: e1520003 cmp r2, r3
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
30004860: 059430b8 ldreq r3, [r4, #184] ; 0xb8
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
30004864: 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;
30004868: 02233010 eoreq r3, r3, #16
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
3000486c: 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;
30004870: 058430b8 streq r3, [r4, #184] ; 0xb8
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
30004874: 158430b8 strne r3, [r4, #184] ; 0xb8 30004878: eaffffe5 b 30004814 <rtems_termios_enqueue_raw_characters+0x1fc>
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);
3000487c: 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)(
30004880: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED 30004884: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30004888: e0811003 add r1, r1, r3 <== NOT EXECUTED 3000488c: e3a02001 mov r2, #1 <== NOT EXECUTED 30004890: e1a0e00f mov lr, pc <== NOT EXECUTED 30004894: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED 30004898: eaffffea b 30004848 <rtems_termios_enqueue_raw_characters+0x230><== 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) ||
3000489c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300048a0: e3130020 tst r3, #32 <== NOT EXECUTED 300048a4: 1a000002 bne 300048b4 <rtems_termios_enqueue_raw_characters+0x29c><== NOT EXECUTED 300048a8: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED 300048ac: e3530000 cmp r3, #0 <== NOT EXECUTED 300048b0: 1affffb5 bne 3000478c <rtems_termios_enqueue_raw_characters+0x174><== 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;
300048b4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
300048b8: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
== (FL_MDXOF ) ) {
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;
300048bc: e3833002 orr r3, r3, #2 <== NOT EXECUTED 300048c0: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
300048c4: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 300048c8: e3a02001 mov r2, #1 <== NOT EXECUTED 300048cc: e1a0e00f mov lr, pc <== NOT EXECUTED 300048d0: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED 300048d4: eaffffac b 3000478c <rtems_termios_enqueue_raw_characters+0x174><== 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;
300048d8: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
300048dc: 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;
300048e0: e3822004 orr r2, r2, #4 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
300048e4: 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;
300048e8: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
300048ec: 0affffa6 beq 3000478c <rtems_termios_enqueue_raw_characters+0x174><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
300048f0: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 300048f4: e1a0e00f mov lr, pc <== NOT EXECUTED 300048f8: e12fff13 bx r3 <== NOT EXECUTED 300048fc: eaffffa2 b 3000478c <rtems_termios_enqueue_raw_characters+0x174><== NOT EXECUTED
30003654 <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;
30003654: e5902000 ldr r2, [r0]
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
30003658: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
3000365c: e5925034 ldr r5, [r2, #52] ; 0x34
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
30003660: e3a03000 mov r3, #0
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
30003664: 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;
30003668: e580300c str r3, [r0, #12]
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3000366c: e1a01003 mov r1, r3 30003670: e5950018 ldr r0, [r5, #24] 30003674: 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;
30003678: e5947008 ldr r7, [r4, #8]
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3000367c: eb000801 bl 30005688 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
30003680: e2506000 subs r6, r0, #0
30003684: 1a00000e bne 300036c4 <rtems_termios_ioctl+0x70>
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
30003688: e5943004 ldr r3, [r4, #4] 3000368c: e3530004 cmp r3, #4
30003690: 0a000006 beq 300036b0 <rtems_termios_ioctl+0x5c> 30003694: 8a00000d bhi 300036d0 <rtems_termios_ioctl+0x7c>
30003698: e3530002 cmp r3, #2
3000369c: 0a00001e beq 3000371c <rtems_termios_ioctl+0xc8>
300036a0: 9a000085 bls 300038bc <rtems_termios_ioctl+0x268>
if (tty->device.setAttributes)
(*tty->device.setAttributes)(tty->minor, &tty->termios);
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
300036a4: e1a00005 mov r0, r5 300036a8: ebfffe27 bl 30002f4c <drainOutput>
break;
300036ac: ea000002 b 300036bc <rtems_termios_ioctl+0x68>
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
300036b0: e897000c ldm r7, {r2, r3}
300036b4: e58520dc str r2, [r5, #220] ; 0xdc
300036b8: e58530e0 str r3, [r5, #224] ; 0xe0
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
300036bc: e5950018 ldr r0, [r5, #24] 300036c0: eb000839 bl 300057ac <rtems_semaphore_release>
args->ioctl_return = sc;
300036c4: e584600c str r6, [r4, #12]
return sc; }
300036c8: e1a00006 mov r0, r6
300036cc: 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) {
300036d0: e59f2340 ldr r2, [pc, #832] ; 30003a18 <rtems_termios_ioctl+0x3c4> 300036d4: e1530002 cmp r3, r2
300036d8: 0a00006b beq 3000388c <rtems_termios_ioctl+0x238> 300036dc: 8a000082 bhi 300038ec <rtems_termios_ioctl+0x298>
300036e0: e3530005 cmp r3, #5
300036e4: 0a0000a1 beq 30003970 <rtems_termios_ioctl+0x31c>
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
300036e8: e59520cc ldr r2, [r5, #204] ; 0xcc 300036ec: e59f3328 ldr r3, [pc, #808] ; 30003a1c <rtems_termios_ioctl+0x3c8> 300036f0: e0833282 add r3, r3, r2, lsl #5 300036f4: e5933018 ldr r3, [r3, #24] 300036f8: e3530000 cmp r3, #0
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
300036fc: 03a0600a moveq r6, #10
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
30003700: 0affffed beq 300036bc <rtems_termios_ioctl+0x68>
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
30003704: e1a00005 mov r0, r5 30003708: e1a01004 mov r1, r4 3000370c: e1a0e00f mov lr, pc 30003710: e12fff13 bx r3 30003714: e1a06000 mov r6, r0 30003718: eaffffe7 b 300036bc <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;
3000371c: e594e008 ldr lr, [r4, #8]
30003720: e2857030 add r7, r5, #48 ; 0x30
30003724: e1a0c007 mov ip, r7
30003728: e8be000f ldm lr!, {r0, r1, r2, r3}
3000372c: e8ac000f stmia ip!, {r0, r1, r2, r3}
30003730: e8be000f ldm lr!, {r0, r1, r2, r3}
30003734: 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) &&
30003738: 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;
3000373c: 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) &&
30003740: 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;
30003744: 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) &&
30003748: 0a000012 beq 30003798 <rtems_termios_ioctl+0x144>
!(tty->termios.c_iflag & IXON)) {
3000374c: 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) &&
30003750: e3130b01 tst r3, #1024 ; 0x400
30003754: 1a00000f bne 30003798 <rtems_termios_ioctl+0x144>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
30003758: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 3000375c: e3c33e21 bic r3, r3, #528 ; 0x210 <== NOT EXECUTED 30003760: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
30003764: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30003768: e3130020 tst r3, #32 <== NOT EXECUTED 3000376c: 0a000009 beq 30003798 <rtems_termios_ioctl+0x144> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30003770: e10f8000 mrs r8, CPSR <== NOT EXECUTED 30003774: e3883080 orr r3, r8, #128 ; 0x80 <== NOT EXECUTED 30003778: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
3000377c: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30003780: 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;
30003784: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30003788: 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;
3000378c: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30003790: 1a000098 bne 300039f8 <rtems_termios_ioctl+0x3a4> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
30003794: 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)) {
30003798: e59530b8 ldr r3, [r5, #184] ; 0xb8 3000379c: e3130b01 tst r3, #1024 ; 0x400
300037a0: 0a000008 beq 300037c8 <rtems_termios_ioctl+0x174>
300037a4: e5953030 ldr r3, [r5, #48] ; 0x30 <== NOT EXECUTED 300037a8: e3130a01 tst r3, #4096 ; 0x1000 <== NOT EXECUTED 300037ac: 1a000005 bne 300037c8 <rtems_termios_ioctl+0x174> <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
300037b0: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 300037b4: e3c33b01 bic r3, r3, #1024 ; 0x400 <== NOT EXECUTED 300037b8: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
300037bc: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 300037c0: e3c33002 bic r3, r3, #2 <== NOT EXECUTED 300037c4: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
300037c8: e59530b8 ldr r3, [r5, #184] ; 0xb8 300037cc: e3130c01 tst r3, #256 ; 0x100 300037d0: 05952038 ldreq r2, [r5, #56] ; 0x38
300037d4: 0a000012 beq 30003824 <rtems_termios_ioctl+0x1d0>
300037d8: e5952038 ldr r2, [r5, #56] ; 0x38 <== NOT EXECUTED 300037dc: e3520000 cmp r2, #0 <== NOT EXECUTED 300037e0: ba000078 blt 300039c8 <rtems_termios_ioctl+0x374> <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
300037e4: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 300037e8: e3c33c01 bic r3, r3, #256 ; 0x100 <== NOT EXECUTED 300037ec: 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)) {
300037f0: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 300037f4: e3130004 tst r3, #4 <== NOT EXECUTED 300037f8: 0a000006 beq 30003818 <rtems_termios_ioctl+0x1c4> <== NOT EXECUTED 300037fc: e59530b0 ldr r3, [r5, #176] ; 0xb0 <== NOT EXECUTED 30003800: e3530000 cmp r3, #0 <== NOT EXECUTED 30003804: 0a000003 beq 30003818 <rtems_termios_ioctl+0x1c4> <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
30003808: e5950010 ldr r0, [r5, #16] <== NOT EXECUTED 3000380c: e1a0e00f mov lr, pc <== NOT EXECUTED 30003810: e12fff13 bx r3 <== NOT EXECUTED 30003814: e5952038 ldr r2, [r5, #56] ; 0x38 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
30003818: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 3000381c: e3c33004 bic r3, r3, #4 <== NOT EXECUTED 30003820: 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) {
30003824: e3520000 cmp r2, #0
30003828: ba000066 blt 300039c8 <rtems_termios_ioctl+0x374>
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
3000382c: e5953030 ldr r3, [r5, #48] ; 0x30
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) {
30003830: e595803c ldr r8, [r5, #60] ; 0x3c
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
30003834: e3130a01 tst r3, #4096 ; 0x1000
tty->flow_ctrl |= FL_MDXOF;
30003838: 159520b8 ldrne r2, [r5, #184] ; 0xb8 3000383c: 13822b01 orrne r2, r2, #1024 ; 0x400 30003840: 158520b8 strne r2, [r5, #184] ; 0xb8
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
30003844: e3130b01 tst r3, #1024 ; 0x400
tty->flow_ctrl |= FL_MDXON;
30003848: 159530b8 ldrne r3, [r5, #184] ; 0xb8 3000384c: 13833c02 orrne r3, r3, #512 ; 0x200 30003850: 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) {
30003854: e2188002 ands r8, r8, #2
30003858: 0a000048 beq 30003980 <rtems_termios_ioctl+0x32c>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
3000385c: e3a03000 mov r3, #0 30003860: e585306c str r3, [r5, #108] ; 0x6c
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
30003864: e5853070 str r3, [r5, #112] ; 0x70
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
30003868: e5853074 str r3, [r5, #116] ; 0x74
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
3000386c: e59530a8 ldr r3, [r5, #168] ; 0xa8 30003870: e3530000 cmp r3, #0
30003874: 0affff90 beq 300036bc <rtems_termios_ioctl+0x68>
(*tty->device.setAttributes)(tty->minor, &tty->termios);
30003878: e5950010 ldr r0, [r5, #16] 3000387c: e1a01007 mov r1, r7 30003880: e1a0e00f mov lr, pc 30003884: e12fff13 bx r3 30003888: eaffff8b b 300036bc <rtems_termios_ioctl+0x68>
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
3000388c: e5952060 ldr r2, [r5, #96] ; 0x60 <== NOT EXECUTED 30003890: e595305c ldr r3, [r5, #92] ; 0x5c <== NOT EXECUTED
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
30003894: e5950020 ldr r0, [r5, #32] <== NOT EXECUTED
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
30003898: e0523003 subs r3, r2, r3 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
3000389c: 45952064 ldrmi r2, [r5, #100] ; 0x64 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
300038a0: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
300038a4: 40833002 addmi r3, r3, r2 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
300038a8: e5952024 ldr r2, [r5, #36] ; 0x24 <== NOT EXECUTED 300038ac: e0622000 rsb r2, r2, r0 <== NOT EXECUTED 300038b0: e0823003 add r3, r2, r3 <== NOT EXECUTED 300038b4: e5813000 str r3, [r1] <== NOT EXECUTED
}
break;
300038b8: eaffff7f b 300036bc <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) {
300038bc: e3530001 cmp r3, #1
300038c0: 1affff88 bne 300036e8 <rtems_termios_ioctl+0x94>
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
300038c4: e5947008 ldr r7, [r4, #8]
300038c8: e285c030 add ip, r5, #48 ; 0x30
300038cc: e1a0e007 mov lr, r7
300038d0: e8bc000f ldm ip!, {r0, r1, r2, r3}
300038d4: e8ae000f stmia lr!, {r0, r1, r2, r3}
300038d8: e8bc000f ldm ip!, {r0, r1, r2, r3}
300038dc: e8ae000f stmia lr!, {r0, r1, r2, r3}
300038e0: e59c3000 ldr r3, [ip]
300038e4: e58e3000 str r3, [lr]
break;
300038e8: eaffff73 b 300036bc <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) {
300038ec: e59f212c ldr r2, [pc, #300] ; 30003a20 <rtems_termios_ioctl+0x3cc> 300038f0: e1530002 cmp r3, r2
300038f4: 0a000019 beq 30003960 <rtems_termios_ioctl+0x30c>
300038f8: e2822105 add r2, r2, #1073741825 ; 0x40000001 300038fc: e1530002 cmp r3, r2
30003900: 1affff78 bne 300036e8 <rtems_termios_ioctl+0x94>
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
30003904: e59f7110 ldr r7, [pc, #272] ; 30003a1c <rtems_termios_ioctl+0x3c8> 30003908: e59530cc ldr r3, [r5, #204] ; 0xcc 3000390c: e0873283 add r3, r7, r3, lsl #5 30003910: e5933004 ldr r3, [r3, #4] 30003914: e3530000 cmp r3, #0
30003918: 0a000003 beq 3000392c <rtems_termios_ioctl+0x2d8>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
3000391c: e1a00005 mov r0, r5 30003920: e1a0e00f mov lr, pc 30003924: e12fff13 bx r3 30003928: e1a06000 mov r6, r0
}
tty->t_line=*(int*)(args->buffer);
3000392c: e5943008 ldr r3, [r4, #8] 30003930: e5932000 ldr r2, [r3]
tty->t_sc = NULL; /* ensure that no more valid data */
30003934: e3a03000 mov r3, #0 30003938: e58530d0 str r3, [r5, #208] ; 0xd0
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
3000393c: 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);
30003940: 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) {
30003944: e3530000 cmp r3, #0
30003948: 0affff5b beq 300036bc <rtems_termios_ioctl+0x68>
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
3000394c: e1a00005 mov r0, r5 30003950: e1a0e00f mov lr, pc 30003954: e12fff13 bx r3 30003958: e1a06000 mov r6, r0 3000395c: eaffff56 b 300036bc <rtems_termios_ioctl+0x68>
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
30003960: e5943008 ldr r3, [r4, #8] 30003964: e59520cc ldr r2, [r5, #204] ; 0xcc 30003968: e5832000 str r2, [r3]
break;
3000396c: eaffff52 b 300036bc <rtems_termios_ioctl+0x68>
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
30003970: e897000c ldm r7, {r2, r3}
30003974: e58520d4 str r2, [r5, #212] ; 0xd4
30003978: e58530d8 str r3, [r5, #216] ; 0xd8
break;
3000397c: eaffff4e b 300036bc <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] *
30003980: e5d5a046 ldrb sl, [r5, #70] ; 0x46
rtems_clock_get_ticks_per_second() / 10;
30003984: eb000597 bl 30004fe8 <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] *
30003988: e000009a mul r0, sl, r0
rtems_clock_get_ticks_per_second() / 10;
3000398c: e59f3090 ldr r3, [pc, #144] ; 30003a24 <rtems_termios_ioctl+0x3d0>
if (tty->termios.c_cc[VTIME]) {
30003990: 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;
30003994: e0831390 umull r1, r3, r0, r3
if (tty->termios.c_cc[VTIME]) {
30003998: e3520000 cmp r2, #0
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;
3000399c: e1a031a3 lsr r3, r3, #3
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] *
300039a0: e5853054 str r3, [r5, #84] ; 0x54
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
300039a4: 0a00000b beq 300039d8 <rtems_termios_ioctl+0x384>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
300039a8: e5d52047 ldrb r2, [r5, #71] ; 0x47
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;
300039ac: e585806c str r8, [r5, #108] ; 0x6c
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
300039b0: e3520000 cmp r2, #0 300039b4: 01a02003 moveq r2, r3 300039b8: 13a02000 movne r2, #0
} 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;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
300039bc: e5853070 str r3, [r5, #112] ; 0x70
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
300039c0: e5852074 str r2, [r5, #116] ; 0x74 300039c4: eaffffa8 b 3000386c <rtems_termios_ioctl+0x218>
/*
* 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;
300039c8: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 300039cc: e3833c01 orr r3, r3, #256 ; 0x100 <== NOT EXECUTED 300039d0: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 300039d4: eaffff94 b 3000382c <rtems_termios_ioctl+0x1d8> <== 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]) {
300039d8: e5d53047 ldrb r3, [r5, #71] ; 0x47 300039dc: e3530000 cmp r3, #0
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
300039e0: 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;
300039e4: 1585206c strne r2, [r5, #108] ; 0x6c
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
300039e8: 15852070 strne r2, [r5, #112] ; 0x70
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
300039ec: 15852074 strne r2, [r5, #116] ; 0x74
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
300039f0: 0585306c streq r3, [r5, #108] ; 0x6c 300039f4: eaffff9c b 3000386c <rtems_termios_ioctl+0x218>
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);
300039f8: 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)(
300039fc: e595107c ldr r1, [r5, #124] ; 0x7c <== NOT EXECUTED 30003a00: e5950010 ldr r0, [r5, #16] <== NOT EXECUTED 30003a04: e0811003 add r1, r1, r3 <== NOT EXECUTED 30003a08: e3a02001 mov r2, #1 <== NOT EXECUTED 30003a0c: e1a0e00f mov lr, pc <== NOT EXECUTED 30003a10: e595f0a4 ldr pc, [r5, #164] ; 0xa4 <== NOT EXECUTED 30003a14: eaffff5e b 30003794 <rtems_termios_ioctl+0x140> <== NOT EXECUTED
30002fc8 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
30002fc8: 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(
30002fcc: e59f7468 ldr r7, [pc, #1128] ; 3000343c <rtems_termios_open+0x474>
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
30002fd0: e1a06001 mov r6, r1
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
30002fd4: e3a01000 mov r1, #0
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
30002fd8: e24dd018 sub sp, sp, #24 30002fdc: e1a05000 mov r5, r0 30002fe0: e1a08002 mov r8, r2
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
30002fe4: e5970000 ldr r0, [r7] 30002fe8: e1a02001 mov r2, r1
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
30002fec: e58d3010 str r3, [sp, #16]
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
30002ff0: eb0009a4 bl 30005688 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
30002ff4: e250a000 subs sl, r0, #0
30002ff8: 1a000021 bne 30003084 <rtems_termios_open+0xbc>
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
30002ffc: e59fb43c ldr fp, [pc, #1084] ; 30003440 <rtems_termios_open+0x478> 30003000: e59b9000 ldr r9, [fp] 30003004: e3590000 cmp r9, #0
30003008: 0a00002d beq 300030c4 <rtems_termios_open+0xfc>
3000300c: e1a04009 mov r4, r9 30003010: ea000002 b 30003020 <rtems_termios_open+0x58> 30003014: e5944000 ldr r4, [r4] 30003018: e3540000 cmp r4, #0
3000301c: 0a000028 beq 300030c4 <rtems_termios_open+0xfc>
if ((tty->major == major) && (tty->minor == minor))
30003020: e594300c ldr r3, [r4, #12] 30003024: e1530005 cmp r3, r5
30003028: 1afffff9 bne 30003014 <rtems_termios_open+0x4c>
3000302c: e5943010 ldr r3, [r4, #16] 30003030: e1530006 cmp r3, r6
30003034: 1afffff6 bne 30003014 <rtems_termios_open+0x4c>
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
if (!tty->refcount++) {
30003038: e5943008 ldr r3, [r4, #8]
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
3000303c: e5981000 ldr r1, [r8]
if (!tty->refcount++) {
30003040: e2832001 add r2, r3, #1 30003044: e3530000 cmp r3, #0
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
30003048: e5814034 str r4, [r1, #52] ; 0x34
if (!tty->refcount++) {
3000304c: e5842008 str r2, [r4, #8]
30003050: 1a000009 bne 3000307c <rtems_termios_open+0xb4>
if (tty->device.firstOpen)
30003054: e5943098 ldr r3, [r4, #152] ; 0x98 30003058: e3530000 cmp r3, #0
(*tty->device.firstOpen)(major, minor, arg);
3000305c: 11a00005 movne r0, r5 30003060: 11a01006 movne r1, r6 30003064: 11a02008 movne r2, r8 30003068: 11a0e00f movne lr, pc 3000306c: 112fff13 bxne r3
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
30003070: e59430b4 ldr r3, [r4, #180] ; 0xb4 30003074: e3530002 cmp r3, #2
30003078: 0a000004 beq 30003090 <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);
3000307c: e5970000 ldr r0, [r7] 30003080: eb0009c9 bl 300057ac <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
30003084: e1a0000a mov r0, sl
30003088: e28dd018 add sp, sp, #24
3000308c: 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(
30003090: e59400c4 ldr r0, [r4, #196] ; 0xc4 30003094: e59f13a8 ldr r1, [pc, #936] ; 30003444 <rtems_termios_open+0x47c> 30003098: e1a02004 mov r2, r4 3000309c: eb000a96 bl 30005afc <rtems_task_start>
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
300030a0: e3500000 cmp r0, #0
300030a4: 1a0000ca bne 300033d4 <rtems_termios_open+0x40c>
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
300030a8: e59400c8 ldr r0, [r4, #200] ; 0xc8 300030ac: e59f1394 ldr r1, [pc, #916] ; 30003448 <rtems_termios_open+0x480> 300030b0: e1a02004 mov r2, r4 300030b4: eb000a90 bl 30005afc <rtems_task_start>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
300030b8: e3500000 cmp r0, #0
300030bc: 0affffee beq 3000307c <rtems_termios_open+0xb4>
300030c0: ea0000c3 b 300033d4 <rtems_termios_open+0x40c> <== NOT EXECUTED
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
300030c4: e3a00001 mov r0, #1 300030c8: e3a010e8 mov r1, #232 ; 0xe8 300030cc: ebfffb60 bl 30001e54 <calloc>
if (tty == NULL) {
300030d0: e3500000 cmp r0, #0
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
300030d4: e58d0014 str r0, [sp, #20] 300030d8: e1a04000 mov r4, r0
if (tty == NULL) {
300030dc: 0a0000a8 beq 30003384 <rtems_termios_open+0x3bc>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
300030e0: e59f0364 ldr r0, [pc, #868] ; 3000344c <rtems_termios_open+0x484> 300030e4: e59d1014 ldr r1, [sp, #20] 300030e8: e5903000 ldr r3, [r0] 300030ec: e5813064 str r3, [r1, #100] ; 0x64
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
300030f0: e5910064 ldr r0, [r1, #100] ; 0x64 300030f4: ebfffc9d bl 30002370 <malloc> 300030f8: e59d2014 ldr r2, [sp, #20]
if (tty->rawInBuf.theBuf == NULL) {
300030fc: e3500000 cmp r0, #0
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
30003100: e1a03000 mov r3, r0 30003104: e5820058 str r0, [r2, #88] ; 0x58
if (tty->rawInBuf.theBuf == NULL) {
30003108: 0a0000a1 beq 30003394 <rtems_termios_open+0x3cc>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
3000310c: e59fe338 ldr lr, [pc, #824] ; 3000344c <rtems_termios_open+0x484> 30003110: e59d0014 ldr r0, [sp, #20] 30003114: e59e2004 ldr r2, [lr, #4] 30003118: e5802088 str r2, [r0, #136] ; 0x88
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
3000311c: e5900088 ldr r0, [r0, #136] ; 0x88 30003120: e58d3008 str r3, [sp, #8] 30003124: ebfffc91 bl 30002370 <malloc> 30003128: e59de014 ldr lr, [sp, #20]
if (tty->rawOutBuf.theBuf == NULL) {
3000312c: e3500000 cmp r0, #0
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
30003130: e1a02000 mov r2, r0 30003134: e58e007c str r0, [lr, #124] ; 0x7c
if (tty->rawOutBuf.theBuf == NULL) {
30003138: e59d3008 ldr r3, [sp, #8]
3000313c: 0a00008c beq 30003374 <rtems_termios_open+0x3ac>
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
30003140: e59f1304 ldr r1, [pc, #772] ; 3000344c <rtems_termios_open+0x484> 30003144: e5910008 ldr r0, [r1, #8] 30003148: e58d200c str r2, [sp, #12] 3000314c: e58d3008 str r3, [sp, #8] 30003150: ebfffc86 bl 30002370 <malloc> 30003154: e59de014 ldr lr, [sp, #20]
if (tty->cbuf == NULL) {
30003158: e3500000 cmp r0, #0
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
3000315c: e58e001c str r0, [lr, #28]
if (tty->cbuf == NULL) {
30003160: e59d200c ldr r2, [sp, #12]
30003164: 0a00007f beq 30003368 <rtems_termios_open+0x3a0>
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
30003168: e59d0014 ldr r0, [sp, #20] 3000316c: e3a03000 mov r3, #0
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
30003170: e5803004 str r3, [r0, #4]
if (rtems_termios_ttyHead != NULL)
30003174: e1590003 cmp r9, r3
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
30003178: e58030d4 str r3, [r0, #212] ; 0xd4
tty->tty_snd.sw_arg = NULL;
3000317c: e58030d8 str r3, [r0, #216] ; 0xd8
tty->tty_rcv.sw_pfn = NULL;
30003180: e58030dc str r3, [r0, #220] ; 0xdc
tty->tty_rcv.sw_arg = NULL;
30003184: e58030e0 str r3, [r0, #224] ; 0xe0
tty->tty_rcvwakeup = 0;
30003188: e58030e4 str r3, [r0, #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)
3000318c: e59f32bc ldr r3, [pc, #700] ; 30003450 <rtems_termios_open+0x488>
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
30003190: 15890004 strne r0, [r9, #4]
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
30003194: 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;
30003198: e59d1014 ldr r1, [sp, #20]
if (rtems_termios_ttyTail == NULL)
3000319c: e3520000 cmp r2, #0
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
300031a0: e59f22a4 ldr r2, [pc, #676] ; 3000344c <rtems_termios_open+0x484>
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
300031a4: 05831000 streq r1, [r3]
tty->tty_rcvwakeup = 0;
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
300031a8: e5809000 str r9, [r0]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
300031ac: e5d2300c ldrb r3, [r2, #12]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
300031b0: e59de014 ldr lr, [sp, #20] 300031b4: e59f0298 ldr r0, [pc, #664] ; 30003454 <rtems_termios_open+0x48c>
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
300031b8: e58b1000 str r1, [fp]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
300031bc: e28ec014 add ip, lr, #20 300031c0: e1830000 orr r0, r3, r0
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
300031c4: e58e6010 str r6, [lr, #16]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
300031c8: e3a03000 mov r3, #0
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
tty->major = major;
300031cc: e58e500c str r5, [lr, #12]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
300031d0: e3a01001 mov r1, #1 300031d4: e3a02054 mov r2, #84 ; 0x54 300031d8: e58dc000 str ip, [sp] 300031dc: eb00088f bl 30005420 <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)
300031e0: e2503000 subs r3, r0, #0
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
300031e4: e59f9260 ldr r9, [pc, #608] ; 3000344c <rtems_termios_open+0x484>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
300031e8: 1a000079 bne 300033d4 <rtems_termios_open+0x40c>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'o', c),
300031ec: e5d9200c ldrb r2, [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 (
300031f0: e59d1014 ldr r1, [sp, #20] 300031f4: e59f025c ldr r0, [pc, #604] ; 30003458 <rtems_termios_open+0x490> 300031f8: e281c018 add ip, r1, #24 300031fc: e1820000 orr r0, r2, r0 30003200: e3a01001 mov r1, #1 30003204: e3a02054 mov r2, #84 ; 0x54 30003208: e58dc000 str ip, [sp] 3000320c: eb000883 bl 30005420 <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)
30003210: e2501000 subs r1, r0, #0
30003214: 1a00006e bne 300033d4 <rtems_termios_open+0x40c>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'x', c),
30003218: e5d9300c ldrb r3, [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 (
3000321c: e59d2014 ldr r2, [sp, #20] 30003220: e59f0234 ldr r0, [pc, #564] ; 3000345c <rtems_termios_open+0x494> 30003224: e282c08c add ip, r2, #140 ; 0x8c 30003228: e1830000 orr r0, r3, r0 3000322c: e3a02020 mov r2, #32 30003230: e1a03001 mov r3, r1 30003234: e58dc000 str ip, [sp] 30003238: eb000878 bl 30005420 <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)
3000323c: e250b000 subs fp, r0, #0
30003240: 1a000063 bne 300033d4 <rtems_termios_open+0x40c>
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
30003244: e59d3014 ldr r3, [sp, #20]
30003248: e59dc010 ldr ip, [sp, #16]
3000324c: e283e098 add lr, r3, #152 ; 0x98
30003250: e8bc000f ldm ip!, {r0, r1, r2, r3}
30003254: e8ae000f stmia lr!, {r0, r1, r2, r3}
30003258: e89c000f ldm ip, {r0, r1, r2, r3}
3000325c: e88e000f stm lr, {r0, r1, r2, r3}
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
30003260: e59de014 ldr lr, [sp, #20] 30003264: e59e30b4 ldr r3, [lr, #180] ; 0xb4
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;
30003268: e58eb094 str fp, [lr, #148] ; 0x94
tty->device = *callbacks;
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
3000326c: e3530002 cmp r3, #2
30003270: 0a000058 beq 300033d8 <rtems_termios_open+0x410>
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
30003274: e59d2014 ldr r2, [sp, #20] 30003278: e59230a0 ldr r3, [r2, #160] ; 0xa0 3000327c: e3530000 cmp r3, #0
30003280: 0a000046 beq 300033a0 <rtems_termios_open+0x3d8>
30003284: e59230b4 ldr r3, [r2, #180] ; 0xb4 30003288: e3530002 cmp r3, #2
3000328c: 0a000043 beq 300033a0 <rtems_termios_open+0x3d8>
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;
30003290: e59de014 ldr lr, [sp, #20]
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';
30003294: 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;
30003298: e58e30b8 str r3, [lr, #184] ; 0xb8
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
3000329c: e59f01a8 ldr r0, [pc, #424] ; 3000344c <rtems_termios_open+0x484>
/* 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;
300032a0: e59ec064 ldr ip, [lr, #100] ; 0x64
tty->highwater = tty->rawInBuf.Size * 3/4;
300032a4: e59e1064 ldr r1, [lr, #100] ; 0x64
/*
* Bump name characer
*/
if (c++ == 'z')
300032a8: e5d0200c ldrb r2, [r0, #12]
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;
300032ac: e0811081 add r1, r1, r1, lsl #1
/*
* Bump name characer
*/
if (c++ == 'z')
300032b0: e352007a cmp r2, #122 ; 0x7a
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;
300032b4: e1a00121 lsr r0, r1, #2
/*
* Bump name characer
*/
if (c++ == 'z')
300032b8: e2821001 add r1, r2, #1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
300032bc: e59f219c ldr r2, [pc, #412] ; 30003460 <rtems_termios_open+0x498>
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';
300032c0: e5ce304c strb r3, [lr, #76] ; 0x4c
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
300032c4: e58e2030 str r2, [lr, #48] ; 0x30
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
300032c8: e59f2194 ldr r2, [pc, #404] ; 30003464 <rtems_termios_open+0x49c>
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';
tty->termios.c_cc[VEOL2] = '\000';
300032cc: e5ce3051 strb r3, [lr, #81] ; 0x51
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
300032d0: e58e2034 str r2, [lr, #52] ; 0x34
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
300032d4: e59f218c ldr r2, [pc, #396] ; 30003468 <rtems_termios_open+0x4a0>
tty->termios.c_cc[VERASE] = '\177';
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';
300032d8: e3a03011 mov r3, #17
/*
* 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;
300032dc: e58e2038 str r2, [lr, #56] ; 0x38
tty->termios.c_lflag =
300032e0: e59f2184 ldr r2, [pc, #388] ; 3000346c <rtems_termios_open+0x4a4>
tty->termios.c_cc[VERASE] = '\177';
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';
300032e4: e5ce3049 strb r3, [lr, #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 =
300032e8: e58e203c str r2, [lr, #60] ; 0x3c
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';
300032ec: e3a03013 mov r3, #19
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';
300032f0: e3a02003 mov r2, #3 300032f4: e5ce2041 strb r2, [lr, #65] ; 0x41
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';
300032f8: e5ce304a strb r3, [lr, #74] ; 0x4a
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';
300032fc: e3a0201c mov r2, #28
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';
30003300: e3a0301a mov r3, #26
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';
30003304: e5ce2042 strb r2, [lr, #66] ; 0x42
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';
30003308: e5ce304b strb r3, [lr, #75] ; 0x4b
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';
3000330c: e3a0207f mov r2, #127 ; 0x7f
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';
30003310: e3a03012 mov r3, #18
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';
30003314: e5ce2043 strb r2, [lr, #67] ; 0x43
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';
30003318: e5ce304d strb r3, [lr, #77] ; 0x4d
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';
3000331c: e3a02015 mov r2, #21
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';
30003320: e3a0300f mov r3, #15
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';
30003324: e5ce2044 strb r2, [lr, #68] ; 0x44
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';
30003328: e5ce304e strb r3, [lr, #78] ; 0x4e
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';
3000332c: e3a02004 mov r2, #4
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';
30003330: e3a03017 mov r3, #23
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';
30003334: e5ce2045 strb r2, [lr, #69] ; 0x45
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';
30003338: e5ce304f strb r3, [lr, #79] ; 0x4f
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
3000333c: e59f2108 ldr r2, [pc, #264] ; 3000344c <rtems_termios_open+0x484>
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';
30003340: e3a03016 mov r3, #22 30003344: e5ce3050 strb r3, [lr, #80] ; 0x50
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
30003348: 059f30fc ldreq r3, [pc, #252] ; 3000344c <rtems_termios_open+0x484>
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
3000334c: e5c2100c strb r1, [r2, #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;
30003350: e1a0c0ac lsr ip, ip, #1
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
30003354: 03a02061 moveq r2, #97 ; 0x61
/* 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;
30003358: e58ec0bc str ip, [lr, #188] ; 0xbc
tty->highwater = tty->rawInBuf.Size * 3/4;
3000335c: e58e00c0 str r0, [lr, #192] ; 0xc0
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
30003360: 05c3200c strbeq r2, [r3, #12] 30003364: eaffff33 b 30003038 <rtems_termios_open+0x70>
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
30003368: e1a00002 mov r0, r2 <== NOT EXECUTED 3000336c: ebfffb25 bl 30002008 <free> <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
30003370: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
30003374: e1a00003 mov r0, r3 30003378: ebfffb22 bl 30002008 <free>
free(tty);
3000337c: e59d0014 ldr r0, [sp, #20] 30003380: ebfffb20 bl 30002008 <free>
rtems_semaphore_release (rtems_termios_ttyMutex);
30003384: e5970000 ldr r0, [r7] 30003388: eb000907 bl 300057ac <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
3000338c: e3a0a01a mov sl, #26 30003390: eaffff3b b 30003084 <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);
30003394: e1a00002 mov r0, r2 30003398: ebfffb1a bl 30002008 <free> 3000339c: eafffff8 b 30003384 <rtems_termios_open+0x3bc>
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'r', c),
300033a0: e59fe0a4 ldr lr, [pc, #164] ; 3000344c <rtems_termios_open+0x484>
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
300033a4: e59d2014 ldr r2, [sp, #20]
rtems_build_name ('T', 'R', 'r', c),
300033a8: e5de300c ldrb r3, [lr, #12]
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
300033ac: e59f00bc ldr r0, [pc, #188] ; 30003470 <rtems_termios_open+0x4a8> 300033b0: e3a01000 mov r1, #0 300033b4: e282c068 add ip, r2, #104 ; 0x68 300033b8: e1830000 orr r0, r3, r0 300033bc: e3a02024 mov r2, #36 ; 0x24 300033c0: e1a03001 mov r3, r1 300033c4: e58dc000 str ip, [sp] 300033c8: eb000814 bl 30005420 <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)
300033cc: e3500000 cmp r0, #0
300033d0: 0affffae beq 30003290 <rtems_termios_open+0x2c8>
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);
300033d4: eb000a54 bl 30005d2c <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),
300033d8: e5d9300c ldrb r3, [r9, #12]
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
300033dc: e59f0090 ldr r0, [pc, #144] ; 30003474 <rtems_termios_open+0x4ac>
300033e0: e28ec0c8 add ip, lr, #200 ; 0xc8
300033e4: e1830000 orr r0, r3, r0
300033e8: e3a0100a mov r1, #10
300033ec: e3a02b01 mov r2, #1024 ; 0x400
300033f0: e3a03c05 mov r3, #1280 ; 0x500
300033f4: e88d1800 stm sp, {fp, ip}
300033f8: eb000915 bl 30005854 <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)
300033fc: e250e000 subs lr, r0, #0
30003400: 1afffff3 bne 300033d4 <rtems_termios_open+0x40c>
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
rtems_build_name ('R', 'x', 'T', c),
30003404: e5d9300c ldrb r3, [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 (
30003408: e59d1014 ldr r1, [sp, #20] 3000340c: e59f0064 ldr r0, [pc, #100] ; 30003478 <rtems_termios_open+0x4b0> 30003410: e281c0c4 add ip, r1, #196 ; 0xc4 30003414: e1830000 orr r0, r3, r0 30003418: e3a01009 mov r1, #9 3000341c: e3a02b01 mov r2, #1024 ; 0x400 30003420: e3a03c05 mov r3, #1280 ; 0x500 30003424: e58de000 str lr, [sp] 30003428: e58dc004 str ip, [sp, #4] 3000342c: eb000908 bl 30005854 <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)
30003430: e3500000 cmp r0, #0
30003434: 0affff8e beq 30003274 <rtems_termios_open+0x2ac>
30003438: eaffffe5 b 300033d4 <rtems_termios_open+0x40c> <== NOT EXECUTED
30003a28 <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) {
30003a28: e59230b4 ldr r3, [r2, #180] ; 0xb4
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
30003a2c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
30003a30: e3530000 cmp r3, #0
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
30003a34: e1a04002 mov r4, r2 30003a38: e1a09000 mov r9, r0 30003a3c: e1a0a001 mov sl, r1
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
30003a40: 0a000037 beq 30003b24 <rtems_termios_puts+0xfc>
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
30003a44: e3510000 cmp r1, #0
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
30003a48: e5928080 ldr r8, [r2, #128] ; 0x80
while (len) {
30003a4c: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
30003a50: e3a07002 mov r7, #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;
30003a54: e3a0b001 mov fp, #1
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
30003a58: e5941088 ldr r1, [r4, #136] ; 0x88 30003a5c: e2880001 add r0, r8, #1 30003a60: eb003649 bl 3001138c <__umodsi3> 30003a64: e1a08000 mov r8, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30003a68: e10f5000 mrs r5, CPSR 30003a6c: e3853080 orr r3, r5, #128 ; 0x80 30003a70: e129f003 msr CPSR_fc, r3
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
30003a74: e5946084 ldr r6, [r4, #132] ; 0x84 30003a78: e1560000 cmp r6, r0
30003a7c: 1a00000d bne 30003ab8 <rtems_termios_puts+0x90>
tty->rawOutBufState = rob_wait;
30003a80: e5847094 str r7, [r4, #148] ; 0x94
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
30003a84: e129f005 msr CPSR_fc, r5
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
30003a88: e3a01000 mov r1, #0 30003a8c: e594008c ldr r0, [r4, #140] ; 0x8c 30003a90: e1a02001 mov r2, r1 30003a94: eb0006fb bl 30005688 <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
30003a98: e3500000 cmp r0, #0
30003a9c: 1a000026 bne 30003b3c <rtems_termios_puts+0x114>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30003aa0: e10f5000 mrs r5, CPSR 30003aa4: e3853080 orr r3, r5, #128 ; 0x80 30003aa8: e129f003 msr CPSR_fc, r3
* 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) {
30003aac: e5943084 ldr r3, [r4, #132] ; 0x84 30003ab0: e1530006 cmp r3, r6
30003ab4: 0afffff1 beq 30003a80 <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++;
30003ab8: e5943080 ldr r3, [r4, #128] ; 0x80 30003abc: e4d91001 ldrb r1, [r9], #1 30003ac0: e594207c ldr r2, [r4, #124] ; 0x7c 30003ac4: e7c21003 strb r1, [r2, r3]
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
30003ac8: e5943094 ldr r3, [r4, #148] ; 0x94
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
30003acc: e5848080 str r8, [r4, #128] ; 0x80
if (tty->rawOutBufState == rob_idle) {
30003ad0: e3530000 cmp r3, #0
30003ad4: 1a000006 bne 30003af4 <rtems_termios_puts+0xcc>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
30003ad8: e59430b8 ldr r3, [r4, #184] ; 0xb8 30003adc: e3130010 tst r3, #16
30003ae0: 0a000007 beq 30003b04 <rtems_termios_puts+0xdc>
(*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;
30003ae4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30003ae8: e3833020 orr r3, r3, #32 <== NOT EXECUTED 30003aec: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
30003af0: e584b094 str fp, [r4, #148] ; 0x94
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
30003af4: 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) {
30003af8: e25aa001 subs sl, sl, #1
30003afc: 1affffd5 bne 30003a58 <rtems_termios_puts+0x30>
30003b00: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, 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);
30003b04: 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,
30003b08: e594107c ldr r1, [r4, #124] ; 0x7c 30003b0c: e5940010 ldr r0, [r4, #16] 30003b10: e0811003 add r1, r1, r3 30003b14: e3a02001 mov r2, #1 30003b18: e1a0e00f mov lr, pc 30003b1c: e594f0a4 ldr pc, [r4, #164] ; 0xa4 30003b20: eafffff2 b 30003af0 <rtems_termios_puts+0xc8>
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);
30003b24: e5920010 ldr r0, [r2, #16] 30003b28: e1a01009 mov r1, r9 30003b2c: e1a0200a mov r2, sl 30003b30: e1a0e00f mov lr, pc 30003b34: e594f0a4 ldr pc, [r4, #164] ; 0xa4
return;
30003b38: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, 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);
30003b3c: eb00087a bl 30005d2c <rtems_fatal_error_occurred> <== NOT EXECUTED
30004258 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
30004258: 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;
3000425c: e5903000 ldr r3, [r0]
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30004260: e3a01000 mov r1, #0
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
30004264: e5934034 ldr r4, [r3, #52] ; 0x34
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
30004268: e1a09000 mov r9, r0 3000426c: 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);
30004270: e1a02001 mov r2, r1 30004274: e5940014 ldr r0, [r4, #20]
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;
30004278: e5998010 ldr r8, [r9, #16]
char *buffer = args->buffer;
3000427c: e599a00c ldr sl, [r9, #12]
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30004280: eb000500 bl 30005688 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
30004284: e3500000 cmp r0, #0 30004288: e58d0000 str r0, [sp]
3000428c: 1a00000e bne 300042cc <rtems_termios_read+0x74>
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
30004290: e59420cc ldr r2, [r4, #204] ; 0xcc 30004294: e59f3364 ldr r3, [pc, #868] ; 30004600 <rtems_termios_read+0x3a8> 30004298: e0833282 add r3, r3, r2, lsl #5 3000429c: e5933008 ldr r3, [r3, #8] 300042a0: e3530000 cmp r3, #0
300042a4: 0a00000b beq 300042d8 <rtems_termios_read+0x80>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
300042a8: e1a00004 mov r0, r4 300042ac: e1a01009 mov r1, r9 300042b0: e1a0e00f mov lr, pc 300042b4: e12fff13 bx r3
tty->tty_rcvwakeup = 0;
300042b8: 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);
300042bc: e58d0000 str r0, [sp]
tty->tty_rcvwakeup = 0;
300042c0: e58430e4 str r3, [r4, #228] ; 0xe4
rtems_semaphore_release (tty->isem);
300042c4: e5940014 ldr r0, [r4, #20] 300042c8: eb000537 bl 300057ac <rtems_semaphore_release>
} args->bytes_moved = args->count - count; tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); return sc; }
300042cc: e59d0000 ldr r0, [sp]
300042d0: e28dd008 add sp, sp, #8
300042d4: 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) {
300042d8: e5942024 ldr r2, [r4, #36] ; 0x24 300042dc: e5943020 ldr r3, [r4, #32] 300042e0: e1520003 cmp r2, r3
300042e4: 0a000018 beq 3000434c <rtems_termios_read+0xf4>
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
300042e8: e3580000 cmp r8, #0
300042ec: 0a00000e beq 3000432c <rtems_termios_read+0xd4>
300042f0: e5943024 ldr r3, [r4, #36] ; 0x24 300042f4: e5942020 ldr r2, [r4, #32] 300042f8: e1530002 cmp r3, r2
300042fc: ba000003 blt 30004310 <rtems_termios_read+0xb8>
30004300: ea000009 b 3000432c <rtems_termios_read+0xd4> <== NOT EXECUTED
30004304: e5942020 ldr r2, [r4, #32] 30004308: e1520003 cmp r2, r3
3000430c: da000006 ble 3000432c <rtems_termios_read+0xd4>
*buffer++ = tty->cbuf[tty->cindex++];
30004310: e594201c ldr r2, [r4, #28]
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
30004314: e2588001 subs r8, r8, #1
*buffer++ = tty->cbuf[tty->cindex++];
30004318: e7d22003 ldrb r2, [r2, r3] 3000431c: e2833001 add r3, r3, #1 30004320: e4ca2001 strb r2, [sl], #1 30004324: e5843024 str r3, [r4, #36] ; 0x24
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
30004328: 1afffff5 bne 30004304 <rtems_termios_read+0xac>
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
3000432c: e5993010 ldr r3, [r9, #16]
tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem);
30004330: e5940014 ldr r0, [r4, #20]
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
30004334: e0688003 rsb r8, r8, r3
tty->tty_rcvwakeup = 0;
30004338: e3a03000 mov r3, #0
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
3000433c: e5898018 str r8, [r9, #24]
tty->tty_rcvwakeup = 0;
30004340: e58430e4 str r3, [r4, #228] ; 0xe4
rtems_semaphore_release (tty->isem);
30004344: eb000518 bl 300057ac <rtems_semaphore_release>
return sc;
30004348: eaffffdf b 300042cc <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 &&
3000434c: e59430a0 ldr r3, [r4, #160] ; 0xa0
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
30004350: e59d1000 ldr r1, [sp]
tty->read_start_column = tty->column;
30004354: e5942028 ldr r2, [r4, #40] ; 0x28
if (tty->device.pollRead != NULL &&
30004358: e3530000 cmp r3, #0
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
3000435c: e5841020 str r1, [r4, #32] 30004360: e5841024 str r1, [r4, #36] ; 0x24
tty->read_start_column = tty->column;
30004364: e584202c str r2, [r4, #44] ; 0x2c
if (tty->device.pollRead != NULL &&
30004368: 0a000002 beq 30004378 <rtems_termios_read+0x120>
3000436c: e59420b4 ldr r2, [r4, #180] ; 0xb4 30004370: e3520000 cmp r2, #0
30004374: 0a000065 beq 30004510 <rtems_termios_read+0x2b8>
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)(
30004378: e2843049 add r3, r4, #73 ; 0x49
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
3000437c: 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))) {
30004380: e59f727c ldr r7, [pc, #636] ; 30004604 <rtems_termios_read+0x3ac>
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))
30004384: e59fb27c ldr fp, [pc, #636] ; 30004608 <rtems_termios_read+0x3b0>
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
rtems_status_code sc;
int wait = (int)1;
30004388: e3a05001 mov r5, #1
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)(
3000438c: e58d3004 str r3, [sp, #4]
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
30004390: e594205c ldr r2, [r4, #92] ; 0x5c 30004394: e5943060 ldr r3, [r4, #96] ; 0x60 30004398: e1520003 cmp r2, r3
3000439c: 0a000046 beq 300044bc <rtems_termios_read+0x264>
(tty->ccount < (CBUFSIZE-1))) {
300043a0: e5972008 ldr r2, [r7, #8]
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
300043a4: e5943020 ldr r3, [r4, #32]
(tty->ccount < (CBUFSIZE-1))) {
300043a8: e2422001 sub r2, r2, #1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
300043ac: e1520003 cmp r2, r3
300043b0: ca00000f bgt 300043f4 <rtems_termios_read+0x19c>
300043b4: ea000040 b 300044bc <rtems_termios_read+0x264> <== NOT EXECUTED
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
300043b8: e1a00006 mov r0, r6 300043bc: e1a01004 mov r1, r4 300043c0: ebffff59 bl 3000412c <siproc>
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
300043c4: e594205c ldr r2, [r4, #92] ; 0x5c 300043c8: e5943060 ldr r3, [r4, #96] ; 0x60
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
300043cc: e3500000 cmp r0, #0 300043d0: 13a05000 movne r5, #0
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
300043d4: e1520003 cmp r2, r3
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
300043d8: e5946070 ldr r6, [r4, #112] ; 0x70
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
300043dc: 0a000036 beq 300044bc <rtems_termios_read+0x264>
(tty->ccount < (CBUFSIZE-1))) {
300043e0: e5973008 ldr r3, [r7, #8]
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
300043e4: e5942020 ldr r2, [r4, #32]
(tty->ccount < (CBUFSIZE-1))) {
300043e8: e2433001 sub r3, r3, #1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
300043ec: e1520003 cmp r2, r3
300043f0: aa000031 bge 300044bc <rtems_termios_read+0x264>
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
300043f4: e594005c ldr r0, [r4, #92] ; 0x5c 300043f8: e5941064 ldr r1, [r4, #100] ; 0x64 300043fc: e2800001 add r0, r0, #1 30004400: eb0033e1 bl 3001138c <__umodsi3>
c = tty->rawInBuf.theBuf[newHead];
30004404: e5943058 ldr r3, [r4, #88] ; 0x58 30004408: e7d36000 ldrb r6, [r3, r0]
tty->rawInBuf.Head = newHead;
3000440c: e584005c str r0, [r4, #92] ; 0x5c
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
30004410: e5943060 ldr r3, [r4, #96] ; 0x60 30004414: e5942064 ldr r2, [r4, #100] ; 0x64
% tty->rawInBuf.Size)
30004418: e5941064 ldr r1, [r4, #100] ; 0x64
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)
3000441c: e0823003 add r3, r2, r3
% tty->rawInBuf.Size)
30004420: e0600003 rsb r0, r0, r3 30004424: eb0033d8 bl 3001138c <__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)
30004428: e59430bc ldr r3, [r4, #188] ; 0xbc 3000442c: e1500003 cmp r0, r3
30004430: 2a000012 bcs 30004480 <rtems_termios_read+0x228>
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
30004434: e59420b8 ldr r2, [r4, #184] ; 0xb8
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
30004438: e59f31c8 ldr r3, [pc, #456] ; 30004608 <rtems_termios_read+0x3b0>
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
3000443c: e3c22001 bic r2, r2, #1 30004440: e58420b8 str r2, [r4, #184] ; 0xb8
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
30004444: e59420b8 ldr r2, [r4, #184] ; 0xb8 30004448: e0023003 and r3, r2, r3 3000444c: e153000b cmp r3, fp
30004450: 0a000022 beq 300044e0 <rtems_termios_read+0x288>
&& ((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) {
30004454: e59430b8 ldr r3, [r4, #184] ; 0xb8 30004458: e3130c01 tst r3, #256 ; 0x100
3000445c: 0a000007 beq 30004480 <rtems_termios_read+0x228>
tty->flow_ctrl &= ~FL_IRTSOFF;
30004460: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
30004464: 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;
30004468: e3c22004 bic r2, r2, #4 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
3000446c: 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;
30004470: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
tty->device.startRemoteTx(tty->minor);
30004474: 15940010 ldrne r0, [r4, #16] <== NOT EXECUTED 30004478: 11a0e00f movne lr, pc <== NOT EXECUTED 3000447c: 112fff13 bxne r3 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
30004480: e594303c ldr r3, [r4, #60] ; 0x3c 30004484: e3130002 tst r3, #2
30004488: 1affffca bne 300043b8 <rtems_termios_read+0x160>
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
3000448c: e1a00006 mov r0, r6 <== NOT EXECUTED 30004490: e1a01004 mov r1, r4 <== NOT EXECUTED 30004494: ebffff24 bl 3000412c <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
30004498: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED 3000449c: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
300044a0: e5946070 ldr r6, [r4, #112] ; 0x70 <== NOT EXECUTED
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
300044a4: e1520003 cmp r2, r3 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
300044a8: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED 300044ac: 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;
300044b0: a3a05000 movge r5, #0 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
300044b4: e1520003 cmp r2, r3 <== NOT EXECUTED 300044b8: 1affffc8 bne 300043e0 <rtems_termios_read+0x188> <== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
300044bc: e3550000 cmp r5, #0
300044c0: 0affff88 beq 300042e8 <rtems_termios_read+0x90>
sc = rtems_semaphore_obtain(
300044c4: e5940068 ldr r0, [r4, #104] ; 0x68 300044c8: e594106c ldr r1, [r4, #108] ; 0x6c 300044cc: e1a02006 mov r2, r6 300044d0: eb00046c bl 30005688 <rtems_semaphore_obtain>
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
300044d4: e3500000 cmp r0, #0
300044d8: 0affffac beq 30004390 <rtems_termios_read+0x138>
300044dc: eaffff81 b 300042e8 <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)
300044e0: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED 300044e4: e3530000 cmp r3, #0 <== NOT EXECUTED 300044e8: 0a000002 beq 300044f8 <rtems_termios_read+0x2a0> <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
300044ec: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300044f0: e3130020 tst r3, #32 <== NOT EXECUTED 300044f4: 0affffd6 beq 30004454 <rtems_termios_read+0x1fc> <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
300044f8: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 300044fc: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 30004500: e3a02001 mov r2, #1 <== NOT EXECUTED 30004504: e1a0e00f mov lr, pc <== NOT EXECUTED 30004508: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED 3000450c: eaffffdb b 30004480 <rtems_termios_read+0x228> <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
30004510: e594203c ldr r2, [r4, #60] ; 0x3c 30004514: e3120002 tst r2, #2
30004518: 0a00000b beq 3000454c <rtems_termios_read+0x2f4>
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
3000451c: e5940010 ldr r0, [r4, #16] 30004520: e1a0e00f mov lr, pc 30004524: e12fff13 bx r3
if (n < 0) {
30004528: e3500000 cmp r0, #0
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
3000452c: e1a01004 mov r1, r4 30004530: e20000ff and r0, r0, #255 ; 0xff
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
30004534: ba00002d blt 300045f0 <rtems_termios_read+0x398>
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
30004538: ebfffefb bl 3000412c <siproc> 3000453c: e3500000 cmp r0, #0
30004540: 1affff68 bne 300042e8 <rtems_termios_read+0x90>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
30004544: e59430a0 ldr r3, [r4, #160] ; 0xa0 30004548: eafffff3 b 3000451c <rtems_termios_read+0x2c4>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
3000454c: eb0002ad bl 30005008 <rtems_clock_get_ticks_since_boot> 30004550: e1a05000 mov r5, r0
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
30004554: e5940010 ldr r0, [r4, #16] 30004558: e1a0e00f mov lr, pc 3000455c: e594f0a0 ldr pc, [r4, #160] ; 0xa0
if (n < 0) {
30004560: e3500000 cmp r0, #0
30004564: ba00000c blt 3000459c <rtems_termios_read+0x344>
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
30004568: e20000ff and r0, r0, #255 ; 0xff 3000456c: e1a01004 mov r1, r4 30004570: ebfffeed bl 3000412c <siproc>
if (tty->ccount >= tty->termios.c_cc[VMIN])
30004574: e5d43047 ldrb r3, [r4, #71] ; 0x47 30004578: e5942020 ldr r2, [r4, #32] 3000457c: e1520003 cmp r2, r3
30004580: aaffff58 bge 300042e8 <rtems_termios_read+0x90>
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
30004584: e3530000 cmp r3, #0
30004588: 0afffff1 beq 30004554 <rtems_termios_read+0x2fc>
3000458c: e5d43046 ldrb r3, [r4, #70] ; 0x46 30004590: e3530000 cmp r3, #0
30004594: 0affffee beq 30004554 <rtems_termios_read+0x2fc>
30004598: eaffffeb b 3000454c <rtems_termios_read+0x2f4>
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
3000459c: e5d43047 ldrb r3, [r4, #71] ; 0x47 300045a0: e3530000 cmp r3, #0
300045a4: 0a000008 beq 300045cc <rtems_termios_read+0x374>
if (tty->termios.c_cc[VTIME] && tty->ccount) {
300045a8: e5d43046 ldrb r3, [r4, #70] ; 0x46 300045ac: e3530000 cmp r3, #0
300045b0: 0a000002 beq 300045c0 <rtems_termios_read+0x368>
300045b4: e5943020 ldr r3, [r4, #32] 300045b8: e3530000 cmp r3, #0
300045bc: 1a000005 bne 300045d8 <rtems_termios_read+0x380>
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
300045c0: e3a00001 mov r0, #1 300045c4: eb000566 bl 30005b64 <rtems_task_wake_after> 300045c8: eaffffe1 b 30004554 <rtems_termios_read+0x2fc>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
300045cc: e5d43046 ldrb r3, [r4, #70] ; 0x46 <== NOT EXECUTED 300045d0: e3530000 cmp r3, #0 <== NOT EXECUTED 300045d4: 0affff43 beq 300042e8 <rtems_termios_read+0x90> <== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
300045d8: eb00028a bl 30005008 <rtems_clock_get_ticks_since_boot>
if ((now - then) > tty->vtimeTicks) {
300045dc: e5943054 ldr r3, [r4, #84] ; 0x54 300045e0: e0650000 rsb r0, r5, r0 300045e4: e1500003 cmp r0, r3
300045e8: 9afffff4 bls 300045c0 <rtems_termios_read+0x368>
300045ec: eaffff3d b 300042e8 <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);
300045f0: e3a00001 mov r0, #1 300045f4: eb00055a bl 30005b64 <rtems_task_wake_after>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
300045f8: e59430a0 ldr r3, [r4, #160] ; 0xa0 300045fc: eaffffc6 b 3000451c <rtems_termios_read+0x2c4>
30004994 <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))
30004994: e59020b8 ldr r2, [r0, #184] ; 0xb8 30004998: e59f31f4 ldr r3, [pc, #500] ; 30004b94 <rtems_termios_refill_transmitter+0x200>
* 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)
{
3000499c: e92d4070 push {r4, r5, r6, lr}
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
300049a0: e0023003 and r3, r2, r3 300049a4: e59f21ec ldr r2, [pc, #492] ; 30004b98 <rtems_termios_refill_transmitter+0x204>
* 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)
{
300049a8: 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))
300049ac: e1530002 cmp r3, r2
300049b0: 0a000048 beq 30004ad8 <rtems_termios_refill_transmitter+0x144>
tty->flow_ctrl |= FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
300049b4: e59030b8 ldr r3, [r0, #184] ; 0xb8 300049b8: e2033003 and r3, r3, #3 300049bc: e3530002 cmp r3, #2
300049c0: 0a000056 beq 30004b20 <rtems_termios_refill_transmitter+0x18c>
tty->flow_ctrl &= ~FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
300049c4: e5902080 ldr r2, [r0, #128] ; 0x80 300049c8: e5903084 ldr r3, [r0, #132] ; 0x84 300049cc: e1520003 cmp r2, r3
300049d0: 0a00002a beq 30004a80 <rtems_termios_refill_transmitter+0xec>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
300049d4: e10f3000 mrs r3, CPSR 300049d8: e3832080 orr r2, r3, #128 ; 0x80 300049dc: e129f002 msr CPSR_fc, r2
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
300049e0: e3a02000 mov r2, #0
}
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
300049e4: e5900090 ldr r0, [r0, #144] ; 0x90
tty->t_dqlen = 0;
300049e8: e5842090 str r2, [r4, #144] ; 0x90
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
300049ec: e129f003 msr CPSR_fc, r3
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
300049f0: e5943084 ldr r3, [r4, #132] ; 0x84 300049f4: e5941088 ldr r1, [r4, #136] ; 0x88 300049f8: e0800003 add r0, r0, r3 300049fc: eb003262 bl 3001138c <__umodsi3>
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
30004a00: e5943094 ldr r3, [r4, #148] ; 0x94
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
30004a04: e1a05000 mov r5, r0
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
30004a08: e3530002 cmp r3, #2
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
tty->rawOutBuf.Tail = newTail;
30004a0c: e5840084 str r0, [r4, #132] ; 0x84
if (tty->rawOutBufState == rob_wait) {
30004a10: 0a00002d beq 30004acc <rtems_termios_refill_transmitter+0x138>
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
if (newTail == tty->rawOutBuf.Head) {
30004a14: e5943080 ldr r3, [r4, #128] ; 0x80 30004a18: e1530005 cmp r3, r5
30004a1c: 0a00001f beq 30004aa0 <rtems_termios_refill_transmitter+0x10c>
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))
30004a20: e59430b8 ldr r3, [r4, #184] ; 0xb8 30004a24: e2033e21 and r3, r3, #528 ; 0x210 30004a28: e3530e21 cmp r3, #528 ; 0x210
30004a2c: 0a00004d beq 30004b68 <rtems_termios_refill_transmitter+0x1d4>
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
30004a30: e5943080 ldr r3, [r4, #128] ; 0x80
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
30004a34: e594107c ldr r1, [r4, #124] ; 0x7c
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
30004a38: e1550003 cmp r5, r3
nToSend = tty->rawOutBuf.Size - newTail;
30004a3c: 85946088 ldrhi r6, [r4, #136] ; 0x88
else
nToSend = tty->rawOutBuf.Head - newTail;
30004a40: 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)) {
30004a44: e59430b8 ldr r3, [r4, #184] ; 0xb8
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
30004a48: 80656006 rsbhi r6, r5, r6
else
nToSend = tty->rawOutBuf.Head - newTail;
30004a4c: 90656006 rsbls r6, r5, r6
/* 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)) {
30004a50: e3130c06 tst r3, #1536 ; 0x600 30004a54: 13a06001 movne r6, #1
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
30004a58: 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;
30004a5c: e1a02006 mov r2, r6
}
tty->rawOutBufState = rob_busy; /*apm*/
30004a60: e5843094 str r3, [r4, #148] ; 0x94
(*tty->device.write)(
30004a64: e5940010 ldr r0, [r4, #16] 30004a68: e0811005 add r1, r1, r5 30004a6c: e1a0e00f mov lr, pc 30004a70: e594f0a4 ldr pc, [r4, #164] ; 0xa4
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
30004a74: e5845084 str r5, [r4, #132] ; 0x84
} return nToSend; }
30004a78: e1a00006 mov r0, r6
30004a7c: e8bd8070 pop {r4, r5, r6, pc}
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
30004a80: e5903094 ldr r3, [r0, #148] ; 0x94 30004a84: e3530002 cmp r3, #2
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
30004a88: 13a06000 movne r6, #0
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
30004a8c: 1afffff9 bne 30004a78 <rtems_termios_refill_transmitter+0xe4>
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
30004a90: e590008c ldr r0, [r0, #140] ; 0x8c <== NOT EXECUTED 30004a94: eb000344 bl 300057ac <rtems_semaphore_release> <== NOT EXECUTED
}
return 0;
30004a98: e3a06000 mov r6, #0 <== NOT EXECUTED 30004a9c: eafffff5 b 30004a78 <rtems_termios_refill_transmitter+0xe4><== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
30004aa0: e59430d4 ldr r3, [r4, #212] ; 0xd4
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
30004aa4: e3a06000 mov r6, #0
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
30004aa8: e1530006 cmp r3, r6
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
30004aac: e5846094 str r6, [r4, #148] ; 0x94
nToSend = 0;
30004ab0: 01a06003 moveq r6, r3
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
30004ab4: 0affffee beq 30004a74 <rtems_termios_refill_transmitter+0xe0>
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
30004ab8: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 30004abc: e59410d8 ldr r1, [r4, #216] ; 0xd8 <== NOT EXECUTED 30004ac0: e1a0e00f mov lr, pc <== NOT EXECUTED 30004ac4: e12fff13 bx r3 <== NOT EXECUTED 30004ac8: eaffffe9 b 30004a74 <rtems_termios_refill_transmitter+0xe0><== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
30004acc: e594008c ldr r0, [r4, #140] ; 0x8c 30004ad0: eb000335 bl 300057ac <rtems_semaphore_release> 30004ad4: eaffffce b 30004a14 <rtems_termios_refill_transmitter+0x80>
/* 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);
30004ad8: e284104a add r1, r4, #74 ; 0x4a <== NOT EXECUTED 30004adc: e3a02001 mov r2, #1 <== NOT EXECUTED 30004ae0: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED 30004ae4: e1a0e00f mov lr, pc <== NOT EXECUTED 30004ae8: 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 (
30004aec: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30004af0: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30004af4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->t_dqlen--;
30004af8: e5941090 ldr r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
30004afc: 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--;
30004b00: e2411001 sub r1, r1, #1 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
30004b04: 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--;
30004b08: e5841090 str r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
30004b0c: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
30004b10: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
30004b14: e3a06001 mov r6, #1 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
30004b18: e1a00006 mov r0, r6 <== NOT EXECUTED
30004b1c: 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);
30004b20: e2841049 add r1, r4, #73 ; 0x49 <== NOT EXECUTED 30004b24: e3a02001 mov r2, #1 <== NOT EXECUTED 30004b28: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED 30004b2c: e1a0e00f mov lr, pc <== NOT EXECUTED 30004b30: 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 (
30004b34: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30004b38: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30004b3c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->t_dqlen--;
30004b40: e5941090 ldr r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
30004b44: 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--;
30004b48: e2411001 sub r1, r1, #1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
30004b4c: 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--;
30004b50: e5841090 str r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
30004b54: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
30004b58: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
30004b5c: e3a06001 mov r6, #1 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
30004b60: e1a00006 mov r0, r6 <== NOT EXECUTED
30004b64: 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 (
30004b68: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30004b6c: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30004b70: 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;
30004b74: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED 30004b78: e3822020 orr r2, r2, #32 <== NOT EXECUTED 30004b7c: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
30004b80: e3a02001 mov r2, #1 <== NOT EXECUTED 30004b84: e5842094 str r2, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
30004b88: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 0;
30004b8c: e3a06000 mov r6, #0 <== NOT EXECUTED 30004b90: eaffffb7 b 30004a74 <rtems_termios_refill_transmitter+0xe0><== NOT EXECUTED
30004908 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
30004908: e92d40f0 push {r4, r5, r6, r7, lr}
3000490c: e24dd008 sub sp, sp, #8
30004910: e1a04000 mov r4, r0
30004914: e28d7007 add r7, sp, #7
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
30004918: e3a06000 mov r6, #0 3000491c: ea000005 b 30004938 <rtems_termios_rxdaemon+0x30>
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
30004920: e5940010 ldr r0, [r4, #16] 30004924: e1a0e00f mov lr, pc 30004928: e594f0a0 ldr pc, [r4, #160] ; 0xa0
if (c != EOF) {
3000492c: e3700001 cmn r0, #1
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
30004930: e1a03000 mov r3, r0
if (c != EOF) {
30004934: 1a000010 bne 3000497c <rtems_termios_rxdaemon+0x74>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
30004938: e1a0300d mov r3, sp 3000493c: e3a01002 mov r1, #2 30004940: e3a02000 mov r2, #0 30004944: e3a00003 mov r0, #3 30004948: eb0001ce bl 30005088 <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) {
3000494c: e59d3000 ldr r3, [sp] 30004950: e3130001 tst r3, #1
30004954: 0afffff1 beq 30004920 <rtems_termios_rxdaemon+0x18>
tty->rxTaskId = 0;
30004958: e58460c4 str r6, [r4, #196] ; 0xc4 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
3000495c: e1a00006 mov r0, r6 <== NOT EXECUTED 30004960: eb00040a bl 30005990 <rtems_task_delete> <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
30004964: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30004968: e1a0e00f mov lr, pc <== NOT EXECUTED 3000496c: e594f0a0 ldr pc, [r4, #160] ; 0xa0 <== NOT EXECUTED
if (c != EOF) {
30004970: e3700001 cmn r0, #1 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
30004974: e1a03000 mov r3, r0 <== NOT EXECUTED
if (c != EOF) {
30004978: 0affffee beq 30004938 <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);
3000497c: e1a00004 mov r0, r4 30004980: e1a01007 mov r1, r7 30004984: e3a02001 mov r2, #1
c = tty->device.pollRead(tty->minor);
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
30004988: e5cd3007 strb r3, [sp, #7]
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
3000498c: ebffff21 bl 30004618 <rtems_termios_enqueue_raw_characters> 30004990: eaffffe8 b 30004938 <rtems_termios_rxdaemon+0x30>
30004b9c <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
30004b9c: e92d40f0 push {r4, r5, r6, r7, lr}
30004ba0: e59f6060 ldr r6, [pc, #96] ; 30004c08 <rtems_termios_txdaemon+0x6c>
30004ba4: e24dd004 sub sp, sp, #4
30004ba8: e1a04000 mov r4, r0
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
30004bac: e3a07000 mov r7, #0 30004bb0: ea000008 b 30004bd8 <rtems_termios_txdaemon+0x3c>
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
30004bb4: e59430cc ldr r3, [r4, #204] ; 0xcc
rtems_termios_linesw[tty->t_line].l_start(tty);
30004bb8: e1a00004 mov r0, r4
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
30004bbc: e0863283 add r3, r6, r3, lsl #5 30004bc0: e5933014 ldr r3, [r3, #20] 30004bc4: e3530000 cmp r3, #0
rtems_termios_linesw[tty->t_line].l_start(tty);
30004bc8: 11a0e00f movne lr, pc 30004bcc: 112fff13 bxne r3
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
30004bd0: e1a00004 mov r0, r4 30004bd4: ebffff6e bl 30004994 <rtems_termios_refill_transmitter>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
30004bd8: e1a0300d mov r3, sp 30004bdc: e3a01002 mov r1, #2 30004be0: e3a02000 mov r2, #0 30004be4: e3a00003 mov r0, #3 30004be8: eb000126 bl 30005088 <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) {
30004bec: e59d3000 ldr r3, [sp] 30004bf0: e3130001 tst r3, #1
30004bf4: 0affffee beq 30004bb4 <rtems_termios_txdaemon+0x18>
tty->txTaskId = 0;
30004bf8: e58470c8 str r7, [r4, #200] ; 0xc8 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
30004bfc: e1a00007 mov r0, r7 <== NOT EXECUTED 30004c00: eb000362 bl 30005990 <rtems_task_delete> <== NOT EXECUTED 30004c04: eaffffea b 30004bb4 <rtems_termios_txdaemon+0x18> <== NOT EXECUTED
30004188 <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;
30004188: e5903000 ldr r3, [r0]
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
3000418c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
30004190: e5934034 ldr r4, [r3, #52] ; 0x34
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30004194: e3a01000 mov r1, #0
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
30004198: 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);
3000419c: e1a02001 mov r2, r1 300041a0: e5940018 ldr r0, [r4, #24] 300041a4: eb000537 bl 30005688 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
300041a8: e2506000 subs r6, r0, #0
300041ac: 1a00000c bne 300041e4 <rtems_termios_write+0x5c>
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
300041b0: e59420cc ldr r2, [r4, #204] ; 0xcc 300041b4: e59f3098 ldr r3, [pc, #152] ; 30004254 <rtems_termios_write+0xcc> 300041b8: e0833282 add r3, r3, r2, lsl #5 300041bc: e593300c ldr r3, [r3, #12] 300041c0: e3530000 cmp r3, #0
300041c4: 0a000008 beq 300041ec <rtems_termios_write+0x64>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
300041c8: e1a00004 mov r0, r4 300041cc: e1a01005 mov r1, r5 300041d0: e1a0e00f mov lr, pc 300041d4: e12fff13 bx r3 300041d8: e1a06000 mov r6, r0
rtems_semaphore_release (tty->osem);
300041dc: e5940018 ldr r0, [r4, #24] 300041e0: eb000571 bl 300057ac <rtems_semaphore_release>
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
}
rtems_semaphore_release (tty->osem);
return sc;
}
300041e4: e1a00006 mov r0, r6
300041e8: 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) {
300041ec: e5943034 ldr r3, [r4, #52] ; 0x34 300041f0: e3130001 tst r3, #1
300041f4: 0a000011 beq 30004240 <rtems_termios_write+0xb8>
uint32_t count = args->count;
300041f8: e5958010 ldr r8, [r5, #16]
char *buffer = args->buffer;
300041fc: e595a00c ldr sl, [r5, #12]
while (count--)
30004200: e3580000 cmp r8, #0 30004204: 01a03006 moveq r3, r6
30004208: 0a000007 beq 3000422c <rtems_termios_write+0xa4>
3000420c: e1a07006 mov r7, r6
oproc (*buffer++, tty);
30004210: e7da0007 ldrb r0, [sl, r7] 30004214: e1a01004 mov r1, r4 30004218: e2877001 add r7, r7, #1 3000421c: ebfffe47 bl 30003b40 <oproc>
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
30004220: e1570008 cmp r7, r8
30004224: 1afffff9 bne 30004210 <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;
30004228: e5953010 ldr r3, [r5, #16] 3000422c: e5853018 str r3, [r5, #24]
} rtems_semaphore_release (tty->osem);
30004230: e5940018 ldr r0, [r4, #24] 30004234: eb00055c bl 300057ac <rtems_semaphore_release>
return sc; }
30004238: e1a00006 mov r0, r6
3000423c: 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);
30004240: e595000c ldr r0, [r5, #12] <== NOT EXECUTED 30004244: e5951010 ldr r1, [r5, #16] <== NOT EXECUTED 30004248: e1a02004 mov r2, r4 <== NOT EXECUTED 3000424c: ebfffdf5 bl 30003a28 <rtems_termios_puts> <== NOT EXECUTED 30004250: eafffff4 b 30004228 <rtems_termios_write+0xa0> <== NOT EXECUTED
30006ab0 <rtems_verror>:
{
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
30006ab0: e3100202 tst r0, #536870912 ; 0x20000000
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
30006ab4: e92d41f0 push {r4, r5, r6, r7, r8, lr}
30006ab8: e1a04000 mov r4, r0
30006abc: e1a08001 mov r8, r1
30006ac0: e1a06002 mov r6, r2
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
30006ac4: 0a00000d beq 30006b00 <rtems_verror+0x50>
if (rtems_panic_in_progress++)
30006ac8: e59f212c ldr r2, [pc, #300] ; 30006bfc <rtems_verror+0x14c> 30006acc: e5921000 ldr r1, [r2] 30006ad0: e2813001 add r3, r1, #1 30006ad4: e3510000 cmp r1, #0 30006ad8: e5823000 str r3, [r2]
30006adc: 0a000004 beq 30006af4 <rtems_verror+0x44>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30006ae0: e59f3118 ldr r3, [pc, #280] ; 30006c00 <rtems_verror+0x150><== NOT EXECUTED 30006ae4: e5931000 ldr r1, [r3] <== NOT EXECUTED 30006ae8: e2811001 add r1, r1, #1 <== NOT EXECUTED 30006aec: e5831000 str r1, [r3] <== NOT EXECUTED
RTEMS_COMPILER_MEMORY_BARRIER();
30006af0: e5923000 ldr r3, [r2] <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
30006af4: e3530002 cmp r3, #2
return 0;
30006af8: 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)
30006afc: ca000024 bgt 30006b94 <rtems_verror+0xe4>
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
30006b00: e59f50fc ldr r5, [pc, #252] ; 30006c04 <rtems_verror+0x154>
status = error_flag & ~RTEMS_ERROR_MASK;
30006b04: e3c47207 bic r7, r4, #1879048192 ; 0x70000000
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
30006b08: e5953000 ldr r3, [r5] 30006b0c: e5930008 ldr r0, [r3, #8] 30006b10: eb0032f4 bl 300136e8 <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
30006b14: e2144101 ands r4, r4, #1073741824 ; 0x40000000
30006b18: 1a00002a bne 30006bc8 <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);
30006b1c: e5953000 ldr r3, [r5] 30006b20: e1a02006 mov r2, r6 30006b24: e1a01008 mov r1, r8 30006b28: e593000c ldr r0, [r3, #12] 30006b2c: eb004b5f bl 300198b0 <vfprintf>
if (status)
30006b30: e3570000 cmp r7, #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);
30006b34: e1a06000 mov r6, r0
if (status)
30006b38: 1a000017 bne 30006b9c <rtems_verror+0xec>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
30006b3c: e3540000 cmp r4, #0
30006b40: 0a00000b beq 30006b74 <rtems_verror+0xc4>
if ((local_errno > 0) && *strerror(local_errno))
30006b44: da000004 ble 30006b5c <rtems_verror+0xac>
30006b48: e1a00004 mov r0, r4 30006b4c: eb0036ce bl 3001468c <strerror> 30006b50: e5d03000 ldrb r3, [r0] 30006b54: e3530000 cmp r3, #0
30006b58: 1a00001d bne 30006bd4 <rtems_verror+0x124>
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
30006b5c: e5953000 ldr r3, [r5] 30006b60: e59f10a0 ldr r1, [pc, #160] ; 30006c08 <rtems_verror+0x158> 30006b64: e593000c ldr r0, [r3, #12] 30006b68: e1a02004 mov r2, r4 30006b6c: eb0033c3 bl 30013a80 <fprintf> 30006b70: e0866000 add r6, r6, r0
}
chars_written += fprintf(stderr, "\n");
30006b74: e5953000 ldr r3, [r5] 30006b78: e59f108c ldr r1, [pc, #140] ; 30006c0c <rtems_verror+0x15c> 30006b7c: e593000c ldr r0, [r3, #12] 30006b80: eb0033be bl 30013a80 <fprintf>
(void) fflush(stderr);
30006b84: 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");
30006b88: e0806006 add r6, r0, r6
(void) fflush(stderr);
30006b8c: e593000c ldr r0, [r3, #12] 30006b90: eb0032d4 bl 300136e8 <fflush>
return chars_written;
}
30006b94: e1a00006 mov r0, r6
30006b98: 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));
30006b9c: e59f3060 ldr r3, [pc, #96] ; 30006c04 <rtems_verror+0x154> 30006ba0: e1a00007 mov r0, r7 30006ba4: e5933000 ldr r3, [r3] 30006ba8: e593700c ldr r7, [r3, #12] 30006bac: ebffffbb bl 30006aa0 <rtems_status_text> 30006bb0: e59f1058 ldr r1, [pc, #88] ; 30006c10 <rtems_verror+0x160> 30006bb4: e1a02000 mov r2, r0 30006bb8: e1a00007 mov r0, r7 30006bbc: eb0033af bl 30013a80 <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
30006bc0: e0866000 add r6, r6, r0 30006bc4: eaffffdc b 30006b3c <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;
30006bc8: eb0031cf bl 3001330c <__errno> 30006bcc: e5904000 ldr r4, [r0] 30006bd0: eaffffd1 b 30006b1c <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));
30006bd4: e5953000 ldr r3, [r5] 30006bd8: e1a00004 mov r0, r4 30006bdc: e593400c ldr r4, [r3, #12] 30006be0: eb0036a9 bl 3001468c <strerror> 30006be4: e59f1028 ldr r1, [pc, #40] ; 30006c14 <rtems_verror+0x164> 30006be8: e1a02000 mov r2, r0 30006bec: e1a00004 mov r0, r4 30006bf0: eb0033a2 bl 30013a80 <fprintf> 30006bf4: e0866000 add r6, r6, r0 30006bf8: eaffffdd b 30006b74 <rtems_verror+0xc4>
30002734 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
30002734: 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;
30002738: e3a06000 mov r6, #0
int d;
for (;;) {
c = getc(fp);
3000273c: e59f90f8 ldr r9, [pc, #248] ; 3000283c <scanInt+0x108>
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
30002740: e59f80f8 ldr r8, [pc, #248] ; 30002840 <scanInt+0x10c>
return 0;
d = c - '0';
if ((i > (limit / 10))
30002744: e59fa0f8 ldr sl, [pc, #248] ; 30002844 <scanInt+0x110>
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
30002748: e1a04000 mov r4, r0 3000274c: e1a0b001 mov fp, r1
int c; unsigned int i = 0; unsigned int limit = INT_MAX;
30002750: e3e07102 mvn r7, #-2147483648 ; 0x80000000
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
30002754: e1a05006 mov r5, r6
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
30002758: e5943004 ldr r3, [r4, #4] 3000275c: e2433001 sub r3, r3, #1 30002760: e3530000 cmp r3, #0 30002764: e5843004 str r3, [r4, #4]
30002768: ba00001d blt 300027e4 <scanInt+0xb0>
3000276c: e5943000 ldr r3, [r4] 30002770: e4d30001 ldrb r0, [r3], #1
if (c == ':')
30002774: e350003a cmp r0, #58 ; 0x3a
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
30002778: e5843000 str r3, [r4]
if (c == ':')
3000277c: 0a00001d beq 300027f8 <scanInt+0xc4>
break;
if (sign == 0) {
30002780: e3560000 cmp r6, #0
30002784: 1a000004 bne 3000279c <scanInt+0x68>
if (c == '-') {
30002788: e350002d cmp r0, #45 ; 0x2d
sign = -1;
limit++;
3000278c: 02877001 addeq r7, r7, #1
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
30002790: 03e06000 mvneq r6, #0
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
30002794: 0affffef beq 30002758 <scanInt+0x24>
sign = -1;
limit++;
continue;
}
sign = 1;
30002798: e3a06001 mov r6, #1
}
if (!isdigit(c))
3000279c: e5983000 ldr r3, [r8] 300027a0: e0833000 add r3, r3, r0 300027a4: e5d33001 ldrb r3, [r3, #1] 300027a8: e2133004 ands r3, r3, #4
300027ac: 0a00001e beq 3000282c <scanInt+0xf8>
return 0;
d = c - '0';
if ((i > (limit / 10))
300027b0: e083279a umull r2, r3, sl, r7 300027b4: e15501a3 cmp r5, r3, lsr #3
300027b8: 8a000019 bhi 30002824 <scanInt+0xf0>
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
300027bc: e2400030 sub r0, r0, #48 ; 0x30 300027c0: 11a03105 lslne r3, r5, #2
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
300027c4: 0a000011 beq 30002810 <scanInt+0xdc>
return 0;
i = i * 10 + d;
300027c8: e0835005 add r5, r3, r5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
300027cc: e5943004 ldr r3, [r4, #4]
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
300027d0: e0805085 add r5, r0, r5, lsl #1
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
300027d4: e2433001 sub r3, r3, #1 300027d8: e3530000 cmp r3, #0 300027dc: e5843004 str r3, [r4, #4]
300027e0: aaffffe1 bge 3000276c <scanInt+0x38>
300027e4: e5990000 ldr r0, [r9] <== NOT EXECUTED 300027e8: e1a01004 mov r1, r4 <== NOT EXECUTED 300027ec: eb00367a bl 300101dc <__srget_r> <== NOT EXECUTED
if (c == ':')
300027f0: e350003a cmp r0, #58 ; 0x3a <== NOT EXECUTED 300027f4: 1affffe1 bne 30002780 <scanInt+0x4c> <== NOT EXECUTED
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
300027f8: e3560000 cmp r6, #0
300027fc: 0a00000c beq 30002834 <scanInt+0x100>
return 0;
*val = i * sign;
30002800: e0050596 mul r5, r6, r5
return 1;
30002804: e3a00001 mov r0, #1
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
*val = i * sign;
30002808: e58b5000 str r5, [fp]
return 1;
3000280c: 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))))
30002810: e1a03105 lsl r3, r5, #2 30002814: e0832005 add r2, r3, r5 30002818: e0472082 sub r2, r7, r2, lsl #1 3000281c: e1500002 cmp r0, r2
30002820: 9affffe8 bls 300027c8 <scanInt+0x94>
return 0;
30002824: e3a00000 mov r0, #0
30002828: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
continue;
}
sign = 1;
}
if (!isdigit(c))
return 0;
3000282c: e1a00003 mov r0, r3
30002830: 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;
30002834: e1a00006 mov r0, r6 <== NOT EXECUTED
*val = i * sign; return 1; }
30002838: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3000293c <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
3000293c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
30002940: e24dd014 sub sp, sp, #20
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
30002944: e28d5008 add r5, sp, #8 30002948: e28d4004 add r4, sp, #4
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
3000294c: e58d2008 str r2, [sp, #8] 30002950: e58d3004 str r3, [sp, #4]
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
30002954: e3a06000 mov r6, #0 30002958: e1a02005 mov r2, r5 3000295c: e1a03004 mov r3, r4
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
30002960: e1a07000 mov r7, r0 30002964: e1a08001 mov r8, r1
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
30002968: e58d6000 str r6, [sp] 3000296c: ebffffb5 bl 30002848 <scanString> 30002970: e3500000 cmp r0, #0
30002974: 1a000001 bne 30002980 <scangr+0x44>
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
return 1;
}
30002978: e28dd014 add sp, sp, #20
3000297c: 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)
30002980: e1a00007 mov r0, r7 30002984: e2881004 add r1, r8, #4 30002988: e1a02005 mov r2, r5 3000298c: e1a03004 mov r3, r4 30002990: e58d6000 str r6, [sp] 30002994: ebffffab bl 30002848 <scanString> 30002998: e3500000 cmp r0, #0
3000299c: 0afffff5 beq 30002978 <scangr+0x3c> || !scanInt(fp, &grgid)
300029a0: e1a00007 mov r0, r7 300029a4: e28d1010 add r1, sp, #16 300029a8: ebffff61 bl 30002734 <scanInt> 300029ac: e3500000 cmp r0, #0
300029b0: 0afffff0 beq 30002978 <scangr+0x3c> || !scanString(fp, &grmem, &buffer, &bufsize, 1))
300029b4: e3a06001 mov r6, #1 300029b8: e1a00007 mov r0, r7 300029bc: e28d100c add r1, sp, #12 300029c0: e1a02005 mov r2, r5 300029c4: e1a03004 mov r3, r4 300029c8: e58d6000 str r6, [sp] 300029cc: ebffff9d bl 30002848 <scanString> 300029d0: e3500000 cmp r0, #0
300029d4: 0affffe7 beq 30002978 <scangr+0x3c>
return 0;
grp->gr_gid = grgid;
300029d8: e1dd31b0 ldrh r3, [sp, #16]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
300029dc: 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;
300029e0: e1c830b8 strh r3, [r8, #8]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
300029e4: e5d13000 ldrb r3, [r1] 300029e8: e3530000 cmp r3, #0 300029ec: 03a06017 moveq r6, #23
300029f0: 0a000007 beq 30002a14 <scangr+0xd8>
300029f4: e1a02001 mov r2, r1
if(*cp == ',')
300029f8: e353002c cmp r3, #44 ; 0x2c
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
300029fc: e5f23001 ldrb r3, [r2, #1]!
if(*cp == ',')
memcount++;
30002a00: 02866001 addeq r6, r6, #1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30002a04: e3530000 cmp r3, #0
30002a08: 1afffffa bne 300029f8 <scangr+0xbc>
30002a0c: e1a06106 lsl r6, r6, #2 30002a10: e2866013 add r6, r6, #19
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
30002a14: e59d3004 ldr r3, [sp, #4] 30002a18: e1530006 cmp r3, r6
return 0;
30002a1c: 33a00000 movcc r0, #0
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
30002a20: 3affffd4 bcc 30002978 <scangr+0x3c>
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
30002a24: e59d0008 ldr r0, [sp, #8] 30002a28: e280000f add r0, r0, #15 30002a2c: e3c0000f bic r0, r0, #15 30002a30: e588000c str r0, [r8, #12]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
30002a34: e5801000 str r1, [r0]
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30002a38: e59d200c ldr r2, [sp, #12] 30002a3c: e5d23000 ldrb r3, [r2] 30002a40: e3530000 cmp r3, #0
30002a44: 0a000010 beq 30002a8c <scangr+0x150>
}
/*
* Extract a single group record from the database
*/
static int scangr(
30002a48: e2822001 add r2, r2, #1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30002a4c: e3a01001 mov r1, #1
if(*cp == ',') {
*cp = '\0';
30002a50: e3a00000 mov r0, #0
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
if(*cp == ',') {
30002a54: e353002c cmp r3, #44 ; 0x2c
*cp = '\0';
30002a58: 05420001 strbeq r0, [r2, #-1]
grp->gr_mem[memcount++] = cp + 1;
30002a5c: 0598300c ldreq r3, [r8, #12] 30002a60: 07832101 streq r2, [r3, r1, lsl #2]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30002a64: e4d23001 ldrb r3, [r2], #1
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
30002a68: 02811001 addeq r1, r1, #1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30002a6c: e3530000 cmp r3, #0
30002a70: 1afffff7 bne 30002a54 <scangr+0x118>
30002a74: e598000c ldr r0, [r8, #12] 30002a78: e1a01101 lsl r1, r1, #2
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
30002a7c: e3a03000 mov r3, #0 30002a80: e7803001 str r3, [r0, r1]
return 1;
30002a84: e3a00001 mov r0, #1 30002a88: eaffffba b 30002978 <scangr+0x3c>
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30002a8c: e3a01004 mov r1, #4 <== NOT EXECUTED 30002a90: eafffff9 b 30002a7c <scangr+0x140> <== NOT EXECUTED
300087a0 <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
300087a0: e92d4010 push {r4, lr}
300087a4: e24dd004 sub sp, sp, #4
300087a8: 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 );
300087ac: e1a00001 mov r0, r1 300087b0: e1a0100d mov r1, sp 300087b4: eb001671 bl 3000e180 <_POSIX_Absolute_timeout_to_ticks>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
300087b8: e3500003 cmp r0, #3
300087bc: 0a000005 beq 300087d8 <sem_timedwait+0x38>
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
300087c0: e1a00004 mov r0, r4 300087c4: e3a01000 mov r1, #0 300087c8: e59d2000 ldr r2, [sp] 300087cc: eb001986 bl 3000edec <_POSIX_Semaphore_Wait_support>
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
300087d0: e28dd004 add sp, sp, #4
300087d4: 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 );
300087d8: e1a00004 mov r0, r4 300087dc: e3a01001 mov r1, #1 300087e0: e59d2000 ldr r2, [sp] 300087e4: eb001980 bl 3000edec <_POSIX_Semaphore_Wait_support> 300087e8: eafffff8 b 300087d0 <sem_timedwait+0x30>
30005fe0 <sigaction>:
struct sigaction *oact
)
{
ISR_Level level;
if ( oact )
30005fe0: e2523000 subs r3, r2, #0
*oact = _POSIX_signals_Vectors[ sig ];
30005fe4: 159f20c4 ldrne r2, [pc, #196] ; 300060b0 <sigaction+0xd0>
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
30005fe8: e92d4070 push {r4, r5, r6, lr}
30005fec: e1a05001 mov r5, r1
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
30005ff0: 10801080 addne r1, r0, r0, lsl #1 30005ff4: 10822101 addne r2, r2, r1, lsl #2
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
30005ff8: e1a04000 mov r4, r0
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
30005ffc: 18920007 ldmne r2, {r0, r1, r2}
30006000: 18830007 stmne r3, {r0, r1, r2}
if ( !sig )
30006004: e3540000 cmp r4, #0
30006008: 0a000023 beq 3000609c <sigaction+0xbc>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
3000600c: e2443001 sub r3, r4, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
30006010: e353001f cmp r3, #31
30006014: 8a000020 bhi 3000609c <sigaction+0xbc>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
30006018: e3540009 cmp r4, #9
3000601c: 0a00001e beq 3000609c <sigaction+0xbc>
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
30006020: e3550000 cmp r5, #0
30006024: 0a00001a beq 30006094 <sigaction+0xb4>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30006028: e10f6000 mrs r6, CPSR 3000602c: e3863080 orr r3, r6, #128 ; 0x80 30006030: 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 ) {
30006034: e5953008 ldr r3, [r5, #8] 30006038: e3530000 cmp r3, #0
3000603c: 0a000009 beq 30006068 <sigaction+0x88>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
30006040: e1a00004 mov r0, r4 30006044: eb001740 bl 3000bd4c <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
30006048: e8950007 ldm r5, {r0, r1, r2}
3000604c: e59f305c ldr r3, [pc, #92] ; 300060b0 <sigaction+0xd0>
30006050: e0844084 add r4, r4, r4, lsl #1
30006054: e0834104 add r4, r3, r4, lsl #2
30006058: e8840007 stm r4, {r0, r1, r2}
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3000605c: 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;
30006060: e3a00000 mov r0, #0
30006064: 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 ];
30006068: e59f2044 ldr r2, [pc, #68] ; 300060b4 <sigaction+0xd4>
3000606c: e0844084 add r4, r4, r4, lsl #1
30006070: e59f3038 ldr r3, [pc, #56] ; 300060b0 <sigaction+0xd0>
30006074: e1a04104 lsl r4, r4, #2
30006078: e0833004 add r3, r3, r4
3000607c: e0824004 add r4, r2, r4
30006080: e8940007 ldm r4, {r0, r1, r2}
30006084: e8830007 stm r3, {r0, r1, r2}
30006088: 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;
3000608c: e3a00000 mov r0, #0
30006090: e8bd8070 pop {r4, r5, r6, pc}
30006094: e1a00005 mov r0, r5
}
30006098: 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 );
3000609c: eb002395 bl 3000eef8 <__errno>
300060a0: e3a03016 mov r3, #22
300060a4: e5803000 str r3, [r0]
300060a8: e3e00000 mvn r0, #0
300060ac: e8bd8070 pop {r4, r5, r6, pc}
30008904 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
30008904: e92d4010 push {r4, lr}
30008908: e1a04001 mov r4, r1
int status;
status = sigtimedwait( set, NULL, NULL );
3000890c: e3a01000 mov r1, #0 30008910: e1a02001 mov r2, r1 30008914: ebffff7f bl 30008718 <sigtimedwait>
if ( status != -1 ) {
30008918: e3700001 cmn r0, #1
3000891c: 0a000005 beq 30008938 <sigwait+0x34>
if ( sig )
30008920: e3540000 cmp r4, #0
*sig = status;
30008924: 15840000 strne r0, [r4]
return 0;
30008928: 13a00000 movne r0, #0
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
3000892c: 18bd8010 popne {r4, pc}
*sig = status;
return 0;
30008930: e1a00004 mov r0, r4 <== NOT EXECUTED
}
return errno;
}
30008934: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( sig )
*sig = status;
return 0;
}
return errno;
30008938: eb0022f1 bl 30011504 <__errno>
3000893c: e5900000 ldr r0, [r0]
30008940: e8bd8010 pop {r4, pc}
3000412c <siproc>:
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
3000412c: e591203c ldr r2, [r1, #60] ; 0x3c 30004130: e59f304c ldr r3, [pc, #76] ; 30004184 <siproc+0x58>
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
30004134: e92d4030 push {r4, r5, lr}
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
30004138: e0023003 and r3, r2, r3 3000413c: e3530000 cmp r3, #0
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
30004140: e1a04001 mov r4, r1 30004144: 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)) {
30004148: 1a000001 bne 30004154 <siproc+0x28>
}
else {
i = iproc (c, tty);
}
return i;
}
3000414c: 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);
30004150: eaffff81 b 30003f5c <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);
30004154: e3a01000 mov r1, #0 30004158: e1a02001 mov r2, r1 3000415c: e5940018 ldr r0, [r4, #24] 30004160: eb000548 bl 30005688 <rtems_semaphore_obtain>
i = iproc (c, tty);
30004164: e1a01004 mov r1, r4 30004168: e1a00005 mov r0, r5 3000416c: ebffff7a bl 30003f5c <iproc> 30004170: e1a05000 mov r5, r0
rtems_semaphore_release (tty->osem);
30004174: e5940018 ldr r0, [r4, #24] 30004178: eb00058b bl 300057ac <rtems_semaphore_release>
}
else {
i = iproc (c, tty);
}
return i;
}
3000417c: e1a00005 mov r0, r5
30004180: e8bd8030 pop {r4, r5, pc}
30006040 <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
30006040: e92d40f0 push {r4, r5, r6, r7, lr}
30006044: e24dd030 sub sp, sp, #48 ; 0x30
30006048: e1a07000 mov r7, r0
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
3000604c: ebfff465 bl 300031e8 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
30006050: e2505000 subs r5, r0, #0
30006054: 1a000039 bne 30006140 <unlink+0x100>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
30006058: e28d4018 add r4, sp, #24 3000605c: e1a00007 mov r0, r7 30006060: e28d102c add r1, sp, #44 ; 0x2c 30006064: e1a02004 mov r2, r4 30006068: ebfff870 bl 30004230 <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;
3000606c: e1a06005 mov r6, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
30006070: e28dc004 add ip, sp, #4
30006074: e1a0e004 mov lr, r4
30006078: e8be000f ldm lr!, {r0, r1, r2, r3}
3000607c: e8ac000f stmia ip!, {r0, r1, r2, r3}
name = path + parentpathlen;
30006080: e0875005 add r5, r7, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
30006084: e59e3000 ldr r3, [lr]
name = path + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
30006088: e1a00005 mov r0, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
3000608c: e58c3000 str r3, [ip]
name = path + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
30006090: eb0033e1 bl 3001301c <strlen> 30006094: e1a01000 mov r1, r0 30006098: e1a00005 mov r0, r5 3000609c: ebfff460 bl 30003224 <rtems_filesystem_prefix_separators> 300060a0: e0857000 add r7, r5, r0
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
300060a4: e1a00007 mov r0, r7 300060a8: eb0033db bl 3001301c <strlen> 300060ac: e28d5004 add r5, sp, #4 300060b0: e1a01000 mov r1, r0 300060b4: e3a02000 mov r2, #0 300060b8: e1a00007 mov r0, r7 300060bc: e1a03005 mov r3, r5 300060c0: e58d2000 str r2, [sp] 300060c4: ebfff415 bl 30003120 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
300060c8: e3500000 cmp r0, #0
300060cc: 1a000013 bne 30006120 <unlink+0xe0>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
300060d0: e1a00005 mov r0, r5 300060d4: e59d3010 ldr r3, [sp, #16] 300060d8: e1a0e00f mov lr, pc 300060dc: e593f010 ldr pc, [r3, #16] 300060e0: e3500001 cmp r0, #1
300060e4: 0a000021 beq 30006170 <unlink+0x130>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( EISDIR );
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
300060e8: e1a01005 mov r1, r5 300060ec: e59d3010 ldr r3, [sp, #16] 300060f0: e1a00004 mov r0, r4 300060f4: e1a0e00f mov lr, pc 300060f8: e593f00c ldr pc, [r3, #12] 300060fc: e1a07000 mov r7, r0
rtems_filesystem_freenode( &loc );
30006100: e1a00005 mov r0, r5 30006104: ebfff45b bl 30003278 <rtems_filesystem_freenode>
if ( free_parentloc )
30006108: e3560000 cmp r6, #0
rtems_filesystem_freenode( &parentloc );
3000610c: 11a00004 movne r0, r4 30006110: 1bfff458 blne 30003278 <rtems_filesystem_freenode>
return result;
}
30006114: e1a00007 mov r0, r7
30006118: e28dd030 add sp, sp, #48 ; 0x30
3000611c: 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 )
30006120: e3560000 cmp r6, #0
30006124: 1a000001 bne 30006130 <unlink+0xf0>
rtems_filesystem_freenode( &parentloc );
return -1;
30006128: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000612c: eafffff8 b 30006114 <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 );
30006130: e1a00004 mov r0, r4 30006134: ebfff44f bl 30003278 <rtems_filesystem_freenode>
return -1;
30006138: e3e07000 mvn r7, #0 3000613c: eafffff4 b 30006114 <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,
30006140: e3a03000 mov r3, #0 30006144: e28d4018 add r4, sp, #24 30006148: e58d3000 str r3, [sp] 3000614c: e3a02002 mov r2, #2 30006150: e1a00007 mov r0, r7 30006154: e1a01005 mov r1, r5 30006158: e1a03004 mov r3, r4 3000615c: ebfff40b bl 30003190 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
30006160: e3500000 cmp r0, #0
30006164: 1affffef bne 30006128 <unlink+0xe8>
return -1;
free_parentloc = true;
30006168: e3a06001 mov r6, #1 3000616c: eaffffbf b 30006070 <unlink+0x30>
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_filesystem_freenode( &loc );
30006170: e1a00005 mov r0, r5 30006174: ebfff43f bl 30003278 <rtems_filesystem_freenode>
if ( free_parentloc )
30006178: e3560000 cmp r6, #0
rtems_filesystem_freenode( &parentloc );
3000617c: 11a00004 movne r0, r4 30006180: 1bfff43c blne 30003278 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EISDIR );
30006184: eb002fe5 bl 30012120 <__errno> 30006188: e3a03015 mov r3, #21 3000618c: e5803000 str r3, [r0] 30006190: e3e07000 mvn r7, #0 30006194: eaffffde b 30006114 <unlink+0xd4>
30006360 <unmount>:
*/
int unmount(
const char *path
)
{
30006360: e92d4070 push {r4, r5, r6, lr}
30006364: e24dd018 sub sp, sp, #24
30006368: 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 ) )
3000636c: eb00289f bl 300105f0 <strlen> 30006370: e28d4004 add r4, sp, #4 30006374: e1a01000 mov r1, r0 30006378: e3a0c001 mov ip, #1 3000637c: e1a00005 mov r0, r5 30006380: e3a02000 mov r2, #0 30006384: e1a03004 mov r3, r4 30006388: e58dc000 str ip, [sp] 3000638c: ebfff344 bl 300030a4 <rtems_filesystem_evaluate_path> 30006390: e3500000 cmp r0, #0
30006394: 1a00001a bne 30006404 <unmount+0xa4>
return -1;
mt_entry = loc.mt_entry;
30006398: 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 ){
3000639c: e59d3004 ldr r3, [sp, #4] 300063a0: e595201c ldr r2, [r5, #28] 300063a4: e1520003 cmp r2, r3
300063a8: 1a00002d bne 30006464 <unmount+0x104>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
300063ac: e1a00004 mov r0, r4 300063b0: ebfff375 bl 3000318c <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 )
300063b4: e59f30f8 ldr r3, [pc, #248] ; 300064b4 <unmount+0x154> 300063b8: e5933000 ldr r3, [r3] 300063bc: e5933014 ldr r3, [r3, #20] 300063c0: e1530005 cmp r3, r5
300063c4: 0a00002d beq 30006480 <unmount+0x120>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
300063c8: e59f00e8 ldr r0, [pc, #232] ; 300064b8 <unmount+0x158> 300063cc: e595102c ldr r1, [r5, #44] ; 0x2c 300063d0: ebfff5c1 bl 30003adc <rtems_filesystem_mount_iterate> 300063d4: e3500000 cmp r0, #0
300063d8: 1a000028 bne 30006480 <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 )
300063dc: e1a00005 mov r0, r5 300063e0: ebfff463 bl 30003574 <rtems_libio_is_open_files_in_fs> 300063e4: e3500001 cmp r0, #1
300063e8: 0a000024 beq 30006480 <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 )
300063ec: e5953014 ldr r3, [r5, #20] 300063f0: e1a00005 mov r0, r5 300063f4: e1a0e00f mov lr, pc 300063f8: e593f028 ldr pc, [r3, #40] ; 0x28 300063fc: e2506000 subs r6, r0, #0
30006400: 0a000002 beq 30006410 <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;
30006404: e3e00000 mvn r0, #0
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
30006408: e28dd018 add sp, sp, #24
3000640c: 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){
30006410: e5953028 ldr r3, [r5, #40] ; 0x28 30006414: e1a00005 mov r0, r5 30006418: e1a0e00f mov lr, pc 3000641c: e593f02c ldr pc, [r3, #44] ; 0x2c 30006420: e2504000 subs r4, r0, #0
30006424: 1a00001a bne 30006494 <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 );
30006428: e59f608c ldr r6, [pc, #140] ; 300064bc <unmount+0x15c> 3000642c: e1a01004 mov r1, r4 30006430: e1a02004 mov r2, r4 30006434: e5960000 ldr r0, [r6] 30006438: eb0002a1 bl 30006ec4 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
3000643c: e1a00005 mov r0, r5 30006440: eb000506 bl 30007860 <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
30006444: e5960000 ldr r0, [r6] 30006448: eb0002e6 bl 30006fe8 <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 );
3000644c: e2850008 add r0, r5, #8 30006450: ebfff34d bl 3000318c <rtems_filesystem_freenode>
free( mt_entry );
30006454: e1a00005 mov r0, r5 30006458: ebfff350 bl 300031a0 <free>
return 0;
3000645c: e1a00004 mov r0, r4 30006460: eaffffe8 b 30006408 <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 );
30006464: e1a00004 mov r0, r4 30006468: ebfff347 bl 3000318c <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EACCES );
3000646c: eb0022e7 bl 3000f010 <__errno> 30006470: e3a0300d mov r3, #13 30006474: e5803000 str r3, [r0] 30006478: e3e00000 mvn r0, #0 3000647c: eaffffe1 b 30006408 <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 );
30006480: eb0022e2 bl 3000f010 <__errno> 30006484: e3a03010 mov r3, #16 30006488: e5803000 str r3, [r0] 3000648c: e3e00000 mvn r0, #0 30006490: eaffffdc b 30006408 <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 )
30006494: e5953014 ldr r3, [r5, #20] 30006498: e1a00005 mov r0, r5 3000649c: e1a0e00f mov lr, pc 300064a0: e593f020 ldr pc, [r3, #32] 300064a4: e3500000 cmp r0, #0
300064a8: 0affffd5 beq 30006404 <unmount+0xa4>
rtems_fatal_error_occurred( 0 );
300064ac: e1a00006 mov r0, r6 300064b0: eb000415 bl 3000750c <rtems_fatal_error_occurred>
30004c84 <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
30004c84: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30004c88: e1a0a000 mov sl, r0
for (; *fmt != '\0'; fmt++) {
30004c8c: e5d00000 ldrb r0, [r0]
*/
void vprintk(
const char *fmt,
va_list ap
)
{
30004c90: e24dd01c sub sp, sp, #28
for (; *fmt != '\0'; fmt++) {
30004c94: e3500000 cmp r0, #0
*/
void vprintk(
const char *fmt,
va_list ap
)
{
30004c98: e58d1000 str r1, [sp]
for (; *fmt != '\0'; fmt++) {
30004c9c: 0a00006e beq 30004e5c <vprintk+0x1d8>
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
BSP_output_char(*fmt);
30004ca0: e59f8334 ldr r8, [pc, #820] ; 30004fdc <vprintk+0x358>
* console is not yet initialized or in ISR's. * * Arguments: * as in printf: fmt - format string, ... - unnamed arguments. */ void vprintk(
30004ca4: e28db008 add fp, sp, #8
bool minus = false;
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
30004ca8: e3500025 cmp r0, #37 ; 0x25
30004cac: 1a00006c bne 30004e64 <vprintk+0x1e0>
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
30004cb0: e5fa0001 ldrb r0, [sl, #1]! 30004cb4: e3500030 cmp r0, #48 ; 0x30
lead = '0';
fmt++;
30004cb8: 05fa0001 ldrbeq r0, [sl, #1]!
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
30004cbc: 13a03020 movne r3, #32
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
30004cc0: 03a02030 moveq r2, #48 ; 0x30
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
30004cc4: 158d3004 strne r3, [sp, #4]
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
30004cc8: 058d2004 streq r2, [sp, #4]
fmt++;
}
if (*fmt == '-' ) {
30004ccc: e350002d cmp r0, #45 ; 0x2d
minus = true;
fmt++;
30004cd0: 05fa0001 ldrbeq r0, [sl, #1]!
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
30004cd4: 03a09001 moveq r9, #1
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
30004cd8: e2403030 sub r3, r0, #48 ; 0x30
{
for (; *fmt != '\0'; fmt++) {
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
30004cdc: 13a09000 movne r9, #0
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
30004ce0: e3530009 cmp r3, #9 30004ce4: 83a04000 movhi r4, #0
30004ce8: 8a000009 bhi 30004d14 <vprintk+0x90> * console is not yet initialized or in ISR's. * * Arguments: * as in printf: fmt - format string, ... - unnamed arguments. */ void vprintk(
30004cec: e28a3001 add r3, sl, #1 30004cf0: e3a04000 mov r4, #0
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
30004cf4: e0844104 add r4, r4, r4, lsl #2
width += ((unsigned) *fmt - '0');
30004cf8: e0804084 add r4, r0, r4, lsl #1 30004cfc: e1a0a003 mov sl, r3
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
30004d00: e4d30001 ldrb r0, [r3], #1
width *= 10;
width += ((unsigned) *fmt - '0');
30004d04: e2444030 sub r4, r4, #48 ; 0x30
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
30004d08: e2402030 sub r2, r0, #48 ; 0x30 30004d0c: e3520009 cmp r2, #9
30004d10: 9afffff7 bls 30004cf4 <vprintk+0x70>
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
30004d14: e350006c cmp r0, #108 ; 0x6c
lflag = true;
c = *++fmt;
30004d18: 05fa0001 ldrbeq r0, [sl, #1]!
}
if ( c == 'c' ) {
30004d1c: e3500063 cmp r0, #99 ; 0x63
30004d20: 0a00008b beq 30004f54 <vprintk+0x2d0>
/* 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' ) {
30004d24: e3500073 cmp r0, #115 ; 0x73
30004d28: 0a000053 beq 30004e7c <vprintk+0x1f8>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
30004d2c: e350006f cmp r0, #111 ; 0x6f 30004d30: 1350004f cmpne r0, #79 ; 0x4f
base = 8; sign = false;
30004d34: 03a02000 moveq r2, #0 30004d38: 03a09008 moveq r9, #8
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
30004d3c: 0a000009 beq 30004d68 <vprintk+0xe4>
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
30004d40: e3500069 cmp r0, #105 ; 0x69 30004d44: 13500049 cmpne r0, #73 ; 0x49
30004d48: 0a000004 beq 30004d60 <vprintk+0xdc>
c == 'd' || c == 'D' ) {
30004d4c: e3500064 cmp r0, #100 ; 0x64 30004d50: 13500044 cmpne r0, #68 ; 0x44 30004d54: 13a02000 movne r2, #0 30004d58: 03a02001 moveq r2, #1
30004d5c: 1a000086 bne 30004f7c <vprintk+0x2f8>
base = 10; sign = true;
30004d60: e3a02001 mov r2, #1 30004d64: e3a0900a mov r9, #10
} else {
BSP_output_char(c);
continue;
}
printNum(
30004d68: e59d3000 ldr r3, [sp]
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
30004d6c: e3520000 cmp r2, #0
} else {
BSP_output_char(c);
continue;
}
printNum(
30004d70: e5937000 ldr r7, [r3]
lflag ? va_arg(ap, long) : (long) va_arg(ap, int),
30004d74: e2833004 add r3, r3, #4 30004d78: e58d3000 str r3, [sp]
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
30004d7c: 0a000001 beq 30004d88 <vprintk+0x104>
30004d80: e3570000 cmp r7, #0
30004d84: ba00008d blt 30004fc0 <vprintk+0x33c>
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
30004d88: e1a00007 mov r0, r7 30004d8c: e1a01009 mov r1, r9 30004d90: eb003137 bl 30011274 <__aeabi_uidiv> 30004d94: e3500000 cmp r0, #0 30004d98: e1a05000 mov r5, r0 30004d9c: e1a06000 mov r6, r0 30004da0: 01a05007 moveq r5, r7 30004da4: 03a07001 moveq r7, #1
30004da8: 0a000010 beq 30004df0 <vprintk+0x16c>
30004dac: e20930ff and r3, r9, #255 ; 0xff 30004db0: e1a02007 mov r2, r7
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
30004db4: e3a06000 mov r6, #0 30004db8: e1a07003 mov r7, r3 30004dbc: ea000001 b 30004dc8 <vprintk+0x144>
while ((n = unsigned_num / base) > 0) {
30004dc0: e1a02005 mov r2, r5 30004dc4: e1a05000 mov r5, r0
toPrint[count++] = (char) (unsigned_num - (n * base));
30004dc8: e0030795 mul r3, r5, r7 30004dcc: e0633002 rsb r3, r3, r2 30004dd0: e7cb3006 strb r3, [fp, r6]
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
30004dd4: e1a00005 mov r0, r5 30004dd8: e1a01009 mov r1, r9 30004ddc: eb003124 bl 30011274 <__aeabi_uidiv> 30004de0: e3500000 cmp r0, #0
toPrint[count++] = (char) (unsigned_num - (n * base));
30004de4: e2866001 add r6, r6, #1
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
30004de8: 1afffff4 bne 30004dc0 <vprintk+0x13c>
30004dec: e2867001 add r7, r6, #1
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
30004df0: e28d201c add r2, sp, #28 30004df4: e0826006 add r6, r2, r6
for (n=maxwidth ; n > count; n-- )
30004df8: e1570004 cmp r7, r4
count = 0;
while ((n = unsigned_num / base) > 0) {
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
30004dfc: e5465014 strb r5, [r6, #-20]
for (n=maxwidth ; n > count; n-- )
30004e00: 2a000006 bcs 30004e20 <vprintk+0x19c>
30004e04: e59d5004 ldr r5, [sp, #4]
BSP_output_char(lead);
30004e08: e1a00005 mov r0, r5
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
30004e0c: e2444001 sub r4, r4, #1
BSP_output_char(lead);
30004e10: e1a0e00f mov lr, pc 30004e14: 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-- )
30004e18: e1570004 cmp r7, r4
30004e1c: 3afffff9 bcc 30004e08 <vprintk+0x184>
BSP_output_char(lead);
for (n = 0; n < count; n++) {
30004e20: e3570000 cmp r7, #0
30004e24: 0a000009 beq 30004e50 <vprintk+0x1cc> * console is not yet initialized or in ISR's. * * Arguments: * as in printf: fmt - format string, ... - unnamed arguments. */ void vprintk(
30004e28: e08b5007 add r5, fp, r7 30004e2c: 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)])]);
30004e30: e5753001 ldrb r3, [r5, #-1]! 30004e34: e59f21a4 ldr r2, [pc, #420] ; 30004fe0 <vprintk+0x35c>
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
30004e38: e2844001 add r4, r4, #1
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
30004e3c: e7d20003 ldrb r0, [r2, r3] 30004e40: e1a0e00f mov lr, pc 30004e44: 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++) {
30004e48: e1570004 cmp r7, r4
30004e4c: 8afffff7 bhi 30004e30 <vprintk+0x1ac>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
30004e50: e5fa0001 ldrb r0, [sl, #1]! 30004e54: e3500000 cmp r0, #0
30004e58: 1affff92 bne 30004ca8 <vprintk+0x24>
sign,
width,
lead
);
}
}
30004e5c: e28dd01c add sp, sp, #28
30004e60: 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);
30004e64: e1a0e00f mov lr, pc 30004e68: e598f000 ldr pc, [r8]
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
30004e6c: e5fa0001 ldrb r0, [sl, #1]! 30004e70: e3500000 cmp r0, #0
30004e74: 1affff8b bne 30004ca8 <vprintk+0x24>
30004e78: eafffff7 b 30004e5c <vprintk+0x1d8>
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
30004e7c: e59d3000 ldr r3, [sp] 30004e80: e5936000 ldr r6, [r3] 30004e84: e2832004 add r2, r3, #4
if ( str == NULL ) {
str = "";
30004e88: e59f3154 ldr r3, [pc, #340] ; 30004fe4 <vprintk+0x360> 30004e8c: e3560000 cmp r6, #0 30004e90: 01a06003 moveq r6, r3
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
30004e94: e58d2000 str r2, [sp]
if ( str == NULL ) {
str = "";
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
30004e98: e5d65000 ldrb r5, [r6] 30004e9c: e3550000 cmp r5, #0
30004ea0: 0a000005 beq 30004ebc <vprintk+0x238>
30004ea4: e1a03006 mov r3, r6 30004ea8: e3a05000 mov r5, #0 30004eac: e5f32001 ldrb r2, [r3, #1]! 30004eb0: e2855001 add r5, r5, #1 30004eb4: e3520000 cmp r2, #0
30004eb8: 1afffffb bne 30004eac <vprintk+0x228>
;
/* leading spaces */
if ( !minus )
30004ebc: e3590000 cmp r9, #0
30004ec0: 1a000008 bne 30004ee8 <vprintk+0x264>
for ( i=len ; i<width ; i++ )
30004ec4: e1550004 cmp r5, r4
30004ec8: 2a000006 bcs 30004ee8 <vprintk+0x264>
30004ecc: e1a07005 mov r7, r5
BSP_output_char(' ');
30004ed0: e3a00020 mov r0, #32
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
30004ed4: e2877001 add r7, r7, #1
BSP_output_char(' ');
30004ed8: e1a0e00f mov lr, pc 30004edc: e598f000 ldr pc, [r8]
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
30004ee0: e1570004 cmp r7, r4
30004ee4: 3afffff9 bcc 30004ed0 <vprintk+0x24c>
BSP_output_char(' ');
/* no width option */
if (width == 0) {
30004ee8: e3540000 cmp r4, #0
30004eec: 1a000002 bne 30004efc <vprintk+0x278>
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
30004ef0: e3550000 cmp r5, #0
30004ef4: 0a000008 beq 30004f1c <vprintk+0x298>
30004ef8: e1a04005 mov r4, r5 30004efc: e5d60000 ldrb r0, [r6] 30004f00: e3500000 cmp r0, #0
30004f04: 0a000004 beq 30004f1c <vprintk+0x298>
BSP_output_char(*str);
30004f08: e1a0e00f mov lr, pc 30004f0c: e598f000 ldr pc, [r8]
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
30004f10: e5f60001 ldrb r0, [r6, #1]! 30004f14: e3500000 cmp r0, #0
30004f18: 1afffffa bne 30004f08 <vprintk+0x284>
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
30004f1c: e3590000 cmp r9, #0
30004f20: 0affffca beq 30004e50 <vprintk+0x1cc>
for ( i=len ; i<width ; i++ )
30004f24: e1550004 cmp r5, r4
30004f28: 2affffc8 bcs 30004e50 <vprintk+0x1cc>
BSP_output_char(' ');
30004f2c: 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++ )
30004f30: e2855001 add r5, r5, #1
BSP_output_char(' ');
30004f34: e1a0e00f mov lr, pc 30004f38: 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++ )
30004f3c: e1550004 cmp r5, r4
30004f40: 3afffff9 bcc 30004f2c <vprintk+0x2a8>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
30004f44: e5fa0001 ldrb r0, [sl, #1]! 30004f48: e3500000 cmp r0, #0
30004f4c: 1affff55 bne 30004ca8 <vprintk+0x24>
30004f50: eaffffc1 b 30004e5c <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);
30004f54: e59d2000 ldr r2, [sp] 30004f58: e2824004 add r4, r2, #4
BSP_output_char(chr);
30004f5c: e5d20000 ldrb r0, [r2] 30004f60: e1a0e00f mov lr, pc 30004f64: 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);
30004f68: e58d4000 str r4, [sp]
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
30004f6c: e5fa0001 ldrb r0, [sl, #1]! 30004f70: e3500000 cmp r0, #0
30004f74: 1affff4b bne 30004ca8 <vprintk+0x24>
30004f78: eaffffb7 b 30004e5c <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' ) {
30004f7c: e3500075 cmp r0, #117 ; 0x75 30004f80: 13500055 cmpne r0, #85 ; 0x55 30004f84: 13a01000 movne r1, #0 30004f88: 03a01001 moveq r1, #1
base = 10; sign = false;
30004f8c: 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' ) {
30004f90: 0affff74 beq 30004d68 <vprintk+0xe4>
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
30004f94: e3500078 cmp r0, #120 ; 0x78 30004f98: 13500058 cmpne r0, #88 ; 0x58 30004f9c: 13a02000 movne r2, #0 30004fa0: 03a02001 moveq r2, #1
base = 16; sign = false;
30004fa4: 03a09010 moveq r9, #16 30004fa8: 01a02001 moveq r2, r1
} 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' ) {
30004fac: 0affff6d beq 30004d68 <vprintk+0xe4>
base = 16; sign = false;
} else if ( c == 'p' ) {
30004fb0: e3500070 cmp r0, #112 ; 0x70
30004fb4: 1affffaa bne 30004e64 <vprintk+0x1e0>
base = 16; sign = false; lflag = true;
30004fb8: e3a09010 mov r9, #16 30004fbc: eaffff69 b 30004d68 <vprintk+0xe4>
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
BSP_output_char('-');
30004fc0: e3a0002d mov r0, #45 ; 0x2d 30004fc4: e1a0e00f mov lr, pc 30004fc8: e598f000 ldr pc, [r8]
unsigned_num = (unsigned long) -num;
if (maxwidth) maxwidth--;
30004fcc: e3540000 cmp r4, #0
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
BSP_output_char('-');
unsigned_num = (unsigned long) -num;
30004fd0: e2677000 rsb r7, r7, #0
if (maxwidth) maxwidth--;
30004fd4: 12444001 subne r4, r4, #1 30004fd8: eaffff6a b 30004d88 <vprintk+0x104>
30006478 <writev>:
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
30006478: e59f3158 ldr r3, [pc, #344] ; 300065d8 <writev+0x160>
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
3000647c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
30006480: e5933000 ldr r3, [r3]
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
30006484: e1a05002 mov r5, r2
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
30006488: e1500003 cmp r0, r3
3000648c: 2a00004a bcs 300065bc <writev+0x144> iop = rtems_libio_iop( fd );
30006490: e59f3144 ldr r3, [pc, #324] ; 300065dc <writev+0x164> 30006494: e0600180 rsb r0, r0, r0, lsl #3 30006498: e5933000 ldr r3, [r3] 3000649c: e0838180 add r8, r3, r0, lsl #3
rtems_libio_check_is_open( iop );
300064a0: e5983014 ldr r3, [r8, #20] 300064a4: e3130c01 tst r3, #256 ; 0x100
300064a8: 0a000043 beq 300065bc <writev+0x144> rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
300064ac: e3130004 tst r3, #4
300064b0: 0a00003b beq 300065a4 <writev+0x12c>
/*
* Argument validation on IO vector
*/
if ( !iov )
300064b4: e3510000 cmp r1, #0
300064b8: 0a000039 beq 300065a4 <writev+0x12c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
300064bc: e3520000 cmp r2, #0
300064c0: da000037 ble 300065a4 <writev+0x12c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
300064c4: e3520b01 cmp r2, #1024 ; 0x400
300064c8: ca000035 bgt 300065a4 <writev+0x12c>
rtems_set_errno_and_return_minus_one( EINVAL );
300064cc: e1a04001 mov r4, r1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
300064d0: e3a01000 mov r1, #0 300064d4: e1a02004 mov r2, r4 300064d8: e3a06001 mov r6, #1 300064dc: e1a07001 mov r7, r1
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
300064e0: e59fc0f8 ldr ip, [pc, #248] ; 300065e0 <writev+0x168> 300064e4: ea000000 b 300064ec <writev+0x74>
if ( iov[v].iov_len )
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
300064e8: 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 )
300064ec: e5923000 ldr r3, [r2]
* 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++ ) {
300064f0: 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 )
300064f4: e3530000 cmp r3, #0
300064f8: 0a000029 beq 300065a4 <writev+0x12c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
300064fc: e5920004 ldr r0, [r2, #4]
* 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++ ) {
30006500: e2822008 add r2, r2, #8
if ( iov[v].iov_len )
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
30006504: 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;
30006508: e3500000 cmp r0, #0 3000650c: 13a06000 movne r6, #0
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
30006510: e1570003 cmp r7, r3 30006514: d153000c cmple r3, ip 30006518: d3a07000 movle r7, #0 3000651c: c3a07001 movgt r7, #1
30006520: ca00001f bgt 300065a4 <writev+0x12c>
* 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++ ) {
30006524: e1550001 cmp r5, r1
30006528: caffffee bgt 300064e8 <writev+0x70>
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
3000652c: e3560000 cmp r6, #0
30006530: 1a00001f bne 300065b4 <writev+0x13c>
30006534: e1a07006 mov r7, r6 30006538: ea000003 b 3000654c <writev+0xd4>
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3000653c: e2866001 add r6, r6, #1 30006540: e1550006 cmp r5, r6 30006544: e2844008 add r4, r4, #8
30006548: da000019 ble 300065b4 <writev+0x13c>
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
3000654c: e5942004 ldr r2, [r4, #4] 30006550: e3520000 cmp r2, #0
30006554: 0afffff8 beq 3000653c <writev+0xc4>
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
30006558: e5941000 ldr r1, [r4] 3000655c: e5983020 ldr r3, [r8, #32] 30006560: e1a00008 mov r0, r8 30006564: e1a0e00f mov lr, pc 30006568: e593f00c ldr pc, [r3, #12]
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
3000656c: e3500000 cmp r0, #0
30006570: ba000016 blt 300065d0 <writev+0x158>
return -1;
if ( bytes > 0 ) {
30006574: 0a000006 beq 30006594 <writev+0x11c>
iop->offset += bytes;
30006578: e288300c add r3, r8, #12
3000657c: e893000c ldm r3, {r2, r3}
30006580: e0922000 adds r2, r2, r0
30006584: e0a33fc0 adc r3, r3, r0, asr #31
30006588: e588200c str r2, [r8, #12]
3000658c: e5883010 str r3, [r8, #16]
total += bytes;
30006590: e0877000 add r7, r7, r0
}
if (bytes != iov[ v ].iov_len)
30006594: e5943004 ldr r3, [r4, #4] 30006598: e1500003 cmp r0, r3
3000659c: 0affffe6 beq 3000653c <writev+0xc4>
300065a0: ea000003 b 300065b4 <writev+0x13c> <== 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 );
300065a4: eb0021bd bl 3000eca0 <__errno> 300065a8: e3a03016 mov r3, #22 300065ac: e5803000 str r3, [r0] 300065b0: e3e07000 mvn r7, #0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
300065b4: e1a00007 mov r0, r7
300065b8: 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 );
300065bc: eb0021b7 bl 3000eca0 <__errno> 300065c0: e3a03009 mov r3, #9 300065c4: e5803000 str r3, [r0] 300065c8: e3e07000 mvn r7, #0 300065cc: eafffff8 b 300065b4 <writev+0x13c>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
300065d0: e3e07000 mvn r7, #0 <== NOT EXECUTED 300065d4: eafffff6 b 300065b4 <writev+0x13c> <== NOT EXECUTED