RTEMS 4.11Annotated Report
Mon Mar 21 01:35:17 2011
0800b7d8 <IMFS_Set_handlers>:
#define MAXSYMLINK 5
int IMFS_Set_handlers(
rtems_filesystem_location_info_t *loc
)
{
800b7d8: 37 9c ff f0 addi sp,sp,-16
800b7dc: 5b 8b 00 10 sw (sp+16),r11
800b7e0: 5b 8c 00 0c sw (sp+12),r12
800b7e4: 5b 8d 00 08 sw (sp+8),r13
800b7e8: 5b 9d 00 04 sw (sp+4),ra
800b7ec: b8 20 58 00 mv r11,r1
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
800b7f0: 28 21 00 10 lw r1,(r1+16)
switch( node->type ) {
800b7f4: 34 02 00 06 mvi r2,6
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
800b7f8: 28 2c 00 34 lw r12,(r1+52)
switch( node->type ) {
800b7fc: 29 61 00 00 lw r1,(r11+0)
800b800: 28 21 00 4c lw r1,(r1+76)
800b804: 34 21 ff ff addi r1,r1,-1
800b808: 54 22 00 14 bgu r1,r2,800b858 <IMFS_Set_handlers+0x80> <== NEVER TAKEN
800b80c: 78 0d 08 01 mvhi r13,0x801
800b810: 34 02 00 02 mvi r2,2
800b814: f8 00 2d bf calli 8016f10 <__ashlsi3>
800b818: 39 ad 83 2c ori r13,r13,0x832c
800b81c: b5 a1 08 00 add r1,r13,r1
800b820: 28 21 00 00 lw r1,(r1+0)
800b824: c0 20 00 00 b r1
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
800b828: 29 81 00 0c lw r1,(r12+12)
800b82c: e0 00 00 0a bi 800b854 <IMFS_Set_handlers+0x7c>
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
800b830: 78 01 08 01 mvhi r1,0x801
800b834: 38 21 83 58 ori r1,r1,0x8358
800b838: e0 00 00 07 bi 800b854 <IMFS_Set_handlers+0x7c>
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
800b83c: 78 01 08 01 mvhi r1,0x801
800b840: 38 21 83 c8 ori r1,r1,0x83c8
800b844: e0 00 00 04 bi 800b854 <IMFS_Set_handlers+0x7c>
break;
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
800b848: 29 81 00 08 lw r1,(r12+8)
800b84c: e0 00 00 02 bi 800b854 <IMFS_Set_handlers+0x7c>
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
800b850: 29 81 00 10 lw r1,(r12+16)
800b854: 59 61 00 08 sw (r11+8),r1
break;
}
return 0;
}
800b858: 34 01 00 00 mvi r1,0
800b85c: 2b 9d 00 04 lw ra,(sp+4)
800b860: 2b 8b 00 10 lw r11,(sp+16)
800b864: 2b 8c 00 0c lw r12,(sp+12)
800b868: 2b 8d 00 08 lw r13,(sp+8)
800b86c: 37 9c 00 10 addi sp,sp,16
800b870: c3 a0 00 00 ret
0800b63c <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
800b63c: 37 9c ff e8 addi sp,sp,-24
800b640: 5b 8b 00 18 sw (sp+24),r11
800b644: 5b 8c 00 14 sw (sp+20),r12
800b648: 5b 8d 00 10 sw (sp+16),r13
800b64c: 5b 8e 00 0c sw (sp+12),r14
800b650: 5b 8f 00 08 sw (sp+8),r15
800b654: 5b 9d 00 04 sw (sp+4),ra
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
return NULL;
800b658: 34 0b 00 00 mvi r11,0
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
800b65c: b8 40 60 00 mv r12,r2
800b660: b8 a0 68 00 mv r13,r5
800b664: b8 60 10 00 mv r2,r3
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
800b668: 44 20 00 43 be r1,r0,800b774 <IMFS_create_node+0x138> <== NEVER TAKEN
return NULL;
parent = parent_loc->node_access;
800b66c: 28 2f 00 00 lw r15,(r1+0)
fs_info = parent_loc->mt_entry->fs_info;
800b670: 28 21 00 10 lw r1,(r1+16)
800b674: 28 2e 00 34 lw r14,(r1+52)
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
800b678: 34 01 00 07 mvi r1,7
800b67c: 5d 81 00 05 bne r12,r1,800b690 <IMFS_create_node+0x54>
800b680: 29 c1 00 10 lw r1,(r14+16)
800b684: 78 05 08 01 mvhi r5,0x801
800b688: 38 a5 82 c4 ori r5,r5,0x82c4
800b68c: 44 25 00 3a be r1,r5,800b774 <IMFS_create_node+0x138>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
800b690: 78 05 08 01 mvhi r5,0x801
800b694: 38 a5 91 34 ori r5,r5,0x9134
800b698: 28 a1 00 00 lw r1,(r5+0)
800b69c: 28 23 00 2c lw r3,(r1+44)
800b6a0: b9 80 08 00 mv r1,r12
800b6a4: a4 60 18 00 not r3,r3
800b6a8: a0 83 18 00 and r3,r4,r3
800b6ac: fb ff ff bb calli 800b598 <IMFS_allocate_node>
800b6b0: b8 20 58 00 mv r11,r1
if ( !node )
800b6b4: 44 20 00 30 be r1,r0,800b774 <IMFS_create_node+0x138>
return NULL;
/*
* Set the type specific information
*/
if ( type == IMFS_DIRECTORY ) {
800b6b8: 34 01 00 01 mvi r1,1
800b6bc: 5d 81 00 07 bne r12,r1,800b6d8 <IMFS_create_node+0x9c>
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 );
800b6c0: 35 61 00 54 addi r1,r11,84
head->next = tail;
800b6c4: 59 61 00 50 sw (r11+80),r1
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
800b6c8: 35 61 00 50 addi r1,r11,80
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
800b6cc: 59 60 00 54 sw (r11+84),r0
tail->previous = head;
800b6d0: 59 61 00 58 sw (r11+88),r1
800b6d4: e0 00 00 20 bi 800b754 <IMFS_create_node+0x118>
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
800b6d8: 34 01 00 03 mvi r1,3
800b6dc: 45 81 00 03 be r12,r1,800b6e8 <IMFS_create_node+0xac>
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
800b6e0: 34 01 00 04 mvi r1,4
800b6e4: 5d 81 00 04 bne r12,r1,800b6f4 <IMFS_create_node+0xb8>
node->info.sym_link.name = info->sym_link.name;
800b6e8: 29 a1 00 00 lw r1,(r13+0)
800b6ec: 59 61 00 50 sw (r11+80),r1
800b6f0: e0 00 00 19 bi 800b754 <IMFS_create_node+0x118>
} else if ( type == IMFS_DEVICE ) {
800b6f4: 34 01 00 02 mvi r1,2
800b6f8: 5d 81 00 06 bne r12,r1,800b710 <IMFS_create_node+0xd4>
node->info.device.major = info->device.major;
800b6fc: 29 a1 00 00 lw r1,(r13+0)
800b700: 59 61 00 50 sw (r11+80),r1
node->info.device.minor = info->device.minor;
800b704: 29 a1 00 04 lw r1,(r13+4)
800b708: 59 61 00 54 sw (r11+84),r1
800b70c: e0 00 00 12 bi 800b754 <IMFS_create_node+0x118>
} else if ( type == IMFS_LINEAR_FILE ) {
800b710: 34 01 00 06 mvi r1,6
800b714: 5d 81 00 05 bne r12,r1,800b728 <IMFS_create_node+0xec>
node->info.linearfile.size = 0;
800b718: 59 60 00 50 sw (r11+80),r0
800b71c: 59 60 00 54 sw (r11+84),r0
node->info.linearfile.direct = 0;
800b720: 59 60 00 58 sw (r11+88),r0
800b724: e0 00 00 0c bi 800b754 <IMFS_create_node+0x118>
} else if ( type == IMFS_MEMORY_FILE ) {
800b728: 34 01 00 05 mvi r1,5
800b72c: 5d 81 00 07 bne r12,r1,800b748 <IMFS_create_node+0x10c>
node->info.file.size = 0;
800b730: 59 60 00 50 sw (r11+80),r0
800b734: 59 60 00 54 sw (r11+84),r0
node->info.file.indirect = 0;
800b738: 59 60 00 58 sw (r11+88),r0
node->info.file.doubly_indirect = 0;
800b73c: 59 60 00 5c sw (r11+92),r0
node->info.file.triply_indirect = 0;
800b740: 59 60 00 60 sw (r11+96),r0
800b744: e0 00 00 04 bi 800b754 <IMFS_create_node+0x118>
} else if ( type == IMFS_FIFO ) {
800b748: 34 01 00 07 mvi r1,7
800b74c: 5d 81 00 02 bne r12,r1,800b754 <IMFS_create_node+0x118> <== NEVER TAKEN
node->info.fifo.pipe = NULL;
800b750: 59 60 00 50 sw (r11+80),r0
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
node->st_ino = ++fs_info->ino_count;
800b754: 29 c1 00 04 lw r1,(r14+4)
}
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
800b758: 59 6f 00 08 sw (r11+8),r15
800b75c: b9 60 10 00 mv r2,r11
node->st_ino = ++fs_info->ino_count;
800b760: 34 21 00 01 addi r1,r1,1
800b764: 59 c1 00 04 sw (r14+4),r1
800b768: 59 61 00 38 sw (r11+56),r1
800b76c: 35 e1 00 50 addi r1,r15,80
800b770: fb ff e4 f6 calli 8004b48 <_Chain_Append>
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
800b774: b9 60 08 00 mv r1,r11
800b778: 2b 9d 00 04 lw ra,(sp+4)
800b77c: 2b 8b 00 18 lw r11,(sp+24)
800b780: 2b 8c 00 14 lw r12,(sp+20)
800b784: 2b 8d 00 10 lw r13,(sp+16)
800b788: 2b 8e 00 0c lw r14,(sp+12)
800b78c: 2b 8f 00 08 lw r15,(sp+8)
800b790: 37 9c 00 18 addi sp,sp,24
800b794: c3 a0 00 00 ret
0800b968 <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
800b968: 37 9c ff 84 addi sp,sp,-124
800b96c: 5b 8b 00 40 sw (sp+64),r11
800b970: 5b 8c 00 3c sw (sp+60),r12
800b974: 5b 8d 00 38 sw (sp+56),r13
800b978: 5b 8e 00 34 sw (sp+52),r14
800b97c: 5b 8f 00 30 sw (sp+48),r15
800b980: 5b 90 00 2c sw (sp+44),r16
800b984: 5b 91 00 28 sw (sp+40),r17
800b988: 5b 92 00 24 sw (sp+36),r18
800b98c: 5b 93 00 20 sw (sp+32),r19
800b990: 5b 94 00 1c sw (sp+28),r20
800b994: 5b 95 00 18 sw (sp+24),r21
800b998: 5b 96 00 14 sw (sp+20),r22
800b99c: 5b 97 00 10 sw (sp+16),r23
800b9a0: 5b 98 00 0c sw (sp+12),r24
800b9a4: 5b 99 00 08 sw (sp+8),r25
800b9a8: 5b 9d 00 04 sw (sp+4),ra
800b9ac: b8 20 90 00 mv r18,r1
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 ) ) {
800b9b0: 34 01 ff f8 mvi r1,-8
800b9b4: a0 61 08 00 and r1,r3,r1
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
800b9b8: b8 40 78 00 mv r15,r2
800b9bc: b8 60 88 00 mv r17,r3
800b9c0: b8 80 58 00 mv r11,r4
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 ) ) {
800b9c4: 44 20 00 04 be r1,r0,800b9d4 <IMFS_eval_path+0x6c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
800b9c8: f8 00 16 aa calli 8011470 <__errno> <== NOT EXECUTED
800b9cc: 34 02 00 05 mvi r2,5 <== NOT EXECUTED
800b9d0: e0 00 00 91 bi 800bc14 <IMFS_eval_path+0x2ac> <== NOT EXECUTED
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
800b9d4: 78 13 08 01 mvhi r19,0x801
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
800b9d8: 28 8c 00 00 lw r12,(r4+0)
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
int i = 0;
int len;
IMFS_token_types type = IMFS_CURRENT_DIR;
800b9dc: 34 0e 00 01 mvi r14,1
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
int i = 0;
800b9e0: 34 10 00 00 mvi r16,0
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
800b9e4: 37 96 00 44 addi r22,sp,68
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
800b9e8: 34 15 00 01 mvi r21,1
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
800b9ec: 34 19 00 03 mvi r25,3
* It would be a design error if we evaluated the link and
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
800b9f0: 34 14 00 04 mvi r20,4
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
if ( result == -1 )
800b9f4: 34 18 ff ff mvi r24,-1
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
800b9f8: 34 17 00 02 mvi r23,2
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
800b9fc: 3a 73 91 34 ori r19,r19,0x9134
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
800ba00: e0 00 00 5a bi 800bb68 <IMFS_eval_path+0x200>
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
800ba04: b6 50 08 00 add r1,r18,r16
800ba08: b9 e0 10 00 mv r2,r15
800ba0c: ba c0 18 00 mv r3,r22
800ba10: 37 84 00 7c addi r4,sp,124
800ba14: f8 00 02 11 calli 800c258 <IMFS_get_token>
800ba18: b8 20 70 00 mv r14,r1
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
800ba1c: 29 61 00 00 lw r1,(r11+0)
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
800ba20: 2b 8d 00 7c lw r13,(sp+124)
i += len;
if ( !pathloc->node_access )
800ba24: 44 20 00 49 be r1,r0,800bb48 <IMFS_eval_path+0x1e0> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
800ba28: 45 c0 00 07 be r14,r0,800ba44 <IMFS_eval_path+0xdc>
if ( node->type == IMFS_DIRECTORY )
800ba2c: 29 81 00 4c lw r1,(r12+76)
800ba30: 5c 35 00 05 bne r1,r21,800ba44 <IMFS_eval_path+0xdc>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
800ba34: b9 60 08 00 mv r1,r11
800ba38: 34 02 00 01 mvi r2,1
800ba3c: fb ff ff 8e calli 800b874 <IMFS_evaluate_permission>
800ba40: 44 20 00 73 be r1,r0,800bc0c <IMFS_eval_path+0x2a4>
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
800ba44: c9 ed 78 00 sub r15,r15,r13
i += len;
800ba48: b6 0d 80 00 add r16,r16,r13
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;
800ba4c: 29 6c 00 00 lw r12,(r11+0)
switch( type ) {
800ba50: 45 d9 00 14 be r14,r25,800baa0 <IMFS_eval_path+0x138>
800ba54: 45 d4 00 42 be r14,r20,800bb5c <IMFS_eval_path+0x1f4>
800ba58: 5d d7 00 44 bne r14,r23,800bb68 <IMFS_eval_path+0x200>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
800ba5c: 2a 61 00 00 lw r1,(r19+0)
800ba60: 28 21 00 18 lw r1,(r1+24)
800ba64: 45 81 00 41 be r12,r1,800bb68 <IMFS_eval_path+0x200>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access) {
800ba68: 29 64 00 10 lw r4,(r11+16)
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
800ba6c: 28 81 00 1c lw r1,(r4+28)
800ba70: 5d 81 00 07 bne r12,r1,800ba8c <IMFS_eval_path+0x124>
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
newloc = pathloc->mt_entry->mt_point_node;
800ba74: 28 85 00 08 lw r5,(r4+8)
800ba78: 28 82 00 0c lw r2,(r4+12)
800ba7c: 28 81 00 10 lw r1,(r4+16)
800ba80: 28 83 00 14 lw r3,(r4+20)
800ba84: 28 84 00 18 lw r4,(r4+24)
800ba88: e0 00 00 46 bi 800bba0 <IMFS_eval_path+0x238>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
800ba8c: 29 8c 00 08 lw r12,(r12+8)
800ba90: 5d 80 00 31 bne r12,r0,800bb54 <IMFS_eval_path+0x1ec>
rtems_set_errno_and_return_minus_one( ENOENT );
800ba94: f8 00 16 77 calli 8011470 <__errno>
800ba98: 58 2e 00 00 sw (r1+0),r14
800ba9c: e0 00 00 5f bi 800bc18 <IMFS_eval_path+0x2b0>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
800baa0: 29 81 00 4c lw r1,(r12+76)
800baa4: 5c 2e 00 06 bne r1,r14,800babc <IMFS_eval_path+0x154>
IMFS_evaluate_hard_link( pathloc, 0 );
800baa8: b9 60 08 00 mv r1,r11
800baac: 34 02 00 00 mvi r2,0
800bab0: fb ff ff 97 calli 800b90c <IMFS_evaluate_hard_link>
node = pathloc->node_access;
800bab4: 29 6c 00 00 lw r12,(r11+0)
800bab8: e0 00 00 08 bi 800bad8 <IMFS_eval_path+0x170>
* It would be a design error if we evaluated the link and
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
800babc: 5c 34 00 07 bne r1,r20,800bad8 <IMFS_eval_path+0x170>
result = IMFS_evaluate_sym_link( pathloc, 0 );
800bac0: b9 60 08 00 mv r1,r11
800bac4: 34 02 00 00 mvi r2,0
800bac8: f8 00 00 68 calli 800bc68 <IMFS_evaluate_sym_link>
800bacc: b8 20 68 00 mv r13,r1
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
800bad0: 29 6c 00 00 lw r12,(r11+0)
if ( result == -1 )
800bad4: 44 38 00 52 be r1,r24,800bc1c <IMFS_eval_path+0x2b4> <== NEVER TAKEN
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
800bad8: 29 81 00 4c lw r1,(r12+76)
800badc: 44 35 00 04 be r1,r21,800baec <IMFS_eval_path+0x184>
rtems_set_errno_and_return_minus_one( ENOTDIR );
800bae0: f8 00 16 64 calli 8011470 <__errno>
800bae4: 34 02 00 14 mvi r2,20
800bae8: e0 00 00 4b bi 800bc14 <IMFS_eval_path+0x2ac>
/*
* 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 ) {
800baec: 29 8d 00 5c lw r13,(r12+92)
800baf0: 45 a0 00 11 be r13,r0,800bb34 <IMFS_eval_path+0x1cc>
newloc = node->info.directory.mt_fs->mt_fs_root;
800baf4: 29 a4 00 1c lw r4,(r13+28)
800baf8: 29 a2 00 20 lw r2,(r13+32)
800bafc: 29 a1 00 24 lw r1,(r13+36)
800bb00: 29 a3 00 28 lw r3,(r13+40)
800bb04: 29 a5 00 2c lw r5,(r13+44)
800bb08: 5b 84 00 68 sw (sp+104),r4
800bb0c: 5b 82 00 6c sw (sp+108),r2
800bb10: 5b 81 00 70 sw (sp+112),r1
800bb14: 5b 83 00 74 sw (sp+116),r3
800bb18: 5b 85 00 78 sw (sp+120),r5
*pathloc = newloc;
800bb1c: 59 64 00 00 sw (r11+0),r4
800bb20: 59 62 00 04 sw (r11+4),r2
800bb24: 59 61 00 08 sw (r11+8),r1
800bb28: 59 63 00 0c sw (r11+12),r3
800bb2c: 59 65 00 10 sw (r11+16),r5
800bb30: e0 00 00 26 bi 800bbc8 <IMFS_eval_path+0x260>
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
800bb34: b9 80 08 00 mv r1,r12
800bb38: ba c0 10 00 mv r2,r22
800bb3c: f8 00 01 a1 calli 800c1c0 <IMFS_find_match_in_dir>
800bb40: b8 20 60 00 mv r12,r1
if ( !node )
800bb44: 5c 2d 00 04 bne r1,r13,800bb54 <IMFS_eval_path+0x1ec>
rtems_set_errno_and_return_minus_one( ENOENT );
800bb48: f8 00 16 4a calli 8011470 <__errno>
800bb4c: 34 02 00 02 mvi r2,2
800bb50: e0 00 00 31 bi 800bc14 <IMFS_eval_path+0x2ac>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
800bb54: 59 6c 00 00 sw (r11+0),r12
800bb58: e0 00 00 04 bi 800bb68 <IMFS_eval_path+0x200>
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
800bb5c: f8 00 16 45 calli 8011470 <__errno>
800bb60: 34 02 00 5b mvi r2,91
800bb64: e0 00 00 2c bi 800bc14 <IMFS_eval_path+0x2ac>
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
800bb68: 7d c1 00 04 cmpnei r1,r14,4
800bb6c: 7d ce 00 00 cmpnei r14,r14,0
800bb70: a0 2e 70 00 and r14,r1,r14
800bb74: 5d c0 ff a4 bne r14,r0,800ba04 <IMFS_eval_path+0x9c>
* 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 ) {
800bb78: 29 82 00 4c lw r2,(r12+76)
800bb7c: 34 01 00 01 mvi r1,1
800bb80: 5c 41 00 1c bne r2,r1,800bbf0 <IMFS_eval_path+0x288>
if ( node->info.directory.mt_fs != NULL ) {
800bb84: 29 84 00 5c lw r4,(r12+92)
800bb88: 44 80 00 1a be r4,r0,800bbf0 <IMFS_eval_path+0x288>
newloc = node->info.directory.mt_fs->mt_fs_root;
800bb8c: 28 85 00 1c lw r5,(r4+28)
800bb90: 28 82 00 20 lw r2,(r4+32)
800bb94: 28 81 00 24 lw r1,(r4+36)
800bb98: 28 83 00 28 lw r3,(r4+40)
800bb9c: 28 84 00 2c lw r4,(r4+44)
800bba0: 5b 85 00 68 sw (sp+104),r5
800bba4: 5b 82 00 6c sw (sp+108),r2
800bba8: 5b 81 00 70 sw (sp+112),r1
800bbac: 5b 83 00 74 sw (sp+116),r3
800bbb0: 5b 84 00 78 sw (sp+120),r4
*pathloc = newloc;
800bbb4: 59 65 00 00 sw (r11+0),r5
800bbb8: 59 62 00 04 sw (r11+4),r2
800bbbc: 59 61 00 08 sw (r11+8),r1
800bbc0: 59 63 00 0c sw (r11+12),r3
800bbc4: 59 64 00 10 sw (r11+16),r4
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
800bbc8: 2b 82 00 7c lw r2,(sp+124)
800bbcc: 28 65 00 00 lw r5,(r3+0)
800bbd0: b9 60 20 00 mv r4,r11
800bbd4: ca 02 08 00 sub r1,r16,r2
800bbd8: b6 41 08 00 add r1,r18,r1
800bbdc: b5 e2 10 00 add r2,r15,r2
800bbe0: ba 20 18 00 mv r3,r17
800bbe4: d8 a0 00 00 call r5
800bbe8: b8 20 68 00 mv r13,r1
800bbec: e0 00 00 0c bi 800bc1c <IMFS_eval_path+0x2b4>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
800bbf0: b9 60 08 00 mv r1,r11
800bbf4: fb ff fe f9 calli 800b7d8 <IMFS_Set_handlers>
800bbf8: b8 20 68 00 mv r13,r1
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
800bbfc: ba 20 10 00 mv r2,r17
800bc00: b9 60 08 00 mv r1,r11
800bc04: fb ff ff 1c calli 800b874 <IMFS_evaluate_permission>
800bc08: 5c 20 00 05 bne r1,r0,800bc1c <IMFS_eval_path+0x2b4>
rtems_set_errno_and_return_minus_one( EACCES );
800bc0c: f8 00 16 19 calli 8011470 <__errno>
800bc10: 34 02 00 0d mvi r2,13
800bc14: 58 22 00 00 sw (r1+0),r2
800bc18: 34 0d ff ff mvi r13,-1
return result;
}
800bc1c: b9 a0 08 00 mv r1,r13
800bc20: 2b 9d 00 04 lw ra,(sp+4)
800bc24: 2b 8b 00 40 lw r11,(sp+64)
800bc28: 2b 8c 00 3c lw r12,(sp+60)
800bc2c: 2b 8d 00 38 lw r13,(sp+56)
800bc30: 2b 8e 00 34 lw r14,(sp+52)
800bc34: 2b 8f 00 30 lw r15,(sp+48)
800bc38: 2b 90 00 2c lw r16,(sp+44)
800bc3c: 2b 91 00 28 lw r17,(sp+40)
800bc40: 2b 92 00 24 lw r18,(sp+36)
800bc44: 2b 93 00 20 lw r19,(sp+32)
800bc48: 2b 94 00 1c lw r20,(sp+28)
800bc4c: 2b 95 00 18 lw r21,(sp+24)
800bc50: 2b 96 00 14 lw r22,(sp+20)
800bc54: 2b 97 00 10 lw r23,(sp+16)
800bc58: 2b 98 00 0c lw r24,(sp+12)
800bc5c: 2b 99 00 08 lw r25,(sp+8)
800bc60: 37 9c 00 7c addi sp,sp,124
800bc64: c3 a0 00 00 ret
0800be04 <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 */
)
{
800be04: 37 9c ff 84 addi sp,sp,-124
800be08: 5b 8b 00 40 sw (sp+64),r11
800be0c: 5b 8c 00 3c sw (sp+60),r12
800be10: 5b 8d 00 38 sw (sp+56),r13
800be14: 5b 8e 00 34 sw (sp+52),r14
800be18: 5b 8f 00 30 sw (sp+48),r15
800be1c: 5b 90 00 2c sw (sp+44),r16
800be20: 5b 91 00 28 sw (sp+40),r17
800be24: 5b 92 00 24 sw (sp+36),r18
800be28: 5b 93 00 20 sw (sp+32),r19
800be2c: 5b 94 00 1c sw (sp+28),r20
800be30: 5b 95 00 18 sw (sp+24),r21
800be34: 5b 96 00 14 sw (sp+20),r22
800be38: 5b 97 00 10 sw (sp+16),r23
800be3c: 5b 98 00 0c sw (sp+12),r24
800be40: 5b 99 00 08 sw (sp+8),r25
800be44: 5b 9d 00 04 sw (sp+4),ra
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
800be48: 78 10 08 01 mvhi r16,0x801
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
800be4c: b8 20 78 00 mv r15,r1
800be50: b8 40 58 00 mv r11,r2
800be54: b8 60 88 00 mv r17,r3
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
800be58: 28 4c 00 00 lw r12,(r2+0)
/*
* Get the path length.
*/
pathlen = strlen( path );
800be5c: f8 00 19 e6 calli 80125f4 <strlen>
800be60: b8 20 90 00 mv r18,r1
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
int i = 0;
800be64: 34 0e 00 00 mvi r14,0
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
800be68: 37 98 00 44 addi r24,sp,68
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
800be6c: 34 17 00 01 mvi r23,1
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
800be70: 34 16 00 02 mvi r22,2
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
800be74: 3a 10 91 34 ori r16,r16,0x9134
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
800be78: 34 15 00 03 mvi r21,3
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
800be7c: 34 14 00 04 mvi r20,4
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
800be80: 34 13 ff ff mvi r19,-1
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
800be84: ba 40 10 00 mv r2,r18
800be88: b5 ee 08 00 add r1,r15,r14
800be8c: bb 00 18 00 mv r3,r24
800be90: 37 84 00 7c addi r4,sp,124
800be94: f8 00 00 f1 calli 800c258 <IMFS_get_token>
800be98: b8 20 68 00 mv r13,r1
pathlen -= len;
800be9c: 2b 99 00 7c lw r25,(sp+124)
i += len;
if ( !pathloc->node_access )
800bea0: 29 61 00 00 lw r1,(r11+0)
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
800bea4: ca 59 90 00 sub r18,r18,r25
i += len;
if ( !pathloc->node_access )
800bea8: 44 20 00 68 be r1,r0,800c048 <IMFS_evaluate_for_make+0x244><== NEVER TAKEN
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
800beac: 45 a0 00 07 be r13,r0,800bec8 <IMFS_evaluate_for_make+0xc4>
if ( node->type == IMFS_DIRECTORY )
800beb0: 29 81 00 4c lw r1,(r12+76)
800beb4: 5c 37 00 05 bne r1,r23,800bec8 <IMFS_evaluate_for_make+0xc4>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
800beb8: b9 60 08 00 mv r1,r11
800bebc: 34 02 00 01 mvi r2,1
800bec0: fb ff fe 6d calli 800b874 <IMFS_evaluate_permission>
800bec4: 44 20 00 74 be r1,r0,800c094 <IMFS_evaluate_for_make+0x290>
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
800bec8: b5 d9 70 00 add r14,r14,r25
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;
800becc: 29 6c 00 00 lw r12,(r11+0)
switch( type ) {
800bed0: 45 b6 00 07 be r13,r22,800beec <IMFS_evaluate_for_make+0xe8>
800bed4: 55 b6 00 03 bgu r13,r22,800bee0 <IMFS_evaluate_for_make+0xdc>
800bed8: 5d a0 ff eb bne r13,r0,800be84 <IMFS_evaluate_for_make+0x80>
800bedc: e0 00 00 4c bi 800c00c <IMFS_evaluate_for_make+0x208>
800bee0: 45 b5 00 1e be r13,r21,800bf58 <IMFS_evaluate_for_make+0x154>
800bee4: 5d b4 ff e8 bne r13,r20,800be84 <IMFS_evaluate_for_make+0x80><== NEVER TAKEN
800bee8: e0 00 00 4c bi 800c018 <IMFS_evaluate_for_make+0x214>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
800beec: 2a 01 00 00 lw r1,(r16+0)
800bef0: 28 21 00 18 lw r1,(r1+24)
800bef4: 45 81 ff e4 be r12,r1,800be84 <IMFS_evaluate_for_make+0x80>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
800bef8: 29 64 00 10 lw r4,(r11+16)
800befc: 28 81 00 1c lw r1,(r4+28)
800bf00: 5d 81 00 11 bne r12,r1,800bf44 <IMFS_evaluate_for_make+0x140>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
800bf04: 28 85 00 08 lw r5,(r4+8)
800bf08: 28 83 00 0c lw r3,(r4+12)
800bf0c: 28 81 00 10 lw r1,(r4+16)
800bf10: 28 82 00 14 lw r2,(r4+20)
800bf14: 28 84 00 18 lw r4,(r4+24)
800bf18: 5b 85 00 68 sw (sp+104),r5
800bf1c: 5b 83 00 6c sw (sp+108),r3
800bf20: 5b 81 00 70 sw (sp+112),r1
800bf24: 5b 82 00 74 sw (sp+116),r2
800bf28: 5b 84 00 78 sw (sp+120),r4
*pathloc = newloc;
800bf2c: 59 65 00 00 sw (r11+0),r5
800bf30: 59 63 00 04 sw (r11+4),r3
800bf34: 59 61 00 08 sw (r11+8),r1
800bf38: 59 62 00 0c sw (r11+12),r2
800bf3c: 59 64 00 10 sw (r11+16),r4
800bf40: e0 00 00 23 bi 800bfcc <IMFS_evaluate_for_make+0x1c8>
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
800bf44: 29 8c 00 08 lw r12,(r12+8)
800bf48: 5d 80 00 2f bne r12,r0,800c004 <IMFS_evaluate_for_make+0x200>
rtems_set_errno_and_return_minus_one( ENOENT );
800bf4c: f8 00 15 49 calli 8011470 <__errno>
800bf50: 58 2d 00 00 sw (r1+0),r13
800bf54: e0 00 00 53 bi 800c0a0 <IMFS_evaluate_for_make+0x29c>
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
800bf58: 29 81 00 4c lw r1,(r12+76)
800bf5c: 44 35 00 02 be r1,r21,800bf64 <IMFS_evaluate_for_make+0x160>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
800bf60: 5c 34 00 06 bne r1,r20,800bf78 <IMFS_evaluate_for_make+0x174>
result = IMFS_evaluate_link( pathloc, 0 );
800bf64: b9 60 08 00 mv r1,r11
800bf68: 34 02 00 00 mvi r2,0
800bf6c: fb ff ff 69 calli 800bd10 <IMFS_evaluate_link>
800bf70: b8 20 60 00 mv r12,r1
if ( result == -1 )
800bf74: 44 33 00 4c be r1,r19,800c0a4 <IMFS_evaluate_for_make+0x2a0><== NEVER TAKEN
return -1;
}
node = pathloc->node_access;
800bf78: 29 64 00 00 lw r4,(r11+0)
if ( !node )
800bf7c: 44 80 00 3f be r4,r0,800c078 <IMFS_evaluate_for_make+0x274><== NEVER TAKEN
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
800bf80: 28 81 00 4c lw r1,(r4+76)
800bf84: 5c 37 00 3d bne r1,r23,800c078 <IMFS_evaluate_for_make+0x274>
/*
* 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 ) {
800bf88: 28 8d 00 5c lw r13,(r4+92)
800bf8c: 45 a0 00 19 be r13,r0,800bff0 <IMFS_evaluate_for_make+0x1ec>
newloc = node->info.directory.mt_fs->mt_fs_root;
800bf90: 29 a4 00 1c lw r4,(r13+28)
800bf94: 29 a3 00 20 lw r3,(r13+32)
800bf98: 29 a1 00 24 lw r1,(r13+36)
800bf9c: 29 a2 00 28 lw r2,(r13+40)
800bfa0: 29 a5 00 2c lw r5,(r13+44)
800bfa4: 5b 84 00 68 sw (sp+104),r4
800bfa8: 5b 83 00 6c sw (sp+108),r3
800bfac: 5b 81 00 70 sw (sp+112),r1
800bfb0: 5b 82 00 74 sw (sp+116),r2
800bfb4: 5b 85 00 78 sw (sp+120),r5
*pathloc = newloc;
800bfb8: 59 64 00 00 sw (r11+0),r4
800bfbc: 59 63 00 04 sw (r11+4),r3
800bfc0: 59 61 00 08 sw (r11+8),r1
800bfc4: 59 62 00 0c sw (r11+12),r2
800bfc8: 59 65 00 10 sw (r11+16),r5
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
800bfcc: 2b 81 00 7c lw r1,(sp+124)
800bfd0: 28 44 00 04 lw r4,(r2+4)
800bfd4: ba 20 18 00 mv r3,r17
800bfd8: c9 c1 70 00 sub r14,r14,r1
800bfdc: b5 ee 08 00 add r1,r15,r14
800bfe0: b9 60 10 00 mv r2,r11
800bfe4: d8 80 00 00 call r4
800bfe8: b8 20 60 00 mv r12,r1
800bfec: e0 00 00 2e bi 800c0a4 <IMFS_evaluate_for_make+0x2a0>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
800bff0: b8 80 08 00 mv r1,r4
800bff4: bb 00 10 00 mv r2,r24
800bff8: f8 00 00 72 calli 800c1c0 <IMFS_find_match_in_dir>
800bffc: b8 20 60 00 mv r12,r1
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
800c000: 44 2d 00 09 be r1,r13,800c024 <IMFS_evaluate_for_make+0x220>
done = true;
else
pathloc->node_access = node;
800c004: 59 6c 00 00 sw (r11+0),r12
800c008: e3 ff ff 9f bi 800be84 <IMFS_evaluate_for_make+0x80>
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
800c00c: f8 00 15 19 calli 8011470 <__errno>
800c010: 34 02 00 11 mvi r2,17
800c014: e0 00 00 22 bi 800c09c <IMFS_evaluate_for_make+0x298>
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
800c018: f8 00 15 16 calli 8011470 <__errno>
800c01c: 34 02 00 5b mvi r2,91
800c020: e0 00 00 1f bi 800c09c <IMFS_evaluate_for_make+0x298>
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
800c024: 2b 81 00 7c lw r1,(sp+124)
800c028: c9 c1 08 00 sub r1,r14,r1
800c02c: b5 e1 08 00 add r1,r15,r1
800c030: 5a 21 00 00 sw (r17+0),r1
* pathloc is returned with a pointer to the parent of the new node.
* name is returned with a pointer to the first character in the
* new node name. The parent node is verified to be a directory.
*/
int IMFS_evaluate_for_make(
800c034: b5 ee 70 00 add r14,r15,r14
/*
* 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++) {
800c038: e0 00 00 07 bi 800c054 <IMFS_evaluate_for_make+0x250>
if ( !IMFS_is_separator( path[ i ] ) )
800c03c: fb ff de 1a calli 80038a4 <rtems_filesystem_is_separator>
800c040: 35 ce 00 01 addi r14,r14,1
800c044: 5c 20 00 04 bne r1,r0,800c054 <IMFS_evaluate_for_make+0x250>
rtems_set_errno_and_return_minus_one( ENOENT );
800c048: f8 00 15 0a calli 8011470 <__errno>
800c04c: 34 02 00 02 mvi r2,2
800c050: e0 00 00 13 bi 800c09c <IMFS_evaluate_for_make+0x298>
/*
* 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++) {
800c054: 41 c1 00 00 lbu r1,(r14+0)
800c058: 5c 20 ff f9 bne r1,r0,800c03c <IMFS_evaluate_for_make+0x238>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
800c05c: b9 60 08 00 mv r1,r11
800c060: fb ff fd de calli 800b7d8 <IMFS_Set_handlers>
800c064: b8 20 60 00 mv r12,r1
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
800c068: 29 61 00 00 lw r1,(r11+0)
800c06c: 28 22 00 4c lw r2,(r1+76)
800c070: 34 01 00 01 mvi r1,1
800c074: 44 41 00 04 be r2,r1,800c084 <IMFS_evaluate_for_make+0x280><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
800c078: f8 00 14 fe calli 8011470 <__errno>
800c07c: 34 02 00 14 mvi r2,20
800c080: e0 00 00 07 bi 800c09c <IMFS_evaluate_for_make+0x298>
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
800c084: b9 60 08 00 mv r1,r11
800c088: 34 02 00 03 mvi r2,3
800c08c: fb ff fd fa calli 800b874 <IMFS_evaluate_permission>
800c090: 5c 20 00 05 bne r1,r0,800c0a4 <IMFS_evaluate_for_make+0x2a0>
rtems_set_errno_and_return_minus_one( EACCES );
800c094: f8 00 14 f7 calli 8011470 <__errno>
800c098: 34 02 00 0d mvi r2,13
800c09c: 58 22 00 00 sw (r1+0),r2
800c0a0: 34 0c ff ff mvi r12,-1
return result;
}
800c0a4: b9 80 08 00 mv r1,r12
800c0a8: 2b 9d 00 04 lw ra,(sp+4)
800c0ac: 2b 8b 00 40 lw r11,(sp+64)
800c0b0: 2b 8c 00 3c lw r12,(sp+60)
800c0b4: 2b 8d 00 38 lw r13,(sp+56)
800c0b8: 2b 8e 00 34 lw r14,(sp+52)
800c0bc: 2b 8f 00 30 lw r15,(sp+48)
800c0c0: 2b 90 00 2c lw r16,(sp+44)
800c0c4: 2b 91 00 28 lw r17,(sp+40)
800c0c8: 2b 92 00 24 lw r18,(sp+36)
800c0cc: 2b 93 00 20 lw r19,(sp+32)
800c0d0: 2b 94 00 1c lw r20,(sp+28)
800c0d4: 2b 95 00 18 lw r21,(sp+24)
800c0d8: 2b 96 00 14 lw r22,(sp+20)
800c0dc: 2b 97 00 10 lw r23,(sp+16)
800c0e0: 2b 98 00 0c lw r24,(sp+12)
800c0e4: 2b 99 00 08 lw r25,(sp+8)
800c0e8: 37 9c 00 7c addi sp,sp,124
800c0ec: c3 a0 00 00 ret
0800b874 <IMFS_evaluate_permission>:
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
800b874: 37 9c ff f0 addi sp,sp,-16
800b878: 5b 8b 00 10 sw (sp+16),r11
800b87c: 5b 8c 00 0c sw (sp+12),r12
800b880: 5b 8d 00 08 sw (sp+8),r13
800b884: 5b 9d 00 04 sw (sp+4),ra
800b888: b8 40 60 00 mv r12,r2
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
800b88c: 34 02 ff f8 mvi r2,-8
800b890: a1 82 10 00 and r2,r12,r2
800b894: 44 40 00 06 be r2,r0,800b8ac <IMFS_evaluate_permission+0x38><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
800b898: f8 00 16 f6 calli 8011470 <__errno> <== NOT EXECUTED
800b89c: 34 02 00 01 mvi r2,1 <== NOT EXECUTED
800b8a0: 58 22 00 00 sw (r1+0),r2 <== NOT EXECUTED
800b8a4: 34 01 ff ff mvi r1,-1 <== NOT EXECUTED
800b8a8: e0 00 00 13 bi 800b8f4 <IMFS_evaluate_permission+0x80> <== NOT EXECUTED
jnode = node->node_access;
800b8ac: 28 2b 00 00 lw r11,(r1+0)
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
800b8b0: f8 00 03 a6 calli 800c748 <geteuid>
800b8b4: b8 20 68 00 mv r13,r1
st_gid = getegid();
800b8b8: f8 00 03 9f calli 800c734 <getegid>
800b8bc: b8 20 10 00 mv r2,r1
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
800b8c0: 2d 61 00 3c lhu r1,(r11+60)
800b8c4: 5c 2d 00 04 bne r1,r13,800b8d4 <IMFS_evaluate_permission+0x60>
flags_to_test <<= 6;
800b8c8: b9 80 08 00 mv r1,r12
800b8cc: 34 02 00 06 mvi r2,6
800b8d0: e0 00 00 05 bi 800b8e4 <IMFS_evaluate_permission+0x70>
else if ( st_gid == jnode->st_gid )
800b8d4: 2d 63 00 3e lhu r3,(r11+62)
800b8d8: b9 80 08 00 mv r1,r12
800b8dc: 5c 62 00 03 bne r3,r2,800b8e8 <IMFS_evaluate_permission+0x74><== NEVER TAKEN
flags_to_test <<= 3;
800b8e0: 34 02 00 03 mvi r2,3
800b8e4: f8 00 2d 8b calli 8016f10 <__ashlsi3>
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
800b8e8: 29 62 00 30 lw r2,(r11+48)
800b8ec: a0 22 10 00 and r2,r1,r2
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 );
800b8f0: e4 41 08 00 cmpe r1,r2,r1
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
800b8f4: 2b 9d 00 04 lw ra,(sp+4)
800b8f8: 2b 8b 00 10 lw r11,(sp+16)
800b8fc: 2b 8c 00 0c lw r12,(sp+12)
800b900: 2b 8d 00 08 lw r13,(sp+8)
800b904: 37 9c 00 10 addi sp,sp,16
800b908: c3 a0 00 00 ret
08001f84 <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
8001f84: 37 9c ff f8 addi sp,sp,-8
8001f88: 5b 8b 00 08 sw (sp+8),r11
8001f8c: 5b 9d 00 04 sw (sp+4),ra
8001f90: b8 20 28 00 mv r5,r1
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
8001f94: 28 21 00 1c lw r1,(r1+28)
8001f98: b8 60 10 00 mv r2,r3
8001f9c: b8 80 18 00 mv r3,r4
8001fa0: 28 21 00 50 lw r1,(r1+80)
8001fa4: b8 a0 20 00 mv r4,r5
8001fa8: f8 00 23 30 calli 800ac68 <pipe_lseek>
8001fac: b8 20 58 00 mv r11,r1
IMFS_FIFO_RETURN(err);
8001fb0: 4c 20 00 07 bge r1,r0,8001fcc <IMFS_fifo_lseek+0x48> <== NEVER TAKEN
8001fb4: f8 00 33 41 calli 800ecb8 <__errno>
8001fb8: c8 0b 58 00 sub r11,r0,r11
8001fbc: 58 2b 00 00 sw (r1+0),r11
8001fc0: 34 01 ff ff mvi r1,-1
8001fc4: 34 0b ff ff mvi r11,-1
8001fc8: e0 00 00 03 bi 8001fd4 <IMFS_fifo_lseek+0x50>
8001fcc: 34 02 00 1f mvi r2,31 <== NOT EXECUTED
8001fd0: f8 00 79 26 calli 8020468 <__ashrsi3> <== NOT EXECUTED
}
8001fd4: b9 60 10 00 mv r2,r11
8001fd8: 2b 9d 00 04 lw ra,(sp+4)
8001fdc: 2b 8b 00 08 lw r11,(sp+8)
8001fe0: 37 9c 00 08 addi sp,sp,8
8001fe4: c3 a0 00 00 ret
08002074 <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
8002074: 37 9c ff ec addi sp,sp,-20
8002078: 5b 8b 00 0c sw (sp+12),r11
800207c: 5b 8c 00 08 sw (sp+8),r12
8002080: 5b 9d 00 04 sw (sp+4),ra
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
8002084: 28 2c 00 1c lw r12,(r1+28)
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
8002088: b8 20 20 00 mv r4,r1
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
800208c: 29 81 00 50 lw r1,(r12+80)
8002090: f8 00 22 5a calli 800a9f8 <pipe_write>
8002094: b8 20 58 00 mv r11,r1
if (err > 0) {
8002098: 4c 01 00 09 bge r0,r1,80020bc <IMFS_fifo_write+0x48>
IMFS_mtime_ctime_update(jnode);
800209c: 34 02 00 00 mvi r2,0
80020a0: 37 81 00 10 addi r1,sp,16
80020a4: f8 00 04 e2 calli 800342c <gettimeofday>
80020a8: 2b 81 00 10 lw r1,(sp+16)
80020ac: b9 60 10 00 mv r2,r11
80020b0: 59 81 00 44 sw (r12+68),r1
80020b4: 59 81 00 48 sw (r12+72),r1
80020b8: e0 00 00 07 bi 80020d4 <IMFS_fifo_write+0x60>
}
IMFS_FIFO_RETURN(err);
80020bc: 34 02 00 00 mvi r2,0
80020c0: 44 20 00 05 be r1,r0,80020d4 <IMFS_fifo_write+0x60> <== NEVER TAKEN
80020c4: f8 00 32 fd calli 800ecb8 <__errno>
80020c8: c8 0b 58 00 sub r11,r0,r11
80020cc: 58 2b 00 00 sw (r1+0),r11
80020d0: 34 02 ff ff mvi r2,-1
}
80020d4: b8 40 08 00 mv r1,r2
80020d8: 2b 9d 00 04 lw ra,(sp+4)
80020dc: 2b 8b 00 0c lw r11,(sp+12)
80020e0: 2b 8c 00 08 lw r12,(sp+8)
80020e4: 37 9c 00 14 addi sp,sp,20
80020e8: c3 a0 00 00 ret
0800c1c0 <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
800c1c0: 37 9c ff f0 addi sp,sp,-16
800c1c4: 5b 8b 00 10 sw (sp+16),r11
800c1c8: 5b 8c 00 0c sw (sp+12),r12
800c1cc: 5b 8d 00 08 sw (sp+8),r13
800c1d0: 5b 9d 00 04 sw (sp+4),ra
800c1d4: b8 20 58 00 mv r11,r1
800c1d8: b8 40 68 00 mv r13,r2
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
800c1dc: b8 40 08 00 mv r1,r2
800c1e0: 78 02 08 01 mvhi r2,0x801
800c1e4: 38 42 83 48 ori r2,r2,0x8348
800c1e8: f8 00 18 8c calli 8012418 <strcmp>
800c1ec: 44 20 00 14 be r1,r0,800c23c <IMFS_find_match_in_dir+0x7c> <== NEVER TAKEN
return directory;
if ( !strcmp( name, dotdotname ) )
800c1f0: 78 02 08 01 mvhi r2,0x801
800c1f4: b9 a0 08 00 mv r1,r13
800c1f8: 38 42 83 4c ori r2,r2,0x834c
800c1fc: f8 00 18 87 calli 8012418 <strcmp>
800c200: 5c 20 00 03 bne r1,r0,800c20c <IMFS_find_match_in_dir+0x4c><== ALWAYS TAKEN
return directory->Parent;
800c204: 29 6b 00 08 lw r11,(r11+8) <== NOT EXECUTED
800c208: e0 00 00 0d bi 800c23c <IMFS_find_match_in_dir+0x7c> <== NOT EXECUTED
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
800c20c: 29 6c 00 50 lw r12,(r11+80)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
800c210: 35 6b 00 54 addi r11,r11,84
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
800c214: e0 00 00 06 bi 800c22c <IMFS_find_match_in_dir+0x6c>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
if ( !strcmp( name, the_jnode->name ) )
800c218: b9 a0 08 00 mv r1,r13
800c21c: 35 82 00 0c addi r2,r12,12
800c220: f8 00 18 7e calli 8012418 <strcmp>
800c224: 44 20 00 05 be r1,r0,800c238 <IMFS_find_match_in_dir+0x78>
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
800c228: 29 8c 00 00 lw r12,(r12+0)
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
800c22c: 5d 8b ff fb bne r12,r11,800c218 <IMFS_find_match_in_dir+0x58>
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
800c230: 34 0b 00 00 mvi r11,0
800c234: e0 00 00 02 bi 800c23c <IMFS_find_match_in_dir+0x7c>
for ( the_node = rtems_chain_first( the_chain );
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
800c238: b9 80 58 00 mv r11,r12
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
800c23c: b9 60 08 00 mv r1,r11
800c240: 2b 9d 00 04 lw ra,(sp+4)
800c244: 2b 8b 00 10 lw r11,(sp+16)
800c248: 2b 8c 00 0c lw r12,(sp+12)
800c24c: 2b 8d 00 08 lw r13,(sp+8)
800c250: 37 9c 00 10 addi sp,sp,16
800c254: c3 a0 00 00 ret
0800c0f0 <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
)
{
800c0f0: 37 9c ff d8 addi sp,sp,-40
800c0f4: 5b 8b 00 14 sw (sp+20),r11
800c0f8: 5b 8c 00 10 sw (sp+16),r12
800c0fc: 5b 8d 00 0c sw (sp+12),r13
800c100: 5b 8e 00 08 sw (sp+8),r14
800c104: 5b 9d 00 04 sw (sp+4),ra
/*
* 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;
800c108: 28 2b 00 1c lw r11,(r1+28)
loc = temp_mt_entry->mt_fs_root;
800c10c: 28 25 00 20 lw r5,(r1+32)
800c110: 28 24 00 24 lw r4,(r1+36)
800c114: 28 23 00 28 lw r3,(r1+40)
800c118: 28 22 00 2c lw r2,(r1+44)
800c11c: 5b 8b 00 18 sw (sp+24),r11
800c120: 5b 85 00 1c sw (sp+28),r5
800c124: 5b 84 00 20 sw (sp+32),r4
800c128: 5b 83 00 24 sw (sp+36),r3
800c12c: 5b 82 00 28 sw (sp+40),r2
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
800c130: 58 20 00 1c sw (r1+28),r0
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
800c134: 37 8c 00 18 addi r12,sp,24
if ( jnode->type != IMFS_DIRECTORY ) {
800c138: 34 0d 00 01 mvi r13,1
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
800c13c: b9 80 08 00 mv r1,r12
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
800c140: 29 6e 00 08 lw r14,(r11+8)
loc.node_access = (void *)jnode;
800c144: 5b 8b 00 18 sw (sp+24),r11
IMFS_Set_handlers( &loc );
800c148: fb ff fd a4 calli 800b7d8 <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
800c14c: 29 61 00 4c lw r1,(r11+76)
800c150: 5c 2d 00 04 bne r1,r13,800c160 <IMFS_fsunmount+0x70>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
800c154: 29 62 00 50 lw r2,(r11+80)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
800c158: 35 61 00 54 addi r1,r11,84
800c15c: 5c 41 00 06 bne r2,r1,800c174 <IMFS_fsunmount+0x84>
result = IMFS_unlink( NULL, &loc );
800c160: 34 01 00 00 mvi r1,0
800c164: b9 80 10 00 mv r2,r12
800c168: fb ff d7 d0 calli 80020a8 <IMFS_unlink>
if (result != 0)
800c16c: 5c 20 00 0b bne r1,r0,800c198 <IMFS_fsunmount+0xa8> <== NEVER TAKEN
return -1;
jnode = next;
800c170: b9 c0 58 00 mv r11,r14
}
if ( jnode != NULL ) {
800c174: 45 60 00 0b be r11,r0,800c1a0 <IMFS_fsunmount+0xb0>
if ( jnode->type == IMFS_DIRECTORY ) {
800c178: 29 61 00 4c lw r1,(r11+76)
800c17c: 5c 2d ff f0 bne r1,r13,800c13c <IMFS_fsunmount+0x4c> <== NEVER TAKEN
}
}
} while (jnode != NULL);
return 0;
}
800c180: 29 61 00 50 lw r1,(r11+80)
800c184: 35 62 00 54 addi r2,r11,84
return -1;
jnode = next;
}
if ( jnode != NULL ) {
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
800c188: 44 22 ff ed be r1,r2,800c13c <IMFS_fsunmount+0x4c>
jnode = jnode_get_first_child( jnode );
800c18c: b8 20 58 00 mv r11,r1
}
}
} while (jnode != NULL);
800c190: 5c 20 ff eb bne r1,r0,800c13c <IMFS_fsunmount+0x4c> <== ALWAYS TAKEN
800c194: e0 00 00 03 bi 800c1a0 <IMFS_fsunmount+0xb0> <== NOT EXECUTED
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
800c198: 34 01 ff ff mvi r1,-1 <== NOT EXECUTED
800c19c: e0 00 00 02 bi 800c1a4 <IMFS_fsunmount+0xb4> <== NOT EXECUTED
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
return 0;
800c1a0: 34 01 00 00 mvi r1,0
}
800c1a4: 2b 9d 00 04 lw ra,(sp+4)
800c1a8: 2b 8b 00 14 lw r11,(sp+20)
800c1ac: 2b 8c 00 10 lw r12,(sp+16)
800c1b0: 2b 8d 00 0c lw r13,(sp+12)
800c1b4: 2b 8e 00 08 lw r14,(sp+8)
800c1b8: 37 9c 00 28 addi sp,sp,40
800c1bc: c3 a0 00 00 ret
0800c258 <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
800c258: 37 9c ff e0 addi sp,sp,-32
800c25c: 5b 8b 00 20 sw (sp+32),r11
800c260: 5b 8c 00 1c sw (sp+28),r12
800c264: 5b 8d 00 18 sw (sp+24),r13
800c268: 5b 8e 00 14 sw (sp+20),r14
800c26c: 5b 8f 00 10 sw (sp+16),r15
800c270: 5b 90 00 0c sw (sp+12),r16
800c274: 5b 91 00 08 sw (sp+8),r17
800c278: 5b 9d 00 04 sw (sp+4),ra
register int i = 0;
800c27c: 34 0b 00 00 mvi r11,0
const char *path,
int pathlen,
char *token,
int *token_len
)
{
800c280: b8 20 78 00 mv r15,r1
800c284: b8 40 70 00 mv r14,r2
800c288: b8 60 68 00 mv r13,r3
800c28c: b8 80 80 00 mv r16,r4
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
800c290: 40 2c 00 00 lbu r12,(r1+0)
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
if ( i == IMFS_NAME_MAX )
800c294: 34 11 00 20 mvi r17,32
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
800c298: e0 00 00 07 bi 800c2b4 <IMFS_get_token+0x5c>
#include <string.h>
#include "imfs.h"
#include <rtems/libio_.h>
IMFS_token_types IMFS_get_token(
800c29c: b5 ab 08 00 add r1,r13,r11
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
800c2a0: 30 2c 00 00 sb (r1+0),r12
if ( i == IMFS_NAME_MAX )
800c2a4: 45 71 00 27 be r11,r17,800c340 <IMFS_get_token+0xe8>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
800c2a8: 35 6b 00 01 addi r11,r11,1
#include <string.h>
#include "imfs.h"
#include <rtems/libio_.h>
IMFS_token_types IMFS_get_token(
800c2ac: b5 eb 08 00 add r1,r15,r11
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
800c2b0: 40 2c 00 00 lbu r12,(r1+0)
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
800c2b4: b9 80 08 00 mv r1,r12
800c2b8: fb ff dd 7b calli 80038a4 <rtems_filesystem_is_separator>
800c2bc: 5c 20 00 03 bne r1,r0,800c2c8 <IMFS_get_token+0x70>
800c2c0: e9 cb 10 00 cmpg r2,r14,r11
800c2c4: 5c 41 ff f6 bne r2,r1,800c29c <IMFS_get_token+0x44> <== ALWAYS TAKEN
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
800c2c8: 5d 60 00 08 bne r11,r0,800c2e8 <IMFS_get_token+0x90>
token[i] = c;
800c2cc: 31 ac 00 00 sb (r13+0),r12
if ( (token[i] != '\0') && pathlen ) {
800c2d0: 7d ce 00 00 cmpnei r14,r14,0
800c2d4: 7d 8c 00 00 cmpnei r12,r12,0
800c2d8: a1 8e 60 00 and r12,r12,r14
800c2dc: 5d 8b 00 09 bne r12,r11,800c300 <IMFS_get_token+0xa8>
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
800c2e0: 34 0c 00 00 mvi r12,0
800c2e4: e0 00 00 09 bi 800c308 <IMFS_get_token+0xb0>
}
} else if (token[ i-1 ] != '\0') {
800c2e8: b5 ab 08 00 add r1,r13,r11
800c2ec: 40 22 ff ff lbu r2,(r1+-1)
char *token,
int *token_len
)
{
register int i = 0;
IMFS_token_types type = IMFS_NAME;
800c2f0: 34 0c 00 03 mvi r12,3
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
800c2f4: 44 40 00 05 be r2,r0,800c308 <IMFS_get_token+0xb0> <== NEVER TAKEN
token[i] = '\0';
800c2f8: 30 20 00 00 sb (r1+0),r0
800c2fc: e0 00 00 03 bi 800c308 <IMFS_get_token+0xb0>
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
type = IMFS_CURRENT_DIR;
800c300: 34 0c 00 01 mvi r12,1
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
800c304: 34 0b 00 01 mvi r11,1
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
800c308: 5a 0b 00 00 sw (r16+0),r11
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
800c30c: 34 01 00 03 mvi r1,3
800c310: 5d 81 00 11 bne r12,r1,800c354 <IMFS_get_token+0xfc>
if ( strcmp( token, "..") == 0 )
800c314: 78 02 08 01 mvhi r2,0x801
800c318: b9 a0 08 00 mv r1,r13
800c31c: 38 42 83 50 ori r2,r2,0x8350
800c320: f8 00 18 3e calli 8012418 <strcmp>
800c324: 44 20 00 09 be r1,r0,800c348 <IMFS_get_token+0xf0>
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
800c328: 78 02 08 01 mvhi r2,0x801
800c32c: b9 a0 08 00 mv r1,r13
800c330: 38 42 83 54 ori r2,r2,0x8354
800c334: f8 00 18 39 calli 8012418 <strcmp>
800c338: 44 20 00 06 be r1,r0,800c350 <IMFS_get_token+0xf8>
800c33c: e0 00 00 06 bi 800c354 <IMFS_get_token+0xfc>
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
if ( i == IMFS_NAME_MAX )
return IMFS_INVALID_TOKEN;
800c340: 34 0c 00 04 mvi r12,4
800c344: e0 00 00 04 bi 800c354 <IMFS_get_token+0xfc>
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
800c348: 34 0c 00 02 mvi r12,2
800c34c: e0 00 00 02 bi 800c354 <IMFS_get_token+0xfc>
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
800c350: 34 0c 00 01 mvi r12,1
}
return type;
}
800c354: b9 80 08 00 mv r1,r12
800c358: 2b 9d 00 04 lw ra,(sp+4)
800c35c: 2b 8b 00 20 lw r11,(sp+32)
800c360: 2b 8c 00 1c lw r12,(sp+28)
800c364: 2b 8d 00 18 lw r13,(sp+24)
800c368: 2b 8e 00 14 lw r14,(sp+20)
800c36c: 2b 8f 00 10 lw r15,(sp+16)
800c370: 2b 90 00 0c lw r16,(sp+12)
800c374: 2b 91 00 08 lw r17,(sp+8)
800c378: 37 9c 00 20 addi sp,sp,32
800c37c: c3 a0 00 00 ret
08001c2c <IMFS_initialize_support>:
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
8001c2c: 37 9c ff e0 addi sp,sp,-32
8001c30: 5b 8b 00 20 sw (sp+32),r11
8001c34: 5b 8c 00 1c sw (sp+28),r12
8001c38: 5b 8d 00 18 sw (sp+24),r13
8001c3c: 5b 8e 00 14 sw (sp+20),r14
8001c40: 5b 8f 00 10 sw (sp+16),r15
8001c44: 5b 90 00 0c sw (sp+12),r16
8001c48: 5b 91 00 08 sw (sp+8),r17
8001c4c: 5b 9d 00 04 sw (sp+4),ra
8001c50: b8 20 58 00 mv r11,r1
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
8001c54: 78 01 08 01 mvhi r1,0x801
8001c58: 38 21 90 14 ori r1,r1,0x9014
8001c5c: 28 2c 00 00 lw r12,(r1+0)
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
8001c60: b8 40 88 00 mv r17,r2
8001c64: b8 60 80 00 mv r16,r3
8001c68: b8 80 70 00 mv r14,r4
8001c6c: b8 a0 78 00 mv r15,r5
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
8001c70: 34 0d 00 06 mvi r13,6
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
8001c74: 34 01 00 10 mvi r1,16
if (bit_mask == requested_bytes_per_block) {
8001c78: 44 2c 00 07 be r1,r12,8001c94 <IMFS_initialize_support+0x68>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
8001c7c: 48 2c 00 05 bg r1,r12,8001c90 <IMFS_initialize_support+0x64>
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
8001c80: 34 02 00 01 mvi r2,1
8001c84: 35 ad ff ff addi r13,r13,-1
8001c88: f8 00 54 a2 calli 8016f10 <__ashlsi3>
8001c8c: 5d a0 ff fb bne r13,r0,8001c78 <IMFS_initialize_support+0x4c><== ALWAYS TAKEN
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
8001c90: 34 0c 00 80 mvi r12,128
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
8001c94: 78 01 08 01 mvhi r1,0x801
8001c98: 38 21 97 48 ori r1,r1,0x9748
8001c9c: 58 2c 00 00 sw (r1+0),r12
/*
* Create the root node
*
* NOTE: UNIX root is 755 and owned by root/root (0/0).
*/
temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
8001ca0: f8 00 26 be calli 800b798 <IMFS_create_root_node>
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
temp_mt_entry->mt_fs_root.ops = op_table;
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
8001ca4: 78 02 08 01 mvhi r2,0x801
/*
* Create the root node
*
* NOTE: UNIX root is 755 and owned by root/root (0/0).
*/
temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
8001ca8: 59 61 00 1c sw (r11+28),r1
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
temp_mt_entry->mt_fs_root.ops = op_table;
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
8001cac: 38 42 82 fc ori r2,r2,0x82fc
8001cb0: 34 03 00 30 mvi r3,48
/*
* Create the root node
*
* NOTE: UNIX root is 755 and owned by root/root (0/0).
*/
temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
8001cb4: b8 20 60 00 mv r12,r1
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
8001cb8: 59 6e 00 24 sw (r11+36),r14
temp_mt_entry->mt_fs_root.ops = op_table;
8001cbc: 59 71 00 28 sw (r11+40),r17
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
8001cc0: 35 61 00 38 addi r1,r11,56
8001cc4: f8 00 40 a1 calli 8011f48 <memcpy>
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
8001cc8: 34 02 00 14 mvi r2,20
8001ccc: 34 01 00 01 mvi r1,1
8001cd0: f8 00 01 ec calli 8002480 <calloc>
8001cd4: b8 20 10 00 mv r2,r1
if ( !fs_info ) {
8001cd8: 5c 20 00 08 bne r1,r0,8001cf8 <IMFS_initialize_support+0xcc>
free(temp_mt_entry->mt_fs_root.node_access);
8001cdc: b9 80 08 00 mv r1,r12
8001ce0: f8 00 02 79 calli 80026c4 <free>
rtems_set_errno_and_return_minus_one(ENOMEM);
8001ce4: f8 00 3d e3 calli 8011470 <__errno>
8001ce8: 34 02 00 0c mvi r2,12
8001cec: 58 22 00 00 sw (r1+0),r2
8001cf0: 34 01 ff ff mvi r1,-1
8001cf4: e0 00 00 0f bi 8001d30 <IMFS_initialize_support+0x104>
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
8001cf8: 78 06 08 01 mvhi r6,0x801
8001cfc: 38 c6 97 4c ori r6,r6,0x974c
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
if ( !fs_info ) {
free(temp_mt_entry->mt_fs_root.node_access);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
temp_mt_entry->fs_info = fs_info;
8001d00: 59 61 00 34 sw (r11+52),r1
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
8001d04: 28 c1 00 00 lw r1,(r6+0)
fs_info->ino_count = 1;
fs_info->memfile_handlers = memfile_handlers;
8001d08: 58 50 00 08 sw (r2+8),r16
fs_info->directory_handlers = directory_handlers;
8001d0c: 58 4e 00 0c sw (r2+12),r14
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
8001d10: 58 41 00 00 sw (r2+0),r1
8001d14: 34 21 00 01 addi r1,r1,1
8001d18: 58 c1 00 00 sw (r6+0),r1
fs_info->ino_count = 1;
8001d1c: 34 01 00 01 mvi r1,1
8001d20: 58 41 00 04 sw (r2+4),r1
fs_info->memfile_handlers = memfile_handlers;
fs_info->directory_handlers = directory_handlers;
fs_info->fifo_handlers = fifo_handlers;
8001d24: 58 4f 00 10 sw (r2+16),r15
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
8001d28: 59 81 00 38 sw (r12+56),r1
return 0;
8001d2c: 34 01 00 00 mvi r1,0
}
8001d30: 2b 9d 00 04 lw ra,(sp+4)
8001d34: 2b 8b 00 20 lw r11,(sp+32)
8001d38: 2b 8c 00 1c lw r12,(sp+28)
8001d3c: 2b 8d 00 18 lw r13,(sp+24)
8001d40: 2b 8e 00 14 lw r14,(sp+20)
8001d44: 2b 8f 00 10 lw r15,(sp+16)
8001d48: 2b 90 00 0c lw r16,(sp+12)
8001d4c: 2b 91 00 08 lw r17,(sp+8)
8001d50: 37 9c 00 20 addi sp,sp,32
8001d54: c3 a0 00 00 ret
0800fd5c <IMFS_memfile_extend>:
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
800fd5c: 37 9c ff e0 addi sp,sp,-32
800fd60: 5b 8b 00 20 sw (sp+32),r11
800fd64: 5b 8c 00 1c sw (sp+28),r12
800fd68: 5b 8d 00 18 sw (sp+24),r13
800fd6c: 5b 8e 00 14 sw (sp+20),r14
800fd70: 5b 8f 00 10 sw (sp+16),r15
800fd74: 5b 90 00 0c sw (sp+12),r16
800fd78: 5b 91 00 08 sw (sp+8),r17
800fd7c: 5b 9d 00 04 sw (sp+4),ra
800fd80: b8 20 60 00 mv r12,r1
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
800fd84: 78 01 08 01 mvhi r1,0x801
800fd88: 38 21 97 48 ori r1,r1,0x9748
800fd8c: 28 2b 00 00 lw r11,(r1+0)
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
800fd90: b8 40 68 00 mv r13,r2
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
800fd94: 34 02 00 02 mvi r2,2
800fd98: b9 60 08 00 mv r1,r11
800fd9c: f8 00 1c ab calli 8017048 <__lshrsi3>
800fda0: b8 20 70 00 mv r14,r1
800fda4: b9 c0 10 00 mv r2,r14
800fda8: 34 21 00 01 addi r1,r1,1
800fdac: f8 00 1c ce calli 80170e4 <__mulsi3>
800fdb0: b9 c0 10 00 mv r2,r14
800fdb4: 34 21 00 01 addi r1,r1,1
800fdb8: f8 00 1c cb calli 80170e4 <__mulsi3>
800fdbc: 34 21 ff ff addi r1,r1,-1
800fdc0: b9 60 10 00 mv r2,r11
800fdc4: f8 00 1c c8 calli 80170e4 <__mulsi3>
800fdc8: 54 2d 00 04 bgu r1,r13,800fdd8 <IMFS_memfile_extend+0x7c>
rtems_set_errno_and_return_minus_one( EINVAL );
800fdcc: f8 00 05 a9 calli 8011470 <__errno>
800fdd0: 34 02 00 16 mvi r2,22
800fdd4: e0 00 00 26 bi 800fe6c <IMFS_memfile_extend+0x110>
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
800fdd8: b9 a0 08 00 mv r1,r13
800fddc: 34 02 00 1f mvi r2,31
800fde0: f8 00 1c 73 calli 8016fac <__ashrsi3>
800fde4: 29 8f 00 50 lw r15,(r12+80)
800fde8: b8 20 70 00 mv r14,r1
800fdec: 29 90 00 54 lw r16,(r12+84)
800fdf0: 48 2f 00 04 bg r1,r15,800fe00 <IMFS_memfile_extend+0xa4> <== NEVER TAKEN
800fdf4: 5c 2f 00 25 bne r1,r15,800fe88 <IMFS_memfile_extend+0x12c> <== NEVER TAKEN
800fdf8: 55 b0 00 02 bgu r13,r16,800fe00 <IMFS_memfile_extend+0xa4>
800fdfc: e0 00 00 23 bi 800fe88 <IMFS_memfile_extend+0x12c>
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
800fe00: b9 60 10 00 mv r2,r11
800fe04: b9 a0 08 00 mv r1,r13
800fe08: f8 00 1c c3 calli 8017114 <__divsi3>
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
800fe0c: 34 02 00 1f mvi r2,31
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
800fe10: b8 20 88 00 mv r17,r1
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
800fe14: b9 60 08 00 mv r1,r11
800fe18: f8 00 1c 65 calli 8016fac <__ashrsi3>
800fe1c: b8 20 18 00 mv r3,r1
800fe20: b9 60 20 00 mv r4,r11
800fe24: b9 e0 08 00 mv r1,r15
800fe28: ba 00 10 00 mv r2,r16
800fe2c: f8 00 14 73 calli 8014ff8 <__divdi3>
800fe30: b8 40 78 00 mv r15,r2
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
800fe34: b8 40 58 00 mv r11,r2
800fe38: e0 00 00 11 bi 800fe7c <IMFS_memfile_extend+0x120>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
800fe3c: b9 80 08 00 mv r1,r12
800fe40: b9 60 10 00 mv r2,r11
800fe44: fb ff ff 23 calli 800fad0 <IMFS_memfile_addblock>
800fe48: 44 20 00 0c be r1,r0,800fe78 <IMFS_memfile_extend+0x11c>
800fe4c: e0 00 00 05 bi 800fe60 <IMFS_memfile_extend+0x104>
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
800fe50: b9 60 10 00 mv r2,r11
800fe54: b9 80 08 00 mv r1,r12
800fe58: fb ff ff b5 calli 800fd2c <IMFS_memfile_remove_block>
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
for ( ; block>=old_blocks ; block-- ) {
800fe5c: 35 6b ff ff addi r11,r11,-1
800fe60: 51 6f ff fc bgeu r11,r15,800fe50 <IMFS_memfile_extend+0xf4>
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
800fe64: f8 00 05 83 calli 8011470 <__errno>
800fe68: 34 02 00 1c mvi r2,28
800fe6c: 58 22 00 00 sw (r1+0),r2
800fe70: 34 01 ff ff mvi r1,-1
800fe74: e0 00 00 06 bi 800fe8c <IMFS_memfile_extend+0x130>
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
800fe78: 35 6b 00 01 addi r11,r11,1
800fe7c: 52 2b ff f0 bgeu r17,r11,800fe3c <IMFS_memfile_extend+0xe0>
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
800fe80: 59 8e 00 50 sw (r12+80),r14
800fe84: 59 8d 00 54 sw (r12+84),r13
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
return 0;
800fe88: 34 01 00 00 mvi r1,0
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
return 0;
}
800fe8c: 2b 9d 00 04 lw ra,(sp+4)
800fe90: 2b 8b 00 20 lw r11,(sp+32)
800fe94: 2b 8c 00 1c lw r12,(sp+28)
800fe98: 2b 8d 00 18 lw r13,(sp+24)
800fe9c: 2b 8e 00 14 lw r14,(sp+20)
800fea0: 2b 8f 00 10 lw r15,(sp+16)
800fea4: 2b 90 00 0c lw r16,(sp+12)
800fea8: 2b 91 00 08 lw r17,(sp+8)
800feac: 37 9c 00 20 addi sp,sp,32
800feb0: c3 a0 00 00 ret
0800f614 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
800f614: 37 9c ff e0 addi sp,sp,-32
800f618: 5b 8b 00 20 sw (sp+32),r11
800f61c: 5b 8c 00 1c sw (sp+28),r12
800f620: 5b 8d 00 18 sw (sp+24),r13
800f624: 5b 8e 00 14 sw (sp+20),r14
800f628: 5b 8f 00 10 sw (sp+16),r15
800f62c: 5b 90 00 0c sw (sp+12),r16
800f630: 5b 91 00 08 sw (sp+8),r17
800f634: 5b 9d 00 04 sw (sp+4),ra
800f638: b8 20 68 00 mv r13,r1
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
800f63c: 78 01 08 01 mvhi r1,0x801
800f640: 38 21 97 48 ori r1,r1,0x9748
800f644: 28 21 00 00 lw r1,(r1+0)
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
800f648: b8 40 70 00 mv r14,r2
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
800f64c: 34 02 00 02 mvi r2,2
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
800f650: b8 60 78 00 mv r15,r3
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
800f654: f8 00 1e 7d calli 8017048 <__lshrsi3>
800f658: b8 20 60 00 mv r12,r1
800f65c: 34 21 ff ff addi r1,r1,-1
800f660: 55 c1 00 12 bgu r14,r1,800f6a8 <IMFS_memfile_get_block_pointer+0x94>
p = info->indirect;
800f664: 29 ac 00 58 lw r12,(r13+88)
if ( malloc_it ) {
800f668: 45 e0 00 0c be r15,r0,800f698 <IMFS_memfile_get_block_pointer+0x84>
if ( !p ) {
800f66c: 5d 80 00 05 bne r12,r0,800f680 <IMFS_memfile_get_block_pointer+0x6c>
p = memfile_alloc_block();
800f670: fb ff ff d9 calli 800f5d4 <memfile_alloc_block>
if ( !p )
return 0;
800f674: 34 0b 00 00 mvi r11,0
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
800f678: 44 2c 00 81 be r1,r12,800f87c <IMFS_memfile_get_block_pointer+0x268><== NEVER TAKEN
return 0;
info->indirect = p;
800f67c: 59 a1 00 58 sw (r13+88),r1
}
return &info->indirect[ my_block ];
800f680: b9 c0 08 00 mv r1,r14
800f684: 34 02 00 02 mvi r2,2
800f688: f8 00 1e 22 calli 8016f10 <__ashlsi3>
800f68c: 29 ab 00 58 lw r11,(r13+88)
800f690: b5 61 58 00 add r11,r11,r1
800f694: e0 00 00 7a bi 800f87c <IMFS_memfile_get_block_pointer+0x268>
}
if ( !p )
return 0;
800f698: 34 0b 00 00 mvi r11,0
return &info->indirect[ my_block ];
800f69c: b9 c0 08 00 mv r1,r14
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
800f6a0: 5d 8b 00 74 bne r12,r11,800f870 <IMFS_memfile_get_block_pointer+0x25c><== ALWAYS TAKEN
800f6a4: e0 00 00 76 bi 800f87c <IMFS_memfile_get_block_pointer+0x268><== NOT EXECUTED
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
800f6a8: 35 81 00 01 addi r1,r12,1
800f6ac: b9 80 10 00 mv r2,r12
800f6b0: f8 00 1e 8d calli 80170e4 <__mulsi3>
800f6b4: b8 20 80 00 mv r16,r1
800f6b8: 34 21 ff ff addi r1,r1,-1
800f6bc: 55 c1 00 2b bgu r14,r1,800f768 <IMFS_memfile_get_block_pointer+0x154>
my_block -= FIRST_DOUBLY_INDIRECT;
800f6c0: c9 cc 70 00 sub r14,r14,r12
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
800f6c4: b9 80 10 00 mv r2,r12
800f6c8: b9 c0 08 00 mv r1,r14
800f6cc: f8 00 1e fb calli 80172b8 <__umodsi3>
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
800f6d0: b9 80 10 00 mv r2,r12
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
800f6d4: b8 20 80 00 mv r16,r1
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
800f6d8: b9 c0 08 00 mv r1,r14
800f6dc: f8 00 1e e7 calli 8017278 <__udivsi3>
800f6e0: b8 20 70 00 mv r14,r1
p = info->doubly_indirect;
800f6e4: 29 ac 00 5c lw r12,(r13+92)
if ( malloc_it ) {
800f6e8: 45 e0 00 17 be r15,r0,800f744 <IMFS_memfile_get_block_pointer+0x130>
if ( !p ) {
800f6ec: 5d 80 00 06 bne r12,r0,800f704 <IMFS_memfile_get_block_pointer+0xf0>
p = memfile_alloc_block();
800f6f0: fb ff ff b9 calli 800f5d4 <memfile_alloc_block>
800f6f4: b8 20 60 00 mv r12,r1
if ( !p )
return 0;
800f6f8: 34 0b 00 00 mvi r11,0
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
800f6fc: 44 20 00 60 be r1,r0,800f87c <IMFS_memfile_get_block_pointer+0x268><== NEVER TAKEN
return 0;
info->doubly_indirect = p;
800f700: 59 a1 00 5c sw (r13+92),r1
}
p1 = (block_p *)p[ doubly ];
800f704: b9 c0 08 00 mv r1,r14
800f708: 34 02 00 02 mvi r2,2
800f70c: f8 00 1e 01 calli 8016f10 <__ashlsi3>
800f710: b5 81 60 00 add r12,r12,r1
800f714: 29 8d 00 00 lw r13,(r12+0)
if ( !p1 ) {
800f718: 5d a0 00 06 bne r13,r0,800f730 <IMFS_memfile_get_block_pointer+0x11c>
p1 = memfile_alloc_block();
800f71c: fb ff ff ae calli 800f5d4 <memfile_alloc_block>
800f720: b8 20 68 00 mv r13,r1
if ( !p1 )
return 0;
800f724: 34 0b 00 00 mvi r11,0
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
800f728: 44 20 00 55 be r1,r0,800f87c <IMFS_memfile_get_block_pointer+0x268><== NEVER TAKEN
return 0;
p[ doubly ] = (block_p) p1;
800f72c: 59 81 00 00 sw (r12+0),r1
}
return (block_p *)&p1[ singly ];
800f730: ba 00 08 00 mv r1,r16
800f734: 34 02 00 02 mvi r2,2
800f738: f8 00 1d f6 calli 8016f10 <__ashlsi3>
800f73c: b5 a1 58 00 add r11,r13,r1
800f740: e0 00 00 4f bi 800f87c <IMFS_memfile_get_block_pointer+0x268>
}
if ( !p )
return 0;
800f744: 34 0b 00 00 mvi r11,0
}
return (block_p *)&p1[ singly ];
}
if ( !p )
800f748: 45 8b 00 4d be r12,r11,800f87c <IMFS_memfile_get_block_pointer+0x268><== NEVER TAKEN
return 0;
p = (block_p *)p[ doubly ];
800f74c: 34 02 00 02 mvi r2,2
800f750: f8 00 1d f0 calli 8016f10 <__ashlsi3>
800f754: b5 81 08 00 add r1,r12,r1
800f758: 28 2c 00 00 lw r12,(r1+0)
if ( !p )
return 0;
return (block_p *)&p[ singly ];
800f75c: ba 00 08 00 mv r1,r16
if ( !p )
return 0;
p = (block_p *)p[ doubly ];
if ( !p )
800f760: 5d 80 00 44 bne r12,r0,800f870 <IMFS_memfile_get_block_pointer+0x25c><== ALWAYS TAKEN
800f764: e0 00 00 46 bi 800f87c <IMFS_memfile_get_block_pointer+0x268><== NOT EXECUTED
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
800f768: 36 01 00 01 addi r1,r16,1
800f76c: b9 80 10 00 mv r2,r12
800f770: f8 00 1e 5d calli 80170e4 <__mulsi3>
800f774: 34 21 ff ff addi r1,r1,-1
}
/*
* This means the requested block number is out of range.
*/
return 0;
800f778: 34 0b 00 00 mvi r11,0
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
800f77c: 55 c1 00 40 bgu r14,r1,800f87c <IMFS_memfile_get_block_pointer+0x268><== NEVER TAKEN
my_block -= FIRST_TRIPLY_INDIRECT;
800f780: c9 d0 70 00 sub r14,r14,r16
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
800f784: b9 80 10 00 mv r2,r12
800f788: b9 c0 08 00 mv r1,r14
800f78c: f8 00 1e cb calli 80172b8 <__umodsi3>
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
800f790: b9 80 10 00 mv r2,r12
* 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;
800f794: b8 20 88 00 mv r17,r1
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
800f798: b9 c0 08 00 mv r1,r14
800f79c: f8 00 1e b7 calli 8017278 <__udivsi3>
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
800f7a0: b9 80 10 00 mv r2,r12
*/
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;
800f7a4: b8 20 70 00 mv r14,r1
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
800f7a8: f8 00 1e b4 calli 8017278 <__udivsi3>
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
800f7ac: b9 80 10 00 mv r2,r12
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;
800f7b0: b8 20 80 00 mv r16,r1
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
800f7b4: b9 c0 08 00 mv r1,r14
800f7b8: f8 00 1e c0 calli 80172b8 <__umodsi3>
800f7bc: b8 20 70 00 mv r14,r1
p = info->triply_indirect;
800f7c0: 29 ac 00 60 lw r12,(r13+96)
if ( malloc_it ) {
800f7c4: 45 e0 00 1d be r15,r0,800f838 <IMFS_memfile_get_block_pointer+0x224>
if ( !p ) {
800f7c8: 5d 80 00 05 bne r12,r0,800f7dc <IMFS_memfile_get_block_pointer+0x1c8>
p = memfile_alloc_block();
800f7cc: fb ff ff 82 calli 800f5d4 <memfile_alloc_block>
800f7d0: b8 20 60 00 mv r12,r1
if ( !p )
800f7d4: 44 20 00 2a be r1,r0,800f87c <IMFS_memfile_get_block_pointer+0x268><== NEVER TAKEN
return 0;
info->triply_indirect = p;
800f7d8: 59 a1 00 60 sw (r13+96),r1
}
p1 = (block_p *) p[ triply ];
800f7dc: ba 00 08 00 mv r1,r16
800f7e0: 34 02 00 02 mvi r2,2
800f7e4: f8 00 1d cb calli 8016f10 <__ashlsi3>
800f7e8: b5 81 60 00 add r12,r12,r1
800f7ec: 29 8d 00 00 lw r13,(r12+0)
if ( !p1 ) {
800f7f0: 5d a0 00 06 bne r13,r0,800f808 <IMFS_memfile_get_block_pointer+0x1f4>
p1 = memfile_alloc_block();
800f7f4: fb ff ff 78 calli 800f5d4 <memfile_alloc_block>
800f7f8: b8 20 68 00 mv r13,r1
if ( !p1 )
return 0;
800f7fc: 34 0b 00 00 mvi r11,0
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
800f800: 44 20 00 1f be r1,r0,800f87c <IMFS_memfile_get_block_pointer+0x268><== NEVER TAKEN
return 0;
p[ triply ] = (block_p) p1;
800f804: 59 81 00 00 sw (r12+0),r1
}
p2 = (block_p *)p1[ doubly ];
800f808: b9 c0 08 00 mv r1,r14
800f80c: 34 02 00 02 mvi r2,2
800f810: f8 00 1d c0 calli 8016f10 <__ashlsi3>
800f814: b5 a1 68 00 add r13,r13,r1
800f818: 29 ac 00 00 lw r12,(r13+0)
if ( !p2 ) {
800f81c: 5d 80 00 14 bne r12,r0,800f86c <IMFS_memfile_get_block_pointer+0x258>
p2 = memfile_alloc_block();
800f820: fb ff ff 6d calli 800f5d4 <memfile_alloc_block>
800f824: b8 20 60 00 mv r12,r1
if ( !p2 )
return 0;
800f828: 34 0b 00 00 mvi r11,0
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
if ( !p2 )
800f82c: 44 20 00 14 be r1,r0,800f87c <IMFS_memfile_get_block_pointer+0x268><== NEVER TAKEN
return 0;
p1[ doubly ] = (block_p) p2;
800f830: 59 a1 00 00 sw (r13+0),r1
800f834: e0 00 00 0e bi 800f86c <IMFS_memfile_get_block_pointer+0x258>
}
return (block_p *)&p2[ singly ];
}
if ( !p )
800f838: 45 8b 00 11 be r12,r11,800f87c <IMFS_memfile_get_block_pointer+0x268><== NEVER TAKEN
return 0;
p1 = (block_p *) p[ triply ];
800f83c: ba 00 08 00 mv r1,r16
800f840: 34 02 00 02 mvi r2,2
800f844: f8 00 1d b3 calli 8016f10 <__ashlsi3>
800f848: b5 81 08 00 add r1,r12,r1
800f84c: 28 2c 00 00 lw r12,(r1+0)
if ( !p1 )
800f850: 45 80 00 0b be r12,r0,800f87c <IMFS_memfile_get_block_pointer+0x268><== NEVER TAKEN
return 0;
p2 = (block_p *)p1[ doubly ];
800f854: b9 c0 08 00 mv r1,r14
800f858: 34 02 00 02 mvi r2,2
800f85c: f8 00 1d ad calli 8016f10 <__ashlsi3>
800f860: b5 81 08 00 add r1,r12,r1
800f864: 28 2c 00 00 lw r12,(r1+0)
if ( !p2 )
800f868: 45 80 00 05 be r12,r0,800f87c <IMFS_memfile_get_block_pointer+0x268><== NEVER TAKEN
return 0;
return (block_p *)&p2[ singly ];
800f86c: ba 20 08 00 mv r1,r17
800f870: 34 02 00 02 mvi r2,2
800f874: f8 00 1d a7 calli 8016f10 <__ashlsi3>
800f878: b5 81 58 00 add r11,r12,r1
/*
* This means the requested block number is out of range.
*/
return 0;
}
800f87c: b9 60 08 00 mv r1,r11
800f880: 2b 9d 00 04 lw ra,(sp+4)
800f884: 2b 8b 00 20 lw r11,(sp+32)
800f888: 2b 8c 00 1c lw r12,(sp+28)
800f88c: 2b 8d 00 18 lw r13,(sp+24)
800f890: 2b 8e 00 14 lw r14,(sp+20)
800f894: 2b 8f 00 10 lw r15,(sp+16)
800f898: 2b 90 00 0c lw r16,(sp+12)
800f89c: 2b 91 00 08 lw r17,(sp+8)
800f8a0: 37 9c 00 20 addi sp,sp,32
800f8a4: c3 a0 00 00 ret
0800f8a8 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
800f8a8: 37 9c ff d4 addi sp,sp,-44
800f8ac: 5b 8b 00 24 sw (sp+36),r11
800f8b0: 5b 8c 00 20 sw (sp+32),r12
800f8b4: 5b 8d 00 1c sw (sp+28),r13
800f8b8: 5b 8e 00 18 sw (sp+24),r14
800f8bc: 5b 8f 00 14 sw (sp+20),r15
800f8c0: 5b 90 00 10 sw (sp+16),r16
800f8c4: 5b 91 00 0c sw (sp+12),r17
800f8c8: 5b 92 00 08 sw (sp+8),r18
800f8cc: 5b 9d 00 04 sw (sp+4),ra
800f8d0: b8 40 70 00 mv r14,r2
* 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) {
800f8d4: 28 22 00 4c lw r2,(r1+76)
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
800f8d8: b8 20 60 00 mv r12,r1
800f8dc: 28 2d 00 50 lw r13,(r1+80)
800f8e0: 28 2f 00 54 lw r15,(r1+84)
* 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) {
800f8e4: 34 01 00 06 mvi r1,6
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
800f8e8: b8 60 80 00 mv r16,r3
800f8ec: b8 80 58 00 mv r11,r4
* 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) {
800f8f0: 5c 41 00 15 bne r2,r1,800f944 <IMFS_memfile_read+0x9c>
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
800f8f4: 34 02 00 1f mvi r2,31
800f8f8: b9 c0 08 00 mv r1,r14
800f8fc: f8 00 1d ac calli 8016fac <__ashrsi3>
800f900: c9 ee 18 00 sub r3,r15,r14
800f904: f4 6f 10 00 cmpgu r2,r3,r15
800f908: c9 a1 08 00 sub r1,r13,r1
800f90c: c8 22 68 00 sub r13,r1,r2
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
800f910: 29 91 00 58 lw r17,(r12+88)
if (my_length > (the_jnode->info.linearfile.size - start))
800f914: 48 0d 00 04 bg r0,r13,800f924 <IMFS_memfile_read+0x7c> <== NEVER TAKEN
800f918: 5c 0d 00 05 bne r0,r13,800f92c <IMFS_memfile_read+0x84> <== NEVER TAKEN
800f91c: 55 63 00 02 bgu r11,r3,800f924 <IMFS_memfile_read+0x7c> <== ALWAYS TAKEN
800f920: e0 00 00 03 bi 800f92c <IMFS_memfile_read+0x84> <== NOT EXECUTED
my_length = the_jnode->info.linearfile.size - start;
800f924: c9 ee 68 00 sub r13,r15,r14
800f928: e0 00 00 02 bi 800f930 <IMFS_memfile_read+0x88>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
800f92c: b9 60 68 00 mv r13,r11 <== NOT EXECUTED
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
my_length = the_jnode->info.linearfile.size - start;
memcpy(dest, &file_ptr[start], my_length);
800f930: ba 00 08 00 mv r1,r16
800f934: b6 2e 10 00 add r2,r17,r14
800f938: b9 a0 18 00 mv r3,r13
800f93c: f8 00 09 83 calli 8011f48 <memcpy>
800f940: e0 00 00 47 bi 800fa5c <IMFS_memfile_read+0x1b4>
/*
* 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;
800f944: b4 8e 08 00 add r1,r4,r14
if ( last_byte > the_jnode->info.file.size )
800f948: 48 0d 00 04 bg r0,r13,800f958 <IMFS_memfile_read+0xb0> <== NEVER TAKEN
800f94c: 5d a0 00 04 bne r13,r0,800f95c <IMFS_memfile_read+0xb4> <== NEVER TAKEN
800f950: 54 2f 00 02 bgu r1,r15,800f958 <IMFS_memfile_read+0xb0>
800f954: e0 00 00 02 bi 800f95c <IMFS_memfile_read+0xb4>
my_length = the_jnode->info.file.size - start;
800f958: c9 ee 58 00 sub r11,r15,r14
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
800f95c: 78 01 08 01 mvhi r1,0x801
800f960: 38 21 97 48 ori r1,r1,0x9748
800f964: 28 32 00 00 lw r18,(r1+0)
800f968: b9 c0 08 00 mv r1,r14
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
800f96c: ba 00 78 00 mv r15,r16
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
800f970: ba 40 10 00 mv r2,r18
800f974: f8 00 1e 18 calli 80171d4 <__modsi3>
800f978: b8 20 88 00 mv r17,r1
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
800f97c: ba 40 10 00 mv r2,r18
800f980: b9 c0 08 00 mv r1,r14
800f984: f8 00 1d e4 calli 8017114 <__divsi3>
800f988: b8 20 70 00 mv r14,r1
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
my_length = the_jnode->info.file.size - start;
copied = 0;
800f98c: 34 0d 00 00 mvi r13,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;
if ( start_offset ) {
800f990: 46 20 00 12 be r17,r0,800f9d8 <IMFS_memfile_read+0x130>
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 );
800f994: b9 80 08 00 mv r1,r12
800f998: b9 c0 10 00 mv r2,r14
800f99c: 34 03 00 00 mvi r3,0
800f9a0: fb ff ff 1d calli 800f614 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
800f9a4: 44 20 00 33 be r1,r0,800fa70 <IMFS_memfile_read+0x1c8> <== NEVER TAKEN
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
800f9a8: ca 51 90 00 sub r18,r18,r17
800f9ac: b9 60 68 00 mv r13,r11
800f9b0: 52 4b 00 02 bgeu r18,r11,800f9b8 <IMFS_memfile_read+0x110>
800f9b4: ba 40 68 00 mv r13,r18
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 );
800f9b8: 28 22 00 00 lw r2,(r1+0)
800f9bc: b9 a0 18 00 mv r3,r13
800f9c0: ba 00 08 00 mv r1,r16
800f9c4: b4 51 10 00 add r2,r2,r17
800f9c8: f8 00 09 60 calli 8011f48 <memcpy>
dest += to_copy;
800f9cc: b6 0d 78 00 add r15,r16,r13
block++;
800f9d0: 35 ce 00 01 addi r14,r14,1
my_length -= to_copy;
800f9d4: c9 6d 58 00 sub r11,r11,r13
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
800f9d8: 78 01 08 01 mvhi r1,0x801
800f9dc: 38 21 97 48 ori r1,r1,0x9748
800f9e0: 28 30 00 00 lw r16,(r1+0)
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
800f9e4: b8 20 88 00 mv r17,r1
800f9e8: e0 00 00 0f bi 800fa24 <IMFS_memfile_read+0x17c>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
800f9ec: b9 c0 10 00 mv r2,r14
800f9f0: b9 80 08 00 mv r1,r12
800f9f4: 34 03 00 00 mvi r3,0
800f9f8: fb ff ff 07 calli 800f614 <IMFS_memfile_get_block_pointer>
800f9fc: b8 20 10 00 mv r2,r1
if ( !block_ptr )
800fa00: 44 20 00 1c be r1,r0,800fa70 <IMFS_memfile_read+0x1c8> <== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
800fa04: 28 42 00 00 lw r2,(r2+0)
800fa08: b9 e0 08 00 mv r1,r15
800fa0c: ba 00 18 00 mv r3,r16
800fa10: f8 00 09 4e calli 8011f48 <memcpy>
dest += to_copy;
800fa14: b5 f0 78 00 add r15,r15,r16
block++;
800fa18: 35 ce 00 01 addi r14,r14,1
my_length -= to_copy;
800fa1c: c9 70 58 00 sub r11,r11,r16
copied += to_copy;
800fa20: b5 b0 68 00 add r13,r13,r16
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
800fa24: 2a 21 00 00 lw r1,(r17+0)
800fa28: 51 61 ff f1 bgeu r11,r1,800f9ec <IMFS_memfile_read+0x144>
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
800fa2c: 45 60 00 0c be r11,r0,800fa5c <IMFS_memfile_read+0x1b4>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
800fa30: b9 c0 10 00 mv r2,r14
800fa34: b9 80 08 00 mv r1,r12
800fa38: 34 03 00 00 mvi r3,0
800fa3c: fb ff fe f6 calli 800f614 <IMFS_memfile_get_block_pointer>
800fa40: b8 20 10 00 mv r2,r1
if ( !block_ptr )
800fa44: 44 20 00 0b be r1,r0,800fa70 <IMFS_memfile_read+0x1c8> <== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
800fa48: 28 42 00 00 lw r2,(r2+0)
800fa4c: b9 e0 08 00 mv r1,r15
800fa50: b9 60 18 00 mv r3,r11
800fa54: f8 00 09 3d calli 8011f48 <memcpy>
copied += my_length;
800fa58: b5 6d 68 00 add r13,r11,r13
}
IMFS_update_atime( the_jnode );
800fa5c: 37 81 00 28 addi r1,sp,40
800fa60: 34 02 00 00 mvi r2,0
800fa64: fb ff cb 46 calli 800277c <gettimeofday>
800fa68: 2b 81 00 28 lw r1,(sp+40)
800fa6c: 59 81 00 40 sw (r12+64),r1
return copied;
}
800fa70: b9 a0 08 00 mv r1,r13
800fa74: 2b 9d 00 04 lw ra,(sp+4)
800fa78: 2b 8b 00 24 lw r11,(sp+36)
800fa7c: 2b 8c 00 20 lw r12,(sp+32)
800fa80: 2b 8d 00 1c lw r13,(sp+28)
800fa84: 2b 8e 00 18 lw r14,(sp+24)
800fa88: 2b 8f 00 14 lw r15,(sp+20)
800fa8c: 2b 90 00 10 lw r16,(sp+16)
800fa90: 2b 91 00 0c lw r17,(sp+12)
800fa94: 2b 92 00 08 lw r18,(sp+8)
800fa98: 37 9c 00 2c addi sp,sp,44
800fa9c: c3 a0 00 00 ret
0800fbc0 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
800fbc0: 37 9c ff e0 addi sp,sp,-32
800fbc4: 5b 8b 00 20 sw (sp+32),r11
800fbc8: 5b 8c 00 1c sw (sp+28),r12
800fbcc: 5b 8d 00 18 sw (sp+24),r13
800fbd0: 5b 8e 00 14 sw (sp+20),r14
800fbd4: 5b 8f 00 10 sw (sp+16),r15
800fbd8: 5b 90 00 0c sw (sp+12),r16
800fbdc: 5b 91 00 08 sw (sp+8),r17
800fbe0: 5b 9d 00 04 sw (sp+4),ra
800fbe4: b8 20 58 00 mv r11,r1
/*
* Eventually this could be set smarter at each call to
* memfile_free_blocks_in_table to greatly speed this up.
*/
to_free = IMFS_MEMFILE_BLOCK_SLOTS;
800fbe8: 78 01 08 01 mvhi r1,0x801
800fbec: 38 21 97 48 ori r1,r1,0x9748
800fbf0: 28 21 00 00 lw r1,(r1+0)
800fbf4: 34 02 00 02 mvi r2,2
800fbf8: f8 00 1d 14 calli 8017048 <__lshrsi3>
800fbfc: b8 20 60 00 mv r12,r1
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
800fc00: 29 61 00 58 lw r1,(r11+88)
800fc04: 44 20 00 04 be r1,r0,800fc14 <IMFS_memfile_remove+0x54>
memfile_free_blocks_in_table( &info->indirect, to_free );
800fc08: 35 61 00 58 addi r1,r11,88
800fc0c: b9 80 10 00 mv r2,r12
800fc10: fb ff ff d0 calli 800fb50 <memfile_free_blocks_in_table>
}
if ( info->doubly_indirect ) {
800fc14: 29 61 00 5c lw r1,(r11+92)
800fc18: 44 20 00 15 be r1,r0,800fc6c <IMFS_memfile_remove+0xac>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
800fc1c: 78 0d 08 01 mvhi r13,0x801
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
800fc20: 34 0f 00 00 mvi r15,0
800fc24: 34 0e 00 00 mvi r14,0
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
800fc28: 39 ad 97 48 ori r13,r13,0x9748
800fc2c: e0 00 00 09 bi 800fc50 <IMFS_memfile_remove+0x90>
if ( info->doubly_indirect[i] ) {
800fc30: 29 61 00 5c lw r1,(r11+92)
800fc34: b4 2f 08 00 add r1,r1,r15
800fc38: 28 22 00 00 lw r2,(r1+0)
800fc3c: 44 40 00 03 be r2,r0,800fc48 <IMFS_memfile_remove+0x88> <== NEVER TAKEN
memfile_free_blocks_in_table(
800fc40: b9 80 10 00 mv r2,r12
800fc44: fb ff ff c3 calli 800fb50 <memfile_free_blocks_in_table>
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
800fc48: 35 ce 00 01 addi r14,r14,1
800fc4c: 35 ef 00 04 addi r15,r15,4
800fc50: 29 a1 00 00 lw r1,(r13+0)
800fc54: 34 02 00 02 mvi r2,2
800fc58: f8 00 1c fc calli 8017048 <__lshrsi3>
800fc5c: 54 2e ff f5 bgu r1,r14,800fc30 <IMFS_memfile_remove+0x70>
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
(block_p **)&info->doubly_indirect[i], to_free );
}
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
800fc60: 35 61 00 5c addi r1,r11,92
800fc64: b9 80 10 00 mv r2,r12
800fc68: fb ff ff ba calli 800fb50 <memfile_free_blocks_in_table>
}
if ( info->triply_indirect ) {
800fc6c: 29 61 00 60 lw r1,(r11+96)
800fc70: 44 20 00 24 be r1,r0,800fd00 <IMFS_memfile_remove+0x140>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
800fc74: 78 0e 08 01 mvhi r14,0x801
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
800fc78: 34 0f 00 00 mvi r15,0
800fc7c: 34 10 00 00 mvi r16,0
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
800fc80: 39 ce 97 48 ori r14,r14,0x9748
800fc84: e0 00 00 18 bi 800fce4 <IMFS_memfile_remove+0x124>
p = (block_p *) info->triply_indirect[i];
800fc88: 29 61 00 60 lw r1,(r11+96)
800fc8c: b4 2f 08 00 add r1,r1,r15
800fc90: 28 2d 00 00 lw r13,(r1+0)
if ( !p ) /* ensure we have a valid pointer */
800fc94: 45 a0 00 18 be r13,r0,800fcf4 <IMFS_memfile_remove+0x134> <== NEVER TAKEN
800fc98: 34 11 00 00 mvi r17,0
800fc9c: e0 00 00 08 bi 800fcbc <IMFS_memfile_remove+0xfc>
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
800fca0: 29 a1 00 00 lw r1,(r13+0)
800fca4: 44 20 00 04 be r1,r0,800fcb4 <IMFS_memfile_remove+0xf4> <== NEVER TAKEN
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
800fca8: b9 a0 08 00 mv r1,r13
800fcac: b9 80 10 00 mv r2,r12
800fcb0: fb ff ff a8 calli 800fb50 <memfile_free_blocks_in_table>
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
800fcb4: 36 31 00 01 addi r17,r17,1
800fcb8: 35 ad 00 04 addi r13,r13,4
800fcbc: 29 c1 00 00 lw r1,(r14+0)
800fcc0: 34 02 00 02 mvi r2,2
800fcc4: f8 00 1c e1 calli 8017048 <__lshrsi3>
800fcc8: 54 31 ff f6 bgu r1,r17,800fca0 <IMFS_memfile_remove+0xe0>
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
800fccc: 29 61 00 60 lw r1,(r11+96)
800fcd0: b9 80 10 00 mv r2,r12
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
800fcd4: 36 10 00 01 addi r16,r16,1
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
800fcd8: b4 2f 08 00 add r1,r1,r15
800fcdc: fb ff ff 9d calli 800fb50 <memfile_free_blocks_in_table>
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
800fce0: 35 ef 00 04 addi r15,r15,4
800fce4: 29 c1 00 00 lw r1,(r14+0)
800fce8: 34 02 00 02 mvi r2,2
800fcec: f8 00 1c d7 calli 8017048 <__lshrsi3>
800fcf0: 54 30 ff e6 bgu r1,r16,800fc88 <IMFS_memfile_remove+0xc8>
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
800fcf4: 35 61 00 60 addi r1,r11,96
800fcf8: b9 80 10 00 mv r2,r12
800fcfc: fb ff ff 95 calli 800fb50 <memfile_free_blocks_in_table>
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
800fd00: 34 01 00 00 mvi r1,0
800fd04: 2b 9d 00 04 lw ra,(sp+4)
800fd08: 2b 8b 00 20 lw r11,(sp+32)
800fd0c: 2b 8c 00 1c lw r12,(sp+28)
800fd10: 2b 8d 00 18 lw r13,(sp+24)
800fd14: 2b 8e 00 14 lw r14,(sp+20)
800fd18: 2b 8f 00 10 lw r15,(sp+16)
800fd1c: 2b 90 00 0c lw r16,(sp+12)
800fd20: 2b 91 00 08 lw r17,(sp+8)
800fd24: 37 9c 00 20 addi sp,sp,32
800fd28: c3 a0 00 00 ret
0800feb4 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
800feb4: 37 9c ff d0 addi sp,sp,-48
800feb8: 5b 8b 00 28 sw (sp+40),r11
800febc: 5b 8c 00 24 sw (sp+36),r12
800fec0: 5b 8d 00 20 sw (sp+32),r13
800fec4: 5b 8e 00 1c sw (sp+28),r14
800fec8: 5b 8f 00 18 sw (sp+24),r15
800fecc: 5b 90 00 14 sw (sp+20),r16
800fed0: 5b 91 00 10 sw (sp+16),r17
800fed4: 5b 92 00 0c sw (sp+12),r18
800fed8: 5b 93 00 08 sw (sp+8),r19
800fedc: 5b 9d 00 04 sw (sp+4),ra
800fee0: b8 20 58 00 mv r11,r1
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
800fee4: 28 21 00 50 lw r1,(r1+80)
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
800fee8: b8 40 60 00 mv r12,r2
800feec: b8 60 88 00 mv r17,r3
800fef0: b8 80 80 00 mv r16,r4
/*
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
800fef4: b4 82 10 00 add r2,r4,r2
if ( last_byte > the_jnode->info.file.size ) {
800fef8: 48 01 00 05 bg r0,r1,800ff0c <IMFS_memfile_write+0x58> <== NEVER TAKEN
800fefc: 5c 20 00 0c bne r1,r0,800ff2c <IMFS_memfile_write+0x78> <== NEVER TAKEN
800ff00: 29 61 00 54 lw r1,(r11+84)
800ff04: 54 41 00 02 bgu r2,r1,800ff0c <IMFS_memfile_write+0x58> <== ALWAYS TAKEN
800ff08: e0 00 00 09 bi 800ff2c <IMFS_memfile_write+0x78> <== NOT EXECUTED
status = IMFS_memfile_extend( the_jnode, last_byte );
800ff0c: b9 60 08 00 mv r1,r11
800ff10: fb ff ff 93 calli 800fd5c <IMFS_memfile_extend>
if ( status )
800ff14: 44 20 00 06 be r1,r0,800ff2c <IMFS_memfile_write+0x78>
rtems_set_errno_and_return_minus_one( ENOSPC );
800ff18: f8 00 05 56 calli 8011470 <__errno>
800ff1c: 34 02 00 1c mvi r2,28
800ff20: 58 22 00 00 sw (r1+0),r2
800ff24: 34 05 ff ff mvi r5,-1
800ff28: e0 00 00 48 bi 8010048 <IMFS_memfile_write+0x194>
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
800ff2c: 78 01 08 01 mvhi r1,0x801
800ff30: 38 21 97 48 ori r1,r1,0x9748
800ff34: 28 33 00 00 lw r19,(r1+0)
800ff38: b9 80 08 00 mv r1,r12
unsigned int last_byte;
unsigned int start_offset;
int copied;
const unsigned char *src;
src = source;
800ff3c: ba 20 78 00 mv r15,r17
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
800ff40: ba 60 10 00 mv r2,r19
800ff44: f8 00 1c a4 calli 80171d4 <__modsi3>
800ff48: b8 20 90 00 mv r18,r1
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
800ff4c: ba 60 10 00 mv r2,r19
800ff50: b9 80 08 00 mv r1,r12
800ff54: f8 00 1c 70 calli 8017114 <__divsi3>
800ff58: b8 20 70 00 mv r14,r1
if ( start_offset ) {
800ff5c: ba 00 68 00 mv r13,r16
status = IMFS_memfile_extend( the_jnode, last_byte );
if ( status )
rtems_set_errno_and_return_minus_one( ENOSPC );
}
copied = 0;
800ff60: 34 0c 00 00 mvi r12,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;
if ( start_offset ) {
800ff64: 46 40 00 12 be r18,r0,800ffac <IMFS_memfile_write+0xf8>
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 );
800ff68: b9 60 08 00 mv r1,r11
800ff6c: b9 c0 10 00 mv r2,r14
800ff70: 34 03 00 00 mvi r3,0
800ff74: fb ff fd a8 calli 800f614 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
return copied;
800ff78: 34 05 00 00 mvi r5,0
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
800ff7c: 44 20 00 33 be r1,r0,8010048 <IMFS_memfile_write+0x194> <== NEVER TAKEN
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
800ff80: ca 72 60 00 sub r12,r19,r18
800ff84: 52 0c 00 02 bgeu r16,r12,800ff8c <IMFS_memfile_write+0xd8>
800ff88: ba 00 60 00 mv r12,r16
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
800ff8c: 28 21 00 00 lw r1,(r1+0)
800ff90: ba 20 10 00 mv r2,r17
800ff94: b9 80 18 00 mv r3,r12
800ff98: b4 32 08 00 add r1,r1,r18
800ff9c: f8 00 07 eb calli 8011f48 <memcpy>
src += to_copy;
800ffa0: b6 2c 78 00 add r15,r17,r12
block++;
800ffa4: 35 ce 00 01 addi r14,r14,1
my_length -= to_copy;
800ffa8: ca 0c 68 00 sub r13,r16,r12
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
800ffac: 78 01 08 01 mvhi r1,0x801
800ffb0: 38 21 97 48 ori r1,r1,0x9748
800ffb4: 28 30 00 00 lw r16,(r1+0)
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
800ffb8: b8 20 88 00 mv r17,r1
800ffbc: e0 00 00 0e bi 800fff4 <IMFS_memfile_write+0x140>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
800ffc0: b9 60 08 00 mv r1,r11
800ffc4: b9 c0 10 00 mv r2,r14
800ffc8: 34 03 00 00 mvi r3,0
800ffcc: fb ff fd 92 calli 800f614 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
800ffd0: 44 20 00 1d be r1,r0,8010044 <IMFS_memfile_write+0x190> <== NEVER TAKEN
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
800ffd4: 28 21 00 00 lw r1,(r1+0)
800ffd8: b9 e0 10 00 mv r2,r15
800ffdc: ba 00 18 00 mv r3,r16
800ffe0: f8 00 07 da calli 8011f48 <memcpy>
src += to_copy;
800ffe4: b5 f0 78 00 add r15,r15,r16
block++;
800ffe8: 35 ce 00 01 addi r14,r14,1
my_length -= to_copy;
800ffec: c9 b0 68 00 sub r13,r13,r16
* IMFS_memfile_write
*
* This routine writes the specified data buffer into the in memory
* file pointed to by the_jnode. The file is extended as needed.
*/
MEMFILE_STATIC ssize_t IMFS_memfile_write(
800fff0: b5 90 60 00 add r12,r12,r16
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
800fff4: 2a 21 00 00 lw r1,(r17+0)
800fff8: 51 a1 ff f2 bgeu r13,r1,800ffc0 <IMFS_memfile_write+0x10c>
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
800fffc: 45 a0 00 0c be r13,r0,801002c <IMFS_memfile_write+0x178>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
8010000: b9 60 08 00 mv r1,r11
8010004: b9 c0 10 00 mv r2,r14
8010008: 34 03 00 00 mvi r3,0
801000c: fb ff fd 82 calli 800f614 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
8010010: b9 80 28 00 mv r5,r12
8010014: 44 20 00 0d be r1,r0,8010048 <IMFS_memfile_write+0x194> <== NEVER TAKEN
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, my_length );
8010018: 28 21 00 00 lw r1,(r1+0)
801001c: b9 e0 10 00 mv r2,r15
8010020: b9 a0 18 00 mv r3,r13
8010024: f8 00 07 c9 calli 8011f48 <memcpy>
my_length = 0;
copied += to_copy;
8010028: b5 8d 60 00 add r12,r12,r13
}
IMFS_mtime_ctime_update( the_jnode );
801002c: 37 81 00 2c addi r1,sp,44
8010030: 34 02 00 00 mvi r2,0
8010034: fb ff c9 d2 calli 800277c <gettimeofday>
8010038: 2b 81 00 2c lw r1,(sp+44)
801003c: 59 61 00 44 sw (r11+68),r1
8010040: 59 61 00 48 sw (r11+72),r1
*/
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 )
8010044: b9 80 28 00 mv r5,r12
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
8010048: b8 a0 08 00 mv r1,r5
801004c: 2b 9d 00 04 lw ra,(sp+4)
8010050: 2b 8b 00 28 lw r11,(sp+40)
8010054: 2b 8c 00 24 lw r12,(sp+36)
8010058: 2b 8d 00 20 lw r13,(sp+32)
801005c: 2b 8e 00 1c lw r14,(sp+28)
8010060: 2b 8f 00 18 lw r15,(sp+24)
8010064: 2b 90 00 14 lw r16,(sp+20)
8010068: 2b 91 00 10 lw r17,(sp+16)
801006c: 2b 92 00 0c lw r18,(sp+12)
8010070: 2b 93 00 08 lw r19,(sp+8)
8010074: 37 9c 00 30 addi sp,sp,48
8010078: c3 a0 00 00 ret
08001f08 <IMFS_mount>:
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
8001f08: 37 9c ff fc addi sp,sp,-4
8001f0c: 5b 9d 00 04 sw (sp+4),ra
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
8001f10: 28 22 00 08 lw r2,(r1+8)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
8001f14: 34 03 00 01 mvi r3,1
8001f18: 28 44 00 4c lw r4,(r2+76)
8001f1c: 44 83 00 06 be r4,r3,8001f34 <IMFS_mount+0x2c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
8001f20: f8 00 3d 54 calli 8011470 <__errno> <== NOT EXECUTED
8001f24: 34 02 00 14 mvi r2,20 <== NOT EXECUTED
8001f28: 58 22 00 00 sw (r1+0),r2 <== NOT EXECUTED
8001f2c: 34 01 ff ff mvi r1,-1 <== NOT EXECUTED
8001f30: e0 00 00 03 bi 8001f3c <IMFS_mount+0x34> <== NOT EXECUTED
/*
* Set mt_fs pointer to point to the mount table entry for
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
8001f34: 58 41 00 5c sw (r2+92),r1
return 0;
8001f38: 34 01 00 00 mvi r1,0
}
8001f3c: 2b 9d 00 04 lw ra,(sp+4)
8001f40: 37 9c 00 04 addi sp,sp,4
8001f44: c3 a0 00 00 ret
08003860 <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
8003860: 37 9c ff f0 addi sp,sp,-16
8003864: 5b 8b 00 10 sw (sp+16),r11
8003868: 5b 8c 00 0c sw (sp+12),r12
800386c: 5b 8d 00 08 sw (sp+8),r13
8003870: 5b 9d 00 04 sw (sp+4),ra
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
8003874: 78 0c 08 02 mvhi r12,0x802
8003878: 39 8c 81 f0 ori r12,r12,0x81f0
800387c: 29 82 00 00 lw r2,(r12+0)
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
8003880: b8 20 58 00 mv r11,r1
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
8003884: 34 21 00 0c addi r1,r1,12
8003888: 28 42 00 08 lw r2,(r2+8)
800388c: f8 00 38 0b calli 80118b8 <fputs>
switch( the_jnode->type ) {
8003890: 29 63 00 4c lw r3,(r11+76)
8003894: 34 02 00 06 mvi r2,6
8003898: 34 61 ff ff addi r1,r3,-1
800389c: 54 22 00 2d bgu r1,r2,8003950 <IMFS_print_jnode+0xf0> <== NEVER TAKEN
80038a0: 78 0d 08 02 mvhi r13,0x802
80038a4: 34 02 00 02 mvi r2,2
80038a8: f8 00 80 4b calli 80239d4 <__ashlsi3>
80038ac: 39 ad 58 e4 ori r13,r13,0x58e4
80038b0: b5 a1 08 00 add r1,r13,r1
80038b4: 28 21 00 00 lw r1,(r1+0)
80038b8: c0 20 00 00 b r1
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
80038bc: 29 82 00 00 lw r2,(r12+0)
80038c0: 34 01 00 2f mvi r1,47
80038c4: 28 42 00 08 lw r2,(r2+8)
80038c8: f8 00 37 b8 calli 80117a8 <fputc>
break;
80038cc: e0 00 00 27 bi 8003968 <IMFS_print_jnode+0x108>
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
80038d0: 29 81 00 00 lw r1,(r12+0)
80038d4: 78 02 08 02 mvhi r2,0x802
80038d8: 38 42 58 00 ori r2,r2,0x5800
80038dc: 28 21 00 08 lw r1,(r1+8)
80038e0: 29 63 00 50 lw r3,(r11+80)
80038e4: 29 64 00 54 lw r4,(r11+84)
80038e8: e0 00 00 07 bi 8003904 <IMFS_print_jnode+0xa4>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
80038ec: 29 81 00 00 lw r1,(r12+0)
80038f0: 29 63 00 54 lw r3,(r11+84)
80038f4: 29 64 00 58 lw r4,(r11+88)
80038f8: 28 21 00 08 lw r1,(r1+8)
80038fc: 78 02 08 02 mvhi r2,0x802
8003900: 38 42 58 14 ori r2,r2,0x5814
8003904: f8 00 37 82 calli 801170c <fprintf>
(uint32_t)the_jnode->info.linearfile.size,
the_jnode->info.linearfile.direct
);
break;
8003908: e0 00 00 18 bi 8003968 <IMFS_print_jnode+0x108>
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
800390c: 29 81 00 00 lw r1,(r12+0)
8003910: 29 63 00 54 lw r3,(r11+84)
8003914: 78 02 08 02 mvhi r2,0x802
8003918: 28 21 00 08 lw r1,(r1+8)
800391c: 38 42 58 24 ori r2,r2,0x5824
8003920: f8 00 37 7b calli 801170c <fprintf>
(uint32_t)the_jnode->info.file.size );
#endif
break;
8003924: e0 00 00 11 bi 8003968 <IMFS_print_jnode+0x108>
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
8003928: 78 01 08 02 mvhi r1,0x802
800392c: 29 82 00 00 lw r2,(r12+0)
8003930: 38 21 58 30 ori r1,r1,0x5830
8003934: e0 00 00 04 bi 8003944 <IMFS_print_jnode+0xe4>
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
8003938: 29 82 00 00 lw r2,(r12+0)
800393c: 78 01 08 02 mvhi r1,0x802
8003940: 38 21 58 44 ori r1,r1,0x5844
8003944: 28 42 00 08 lw r2,(r2+8)
8003948: f8 00 37 dc calli 80118b8 <fputs>
return;
800394c: e0 00 00 0a bi 8003974 <IMFS_print_jnode+0x114>
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
8003950: 29 81 00 00 lw r1,(r12+0) <== NOT EXECUTED
8003954: 78 02 08 02 mvhi r2,0x802 <== NOT EXECUTED
8003958: 38 42 58 58 ori r2,r2,0x5858 <== NOT EXECUTED
800395c: 28 21 00 08 lw r1,(r1+8) <== NOT EXECUTED
8003960: f8 00 37 6b calli 801170c <fprintf> <== NOT EXECUTED
return;
8003964: e0 00 00 04 bi 8003974 <IMFS_print_jnode+0x114> <== NOT EXECUTED
}
puts("");
8003968: 78 01 08 02 mvhi r1,0x802
800396c: 38 21 53 c8 ori r1,r1,0x53c8
8003970: f8 00 3f 49 calli 8013694 <puts>
}
8003974: 2b 9d 00 04 lw ra,(sp+4)
8003978: 2b 8b 00 10 lw r11,(sp+16)
800397c: 2b 8c 00 0c lw r12,(sp+12)
8003980: 2b 8d 00 08 lw r13,(sp+8)
8003984: 37 9c 00 10 addi sp,sp,16
8003988: c3 a0 00 00 ret
08001f84 <IMFS_rename>:
rtems_filesystem_location_info_t *old_parent_loc, /* IN */
rtems_filesystem_location_info_t *old_loc, /* IN */
rtems_filesystem_location_info_t *new_parent_loc, /* IN */
const char *new_name /* IN */
)
{
8001f84: 37 9c ff ec addi sp,sp,-20
8001f88: 5b 8b 00 0c sw (sp+12),r11
8001f8c: 5b 8c 00 08 sw (sp+8),r12
8001f90: 5b 9d 00 04 sw (sp+4),ra
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
8001f94: 28 4b 00 00 lw r11,(r2+0)
rtems_filesystem_location_info_t *old_parent_loc, /* IN */
rtems_filesystem_location_info_t *old_loc, /* IN */
rtems_filesystem_location_info_t *new_parent_loc, /* IN */
const char *new_name /* IN */
)
{
8001f98: b8 60 60 00 mv r12,r3
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
8001f9c: b8 80 10 00 mv r2,r4
8001fa0: 35 61 00 0c addi r1,r11,12
8001fa4: 34 03 00 20 mvi r3,32
8001fa8: f8 00 41 c2 calli 80126b0 <strncpy>
if ( the_jnode->Parent != NULL )
8001fac: 29 61 00 08 lw r1,(r11+8)
8001fb0: 44 20 00 03 be r1,r0,8001fbc <IMFS_rename+0x38> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
8001fb4: b9 60 08 00 mv r1,r11
8001fb8: f8 00 0a f0 calli 8004b78 <_Chain_Extract>
rtems_chain_extract( (rtems_chain_node *) the_jnode );
new_parent = new_parent_loc->node_access;
8001fbc: 29 81 00 00 lw r1,(r12+0)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
8001fc0: b9 60 10 00 mv r2,r11
the_jnode->Parent = new_parent;
8001fc4: 59 61 00 08 sw (r11+8),r1
8001fc8: 34 21 00 50 addi r1,r1,80
8001fcc: f8 00 0a df calli 8004b48 <_Chain_Append>
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
8001fd0: 37 81 00 10 addi r1,sp,16
8001fd4: 34 02 00 00 mvi r2,0
8001fd8: f8 00 01 e9 calli 800277c <gettimeofday>
8001fdc: 2b 81 00 10 lw r1,(sp+16)
8001fe0: 59 61 00 48 sw (r11+72),r1
return 0;
}
8001fe4: 34 01 00 00 mvi r1,0
8001fe8: 2b 9d 00 04 lw ra,(sp+4)
8001fec: 2b 8b 00 0c lw r11,(sp+12)
8001ff0: 2b 8c 00 08 lw r12,(sp+8)
8001ff4: 37 9c 00 14 addi sp,sp,20
8001ff8: c3 a0 00 00 ret
0800c47c <IMFS_stat>:
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
800c47c: 37 9c ff ec addi sp,sp,-20
800c480: 5b 8b 00 14 sw (sp+20),r11
800c484: 5b 8c 00 10 sw (sp+16),r12
800c488: 5b 8d 00 0c sw (sp+12),r13
800c48c: 5b 8e 00 08 sw (sp+8),r14
800c490: 5b 9d 00 04 sw (sp+4),ra
IMFS_fs_info_t *fs_info;
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
800c494: 28 2b 00 00 lw r11,(r1+0)
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
800c498: b8 20 70 00 mv r14,r1
800c49c: b8 40 60 00 mv r12,r2
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
800c4a0: 29 61 00 4c lw r1,(r11+76)
800c4a4: 34 02 00 05 mvi r2,5
800c4a8: 34 21 ff fe addi r1,r1,-2
800c4ac: 54 22 00 12 bgu r1,r2,800c4f4 <IMFS_stat+0x78> <== NEVER TAKEN
800c4b0: 78 0d 08 01 mvhi r13,0x801
800c4b4: 34 02 00 02 mvi r2,2
800c4b8: f8 00 2a 96 calli 8016f10 <__ashlsi3>
800c4bc: 39 ad 84 38 ori r13,r13,0x8438
800c4c0: b5 a1 08 00 add r1,r13,r1
800c4c4: 28 21 00 00 lw r1,(r1+0)
800c4c8: c0 20 00 00 b r1
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
800c4cc: 29 61 00 54 lw r1,(r11+84)
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
800c4d0: 29 62 00 50 lw r2,(r11+80)
800c4d4: 59 81 00 1c sw (r12+28),r1
800c4d8: 59 82 00 18 sw (r12+24),r2
break;
800c4dc: e0 00 00 0b bi 800c508 <IMFS_stat+0x8c>
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
800c4e0: 29 61 00 54 lw r1,(r11+84)
800c4e4: 59 81 00 20 sw (r12+32),r1
break;
800c4e8: e0 00 00 08 bi 800c508 <IMFS_stat+0x8c>
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
800c4ec: 59 80 00 20 sw (r12+32),r0
break;
800c4f0: e0 00 00 06 bi 800c508 <IMFS_stat+0x8c>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
800c4f4: f8 00 13 df calli 8011470 <__errno>
800c4f8: 34 02 00 86 mvi r2,134
800c4fc: 58 22 00 00 sw (r1+0),r2
800c500: 34 01 ff ff mvi r1,-1
800c504: e0 00 00 18 bi 800c564 <IMFS_stat+0xe8>
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
800c508: 29 c1 00 10 lw r1,(r14+16)
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
800c50c: 28 21 00 34 lw r1,(r1+52)
800c510: 28 22 00 00 lw r2,(r1+0)
800c514: 38 01 ff fe mvu r1,0xfffe
/*
* 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 =
800c518: 59 81 00 00 sw (r12+0),r1
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
800c51c: 29 61 00 30 lw r1,(r11+48)
/*
* 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 =
800c520: 59 82 00 04 sw (r12+4),r2
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
800c524: 59 81 00 0c sw (r12+12),r1
buf->st_nlink = the_jnode->st_nlink;
800c528: 2d 61 00 34 lhu r1,(r11+52)
800c52c: 0d 81 00 10 sh (r12+16),r1
buf->st_ino = the_jnode->st_ino;
800c530: 29 61 00 38 lw r1,(r11+56)
800c534: 59 81 00 08 sw (r12+8),r1
buf->st_uid = the_jnode->st_uid;
800c538: 2d 61 00 3c lhu r1,(r11+60)
800c53c: 0d 81 00 12 sh (r12+18),r1
buf->st_gid = the_jnode->st_gid;
800c540: 2d 61 00 3e lhu r1,(r11+62)
800c544: 0d 81 00 14 sh (r12+20),r1
buf->st_atime = the_jnode->stat_atime;
800c548: 29 61 00 40 lw r1,(r11+64)
800c54c: 59 81 00 24 sw (r12+36),r1
buf->st_mtime = the_jnode->stat_mtime;
800c550: 29 61 00 44 lw r1,(r11+68)
800c554: 59 81 00 2c sw (r12+44),r1
buf->st_ctime = the_jnode->stat_ctime;
800c558: 29 61 00 48 lw r1,(r11+72)
800c55c: 59 81 00 34 sw (r12+52),r1
return 0;
800c560: 34 01 00 00 mvi r1,0
}
800c564: 2b 9d 00 04 lw ra,(sp+4)
800c568: 2b 8b 00 14 lw r11,(sp+20)
800c56c: 2b 8c 00 10 lw r12,(sp+16)
800c570: 2b 8d 00 0c lw r13,(sp+12)
800c574: 2b 8e 00 08 lw r14,(sp+8)
800c578: 37 9c 00 14 addi sp,sp,20
800c57c: c3 a0 00 00 ret
080020a8 <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
80020a8: 37 9c ff d0 addi sp,sp,-48
80020ac: 5b 8b 00 14 sw (sp+20),r11
80020b0: 5b 8c 00 10 sw (sp+16),r12
80020b4: 5b 8d 00 0c sw (sp+12),r13
80020b8: 5b 8e 00 08 sw (sp+8),r14
80020bc: 5b 9d 00 04 sw (sp+4),ra
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
80020c0: 28 4c 00 00 lw r12,(r2+0)
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
80020c4: b8 40 58 00 mv r11,r2
80020c8: b8 20 68 00 mv r13,r1
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
80020cc: 29 82 00 4c lw r2,(r12+76)
80020d0: 34 01 00 03 mvi r1,3
80020d4: 5c 41 00 28 bne r2,r1,8002174 <IMFS_unlink+0xcc>
if ( !node->info.hard_link.link_node )
80020d8: 29 81 00 50 lw r1,(r12+80)
80020dc: 5c 20 00 06 bne r1,r0,80020f4 <IMFS_unlink+0x4c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
80020e0: f8 00 3c e4 calli 8011470 <__errno> <== NOT EXECUTED
80020e4: 34 02 00 16 mvi r2,22 <== NOT EXECUTED
80020e8: 58 22 00 00 sw (r1+0),r2 <== NOT EXECUTED
80020ec: 34 02 ff ff mvi r2,-1 <== NOT EXECUTED
80020f0: e0 00 00 27 bi 800218c <IMFS_unlink+0xe4> <== NOT EXECUTED
the_link = *loc;
80020f4: 29 64 00 08 lw r4,(r11+8)
80020f8: 29 63 00 0c lw r3,(r11+12)
80020fc: 29 65 00 04 lw r5,(r11+4)
8002100: 29 62 00 10 lw r2,(r11+16)
the_link.node_access = node->info.hard_link.link_node;
IMFS_Set_handlers( &the_link );
8002104: 37 8e 00 18 addi r14,sp,24
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
the_link.node_access = node->info.hard_link.link_node;
8002108: 5b 81 00 18 sw (sp+24),r1
IMFS_Set_handlers( &the_link );
800210c: b9 c0 08 00 mv r1,r14
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
8002110: 5b 84 00 20 sw (sp+32),r4
8002114: 5b 83 00 24 sw (sp+36),r3
8002118: 5b 85 00 1c sw (sp+28),r5
800211c: 5b 82 00 28 sw (sp+40),r2
the_link.node_access = node->info.hard_link.link_node;
IMFS_Set_handlers( &the_link );
8002120: f8 00 25 ae calli 800b7d8 <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)
8002124: 29 83 00 50 lw r3,(r12+80)
8002128: 34 01 00 01 mvi r1,1
800212c: 2c 64 00 34 lhu r4,(r3+52)
8002130: 5c 81 00 09 bne r4,r1,8002154 <IMFS_unlink+0xac>
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
8002134: 2b 81 00 20 lw r1,(sp+32)
8002138: b9 c0 10 00 mv r2,r14
800213c: 28 23 00 34 lw r3,(r1+52)
8002140: b9 a0 08 00 mv r1,r13
8002144: d8 60 00 00 call r3
if ( result != 0 )
return -1;
8002148: 34 02 ff ff mvi r2,-1
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
if ( result != 0 )
800214c: 44 20 00 0a be r1,r0,8002174 <IMFS_unlink+0xcc>
8002150: e0 00 00 0f bi 800218c <IMFS_unlink+0xe4>
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
8002154: 34 84 ff ff addi r4,r4,-1
IMFS_update_ctime( node->info.hard_link.link_node );
8002158: 34 02 00 00 mvi r2,0
if ( result != 0 )
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
800215c: 0c 64 00 34 sh (r3+52),r4
IMFS_update_ctime( node->info.hard_link.link_node );
8002160: 37 81 00 2c addi r1,sp,44
8002164: f8 00 01 86 calli 800277c <gettimeofday>
8002168: 29 81 00 50 lw r1,(r12+80)
800216c: 2b 82 00 2c lw r2,(sp+44)
8002170: 58 22 00 48 sw (r1+72),r2
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
8002174: 29 61 00 08 lw r1,(r11+8)
8002178: b9 60 10 00 mv r2,r11
800217c: 28 23 00 34 lw r3,(r1+52)
8002180: b9 a0 08 00 mv r1,r13
8002184: d8 60 00 00 call r3
8002188: b8 20 10 00 mv r2,r1
return result;
}
800218c: b8 40 08 00 mv r1,r2
8002190: 2b 9d 00 04 lw ra,(sp+4)
8002194: 2b 8b 00 14 lw r11,(sp+20)
8002198: 2b 8c 00 10 lw r12,(sp+16)
800219c: 2b 8d 00 0c lw r13,(sp+12)
80021a0: 2b 8e 00 08 lw r14,(sp+8)
80021a4: 37 9c 00 30 addi sp,sp,48
80021a8: c3 a0 00 00 ret
080021ac <IMFS_unmount>:
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
80021ac: 37 9c ff fc addi sp,sp,-4
80021b0: 5b 9d 00 04 sw (sp+4),ra
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
80021b4: 28 21 00 08 lw r1,(r1+8)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
80021b8: 34 02 00 01 mvi r2,1
80021bc: 28 23 00 4c lw r3,(r1+76)
80021c0: 44 62 00 04 be r3,r2,80021d0 <IMFS_unmount+0x24> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
80021c4: f8 00 3c ab calli 8011470 <__errno> <== NOT EXECUTED
80021c8: 34 02 00 14 mvi r2,20 <== NOT EXECUTED
80021cc: e0 00 00 05 bi 80021e0 <IMFS_unmount+0x34> <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
80021d0: 28 22 00 5c lw r2,(r1+92)
80021d4: 5c 40 00 06 bne r2,r0,80021ec <IMFS_unmount+0x40> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
80021d8: f8 00 3c a6 calli 8011470 <__errno> <== NOT EXECUTED
80021dc: 34 02 00 16 mvi r2,22 <== NOT EXECUTED
80021e0: 58 22 00 00 sw (r1+0),r2 <== NOT EXECUTED
80021e4: 34 01 ff ff mvi r1,-1 <== NOT EXECUTED
80021e8: e0 00 00 03 bi 80021f4 <IMFS_unmount+0x48> <== NOT EXECUTED
/*
* Set the mt_fs pointer to indicate that there is no longer
* a file system mounted to this point.
*/
node->info.directory.mt_fs = NULL;
80021ec: 58 20 00 5c sw (r1+92),r0
return 0;
80021f0: 34 01 00 00 mvi r1,0
}
80021f4: 2b 9d 00 04 lw ra,(sp+4)
80021f8: 37 9c 00 04 addi sp,sp,4
80021fc: c3 a0 00 00 ret
08001074 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
8001074: 37 9c ff d4 addi sp,sp,-44
8001078: 5b 8b 00 24 sw (sp+36),r11
800107c: 5b 8c 00 20 sw (sp+32),r12
8001080: 5b 8d 00 1c sw (sp+28),r13
8001084: 5b 8e 00 18 sw (sp+24),r14
8001088: 5b 8f 00 14 sw (sp+20),r15
800108c: 5b 90 00 10 sw (sp+16),r16
8001090: 5b 91 00 0c sw (sp+12),r17
8001094: 5b 92 00 08 sw (sp+8),r18
8001098: 5b 9d 00 04 sw (sp+4),ra
800109c: b8 20 68 00 mv r13,r1
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
80010a0: 34 01 ff ff mvi r1,-1
80010a4: 5d a1 00 08 bne r13,r1,80010c4 <Stack_check_Dump_threads_usage+0x50>
if (!Stack_check_Interrupt_stack.area)
80010a8: 78 0c 08 01 mvhi r12,0x801
80010ac: 39 8c 77 d0 ori r12,r12,0x77d0
80010b0: 29 81 00 04 lw r1,(r12+4)
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
current = 0;
80010b4: 34 10 00 00 mvi r16,0
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
if (!Stack_check_Interrupt_stack.area)
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
80010b8: 34 0d 00 00 mvi r13,0
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
if (!Stack_check_Interrupt_stack.area)
80010bc: 5c 20 00 04 bne r1,r0,80010cc <Stack_check_Dump_threads_usage+0x58><== ALWAYS TAKEN
80010c0: e0 00 00 54 bi 8001210 <Stack_check_Dump_threads_usage+0x19c><== NOT EXECUTED
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
80010c4: 29 b0 01 08 lw r16,(r13+264)
the_thread = 0;
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
80010c8: 35 ac 00 b8 addi r12,r13,184
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
80010cc: 29 8f 00 00 lw r15,(r12+0)
{
const uint32_t *base, *ebase;
uint32_t length;
base = s;
length = n/4;
80010d0: 34 02 00 02 mvi r2,2
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
80010d4: 29 8b 00 04 lw r11,(r12+4)
size = Stack_check_usable_stack_size(stack);
80010d8: 35 ef ff f0 addi r15,r15,-16
{
const uint32_t *base, *ebase;
uint32_t length;
base = s;
length = n/4;
80010dc: b9 e0 08 00 mv r1,r15
80010e0: f8 00 4f 00 calli 8014ce0 <__lshrsi3>
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
80010e4: 34 02 00 02 mvi r2,2
80010e8: f8 00 4e b0 calli 8014ba8 <__ashlsi3>
if (*base != U32_PATTERN)
80010ec: 78 03 08 01 mvhi r3,0x801
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
80010f0: 35 71 00 10 addi r17,r11,16
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
if (*base != U32_PATTERN)
80010f4: 38 63 60 98 ori r3,r3,0x6098
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
80010f8: 35 6b 00 20 addi r11,r11,32
for (ebase = base + length; base < ebase; base++)
80010fc: b5 61 08 00 add r1,r11,r1
if (*base != U32_PATTERN)
8001100: 28 62 00 00 lw r2,(r3+0)
8001104: e0 00 00 04 bi 8001114 <Stack_check_Dump_threads_usage+0xa0>
8001108: 29 63 00 00 lw r3,(r11+0)
800110c: 5c 62 00 05 bne r3,r2,8001120 <Stack_check_Dump_threads_usage+0xac>
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
8001110: 35 6b 00 04 addi r11,r11,4
8001114: 54 2b ff fd bgu r1,r11,8001108 <Stack_check_Dump_threads_usage+0x94><== ALWAYS TAKEN
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;
8001118: 34 0e 00 00 mvi r14,0 <== NOT EXECUTED
800111c: e0 00 00 05 bi 8001130 <Stack_check_Dump_threads_usage+0xbc><== NOT EXECUTED
8001120: 34 0e 00 00 mvi r14,0
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 )
8001124: 45 60 00 03 be r11,r0,8001130 <Stack_check_Dump_threads_usage+0xbc><== NEVER TAKEN
used = Stack_check_Calculate_used( low, size, high_water_mark );
8001128: b6 2f 70 00 add r14,r17,r15
800112c: c9 cb 70 00 sub r14,r14,r11
8001130: 78 04 08 01 mvhi r4,0x801
8001134: 78 02 08 01 mvhi r2,0x801
8001138: 38 84 77 30 ori r4,r4,0x7730
800113c: 38 42 77 2c ori r2,r2,0x772c
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
8001140: 45 a0 00 0f be r13,r0,800117c <Stack_check_Dump_threads_usage+0x108>
#endif
{
(*print_handler)(
8001144: 29 ab 00 08 lw r11,(r13+8)
8001148: 28 52 00 00 lw r18,(r2+0)
800114c: 37 83 00 28 addi r3,sp,40
8001150: b9 60 08 00 mv r1,r11
8001154: 34 02 00 05 mvi r2,5
8001158: 28 91 00 00 lw r17,(r4+0)
800115c: f8 00 12 00 calli 800595c <rtems_object_get_name>
8001160: 78 02 08 01 mvhi r2,0x801
8001164: b8 20 20 00 mv r4,r1
8001168: 38 42 5f 00 ori r2,r2,0x5f00
800116c: ba 40 08 00 mv r1,r18
8001170: b9 60 18 00 mv r3,r11
8001174: da 20 00 00 call r17
8001178: e0 00 00 07 bi 8001194 <Stack_check_Dump_threads_usage+0x120>
rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
);
}
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
800117c: 28 41 00 00 lw r1,(r2+0)
8001180: 28 84 00 00 lw r4,(r4+0)
8001184: 78 02 08 01 mvhi r2,0x801
8001188: 38 42 5f 10 ori r2,r2,0x5f10
800118c: 34 03 ff ff mvi r3,-1
8001190: d8 80 00 00 call r4
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
8001194: 29 84 00 00 lw r4,(r12+0)
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
8001198: 78 0b 08 01 mvhi r11,0x801
800119c: 78 0d 08 01 mvhi r13,0x801
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
80011a0: 29 83 00 04 lw r3,(r12+4)
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
80011a4: 39 6b 77 30 ori r11,r11,0x7730
80011a8: 39 ad 77 2c ori r13,r13,0x772c
80011ac: 29 67 00 00 lw r7,(r11+0)
80011b0: 29 a1 00 00 lw r1,(r13+0)
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
80011b4: 34 84 ff ff addi r4,r4,-1
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
80011b8: 78 02 08 01 mvhi r2,0x801
80011bc: 38 42 5f 20 ori r2,r2,0x5f20
80011c0: b4 64 20 00 add r4,r3,r4
80011c4: ba 00 28 00 mv r5,r16
80011c8: b9 e0 30 00 mv r6,r15
80011cc: d8 e0 00 00 call r7
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
80011d0: 78 01 08 01 mvhi r1,0x801
80011d4: 38 21 77 34 ori r1,r1,0x7734
80011d8: 28 21 00 00 lw r1,(r1+0)
80011dc: 5c 20 00 07 bne r1,r0,80011f8 <Stack_check_Dump_threads_usage+0x184><== ALWAYS TAKEN
(*print_handler)( print_context, "Unavailable\n" );
80011e0: 29 63 00 00 lw r3,(r11+0) <== NOT EXECUTED
80011e4: 29 a1 00 00 lw r1,(r13+0) <== NOT EXECUTED
80011e8: 78 02 08 01 mvhi r2,0x801 <== NOT EXECUTED
80011ec: 38 42 5f 40 ori r2,r2,0x5f40 <== NOT EXECUTED
80011f0: d8 60 00 00 call r3 <== NOT EXECUTED
80011f4: e0 00 00 07 bi 8001210 <Stack_check_Dump_threads_usage+0x19c><== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
80011f8: 29 64 00 00 lw r4,(r11+0)
80011fc: 29 a1 00 00 lw r1,(r13+0)
8001200: 78 02 08 01 mvhi r2,0x801
8001204: 38 42 5f 50 ori r2,r2,0x5f50
8001208: b9 c0 18 00 mv r3,r14
800120c: d8 80 00 00 call r4
}
}
8001210: 2b 9d 00 04 lw ra,(sp+4)
8001214: 2b 8b 00 24 lw r11,(sp+36)
8001218: 2b 8c 00 20 lw r12,(sp+32)
800121c: 2b 8d 00 1c lw r13,(sp+28)
8001220: 2b 8e 00 18 lw r14,(sp+24)
8001224: 2b 8f 00 14 lw r15,(sp+20)
8001228: 2b 90 00 10 lw r16,(sp+16)
800122c: 2b 91 00 0c lw r17,(sp+12)
8001230: 2b 92 00 08 lw r18,(sp+8)
8001234: 37 9c 00 2c addi sp,sp,44
8001238: c3 a0 00 00 ret
0800123c <Stack_check_Initialize>:
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
{
800123c: 37 9c ff fc addi sp,sp,-4
8001240: 5b 9d 00 04 sw (sp+4),ra
static uint32_t pattern[ 4 ] = {
0xFEEDF00D, 0x0BAD0D06, /* FEED FOOD to BAD DOG */
0xDEADF00D, 0x600D0D06 /* DEAD FOOD but GOOD DOG */
};
if ( Stack_check_Initialized )
8001244: 78 01 08 01 mvhi r1,0x801
8001248: 38 21 77 34 ori r1,r1,0x7734
800124c: 28 23 00 00 lw r3,(r1+0)
8001250: 5c 60 00 24 bne r3,r0,80012e0 <Stack_check_Initialize+0xa4>
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
p[i] = pattern[ i%4 ];
8001254: 78 04 08 01 mvhi r4,0x801
8001258: 38 84 60 9c ori r4,r4,0x609c
800125c: 28 82 00 00 lw r2,(r4+0)
8001260: 78 01 08 01 mvhi r1,0x801
8001264: 78 04 08 01 mvhi r4,0x801
8001268: 38 21 77 c0 ori r1,r1,0x77c0
800126c: 38 84 60 a0 ori r4,r4,0x60a0
8001270: 58 22 00 00 sw (r1+0),r2
8001274: 28 82 00 00 lw r2,(r4+0)
8001278: 78 04 08 01 mvhi r4,0x801
800127c: 38 84 60 a4 ori r4,r4,0x60a4
8001280: 58 22 00 04 sw (r1+4),r2
8001284: 28 82 00 00 lw r2,(r4+0)
8001288: 78 04 08 01 mvhi r4,0x801
800128c: 38 84 60 a8 ori r4,r4,0x60a8
8001290: 58 22 00 08 sw (r1+8),r2
8001294: 28 82 00 00 lw r2,(r4+0)
8001298: 58 22 00 0c sw (r1+12),r2
/*
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
800129c: 78 02 08 01 mvhi r2,0x801
80012a0: 38 42 7e 28 ori r2,r2,0x7e28
80012a4: 28 41 00 00 lw r1,(r2+0)
80012a8: 44 23 00 0a be r1,r3,80012d0 <Stack_check_Initialize+0x94> <== NEVER TAKEN
80012ac: 28 43 00 04 lw r3,(r2+4)
80012b0: 44 60 00 08 be r3,r0,80012d0 <Stack_check_Initialize+0x94> <== NEVER TAKEN
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
80012b4: 78 02 08 01 mvhi r2,0x801
80012b8: 38 42 77 d0 ori r2,r2,0x77d0
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
80012bc: c8 61 18 00 sub r3,r3,r1
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
80012c0: 58 41 00 04 sw (r2+4),r1
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
80012c4: 58 43 00 00 sw (r2+0),r3
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
80012c8: 34 02 00 a5 mvi r2,165
80012cc: f8 00 3b a8 calli 801016c <memset>
}
#endif
Stack_check_Initialized = 1;
80012d0: 78 01 08 01 mvhi r1,0x801
80012d4: 38 21 77 34 ori r1,r1,0x7734
80012d8: 34 02 00 01 mvi r2,1
80012dc: 58 22 00 00 sw (r1+0),r2
}
80012e0: 2b 9d 00 04 lw ra,(sp+4)
80012e4: 37 9c 00 04 addi sp,sp,4
80012e8: c3 a0 00 00 ret
08005fbc <_CORE_RWLock_Obtain_for_writing>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
8005fbc: 37 9c ff fc addi sp,sp,-4
8005fc0: 5b 9d 00 04 sw (sp+4),ra
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
8005fc4: 78 05 08 01 mvhi r5,0x801
8005fc8: 38 a5 8d 84 ori r5,r5,0x8d84
8005fcc: 28 a5 00 0c lw r5,(r5+12)
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
8005fd0: 20 63 00 ff andi r3,r3,0xff
* Otherwise, we have to block.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
8005fd4: 90 00 30 00 rcsr r6,IE
8005fd8: 34 07 ff fe mvi r7,-2
8005fdc: a0 c7 38 00 and r7,r6,r7
8005fe0: d0 07 00 00 wcsr IE,r7
switch ( the_rwlock->current_state ) {
8005fe4: 28 27 00 44 lw r7,(r1+68)
8005fe8: 5c e0 00 06 bne r7,r0,8006000 <_CORE_RWLock_Obtain_for_writing+0x44><== NEVER TAKEN
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
8005fec: 34 02 00 02 mvi r2,2
8005ff0: 58 22 00 44 sw (r1+68),r2
_ISR_Enable( level );
8005ff4: d0 06 00 00 wcsr IE,r6
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
8005ff8: 58 a0 00 34 sw (r5+52),r0
return;
8005ffc: e0 00 00 11 bi 8006040 <_CORE_RWLock_Obtain_for_writing+0x84>
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
8006000: 5c 60 00 05 bne r3,r0,8006014 <_CORE_RWLock_Obtain_for_writing+0x58>
_ISR_Enable( level );
8006004: d0 06 00 00 wcsr IE,r6
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
8006008: 34 01 00 02 mvi r1,2
800600c: 58 a1 00 34 sw (r5+52),r1
return;
8006010: e0 00 00 0c bi 8006040 <_CORE_RWLock_Obtain_for_writing+0x84>
8006014: 34 03 00 01 mvi r3,1
8006018: 58 23 00 30 sw (r1+48),r3
/*
* We need to wait to enter this critical section
*/
_Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue );
executing->Wait.queue = &the_rwlock->Wait_queue;
800601c: 58 a1 00 44 sw (r5+68),r1
executing->Wait.id = id;
8006020: 58 a2 00 20 sw (r5+32),r2
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE;
8006024: 58 a3 00 30 sw (r5+48),r3
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
8006028: 58 a0 00 34 sw (r5+52),r0
_ISR_Enable( level );
800602c: d0 06 00 00 wcsr IE,r6
_Thread_queue_Enqueue_with_handler(
8006030: 78 03 08 00 mvhi r3,0x800
8006034: b8 80 10 00 mv r2,r4
8006038: 38 63 61 40 ori r3,r3,0x6140
800603c: f8 00 08 ad calli 80082f0 <_Thread_queue_Enqueue_with_handler>
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
8006040: 2b 9d 00 04 lw ra,(sp+4)
8006044: 37 9c 00 04 addi sp,sp,4
8006048: c3 a0 00 00 ret
0800604c <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
800604c: 37 9c ff f4 addi sp,sp,-12
8006050: 5b 8b 00 0c sw (sp+12),r11
8006054: 5b 8c 00 08 sw (sp+8),r12
8006058: 5b 9d 00 04 sw (sp+4),ra
800605c: b8 20 58 00 mv r11,r1
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
8006060: 78 01 08 01 mvhi r1,0x801
8006064: 38 21 8d 84 ori r1,r1,0x8d84
8006068: 28 22 00 0c lw r2,(r1+12)
* Otherwise, we have to block.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
800606c: 90 00 08 00 rcsr r1,IE
8006070: 34 03 ff fe mvi r3,-2
8006074: a0 23 18 00 and r3,r1,r3
8006078: d0 03 00 00 wcsr IE,r3
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
800607c: 29 63 00 44 lw r3,(r11+68)
8006080: 5c 60 00 05 bne r3,r0,8006094 <_CORE_RWLock_Release+0x48>
_ISR_Enable( level );
8006084: d0 01 00 00 wcsr IE,r1
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
8006088: 34 01 00 02 mvi r1,2
800608c: 58 41 00 34 sw (r2+52),r1
return CORE_RWLOCK_SUCCESSFUL;
8006090: e0 00 00 26 bi 8006128 <_CORE_RWLock_Release+0xdc>
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
8006094: 34 04 00 01 mvi r4,1
8006098: 5c 64 00 07 bne r3,r4,80060b4 <_CORE_RWLock_Release+0x68>
the_rwlock->number_of_readers -= 1;
800609c: 29 63 00 48 lw r3,(r11+72)
80060a0: 34 63 ff ff addi r3,r3,-1
80060a4: 59 63 00 48 sw (r11+72),r3
if ( the_rwlock->number_of_readers != 0 ) {
80060a8: 44 60 00 03 be r3,r0,80060b4 <_CORE_RWLock_Release+0x68>
/* must be unlocked again */
_ISR_Enable( level );
80060ac: d0 01 00 00 wcsr IE,r1
return CORE_RWLOCK_SUCCESSFUL;
80060b0: e0 00 00 1e bi 8006128 <_CORE_RWLock_Release+0xdc>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
80060b4: 58 40 00 34 sw (r2+52),r0
/*
* Implicitly transition to "unlocked" and find another thread interested
* in obtaining this rwlock.
*/
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
80060b8: 59 60 00 44 sw (r11+68),r0
_ISR_Enable( level );
80060bc: d0 01 00 00 wcsr IE,r1
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
80060c0: b9 60 08 00 mv r1,r11
80060c4: f8 00 08 18 calli 8008124 <_Thread_queue_Dequeue>
if ( next ) {
80060c8: 44 20 00 18 be r1,r0,8006128 <_CORE_RWLock_Release+0xdc>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
80060cc: 28 22 00 30 lw r2,(r1+48)
80060d0: 34 01 00 01 mvi r1,1
80060d4: 5c 41 00 04 bne r2,r1,80060e4 <_CORE_RWLock_Release+0x98>
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
80060d8: 34 01 00 02 mvi r1,2
80060dc: 59 61 00 44 sw (r11+68),r1
return CORE_RWLOCK_SUCCESSFUL;
80060e0: e0 00 00 12 bi 8006128 <_CORE_RWLock_Release+0xdc>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
80060e4: 29 62 00 48 lw r2,(r11+72)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
80060e8: 59 61 00 44 sw (r11+68),r1
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
80060ec: 34 0c 00 01 mvi r12,1
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
80060f0: 34 42 00 01 addi r2,r2,1
80060f4: 59 62 00 48 sw (r11+72),r2
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
80060f8: b9 60 08 00 mv r1,r11
80060fc: f8 00 09 91 calli 8008740 <_Thread_queue_First>
8006100: b8 20 10 00 mv r2,r1
if ( !next ||
8006104: 44 20 00 09 be r1,r0,8006128 <_CORE_RWLock_Release+0xdc>
8006108: 28 21 00 30 lw r1,(r1+48)
800610c: 44 2c 00 07 be r1,r12,8006128 <_CORE_RWLock_Release+0xdc> <== NEVER TAKEN
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
8006110: 29 61 00 48 lw r1,(r11+72)
8006114: 34 21 00 01 addi r1,r1,1
8006118: 59 61 00 48 sw (r11+72),r1
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
800611c: b9 60 08 00 mv r1,r11
8006120: f8 00 09 3e calli 8008618 <_Thread_queue_Extract>
}
8006124: e3 ff ff f5 bi 80060f8 <_CORE_RWLock_Release+0xac>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
8006128: 34 01 00 00 mvi r1,0
800612c: 2b 9d 00 04 lw ra,(sp+4)
8006130: 2b 8b 00 0c lw r11,(sp+12)
8006134: 2b 8c 00 08 lw r12,(sp+8)
8006138: 37 9c 00 0c addi sp,sp,12
800613c: c3 a0 00 00 ret
08006140 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
8006140: 37 9c ff f8 addi sp,sp,-8
8006144: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
8006148: 37 82 00 08 addi r2,sp,8
800614c: f8 00 07 0e calli 8007d84 <_Thread_Get>
switch ( location ) {
8006150: 2b 82 00 08 lw r2,(sp+8)
8006154: 5c 40 00 07 bne r2,r0,8006170 <_CORE_RWLock_Timeout+0x30> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
8006158: f8 00 09 d4 calli 80088a8 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
800615c: 78 01 08 01 mvhi r1,0x801
8006160: 38 21 88 d8 ori r1,r1,0x88d8
8006164: 28 22 00 00 lw r2,(r1+0)
8006168: 34 42 ff ff addi r2,r2,-1
800616c: 58 22 00 00 sw (r1+0),r2
_Thread_Unnest_dispatch();
break;
}
}
8006170: 2b 9d 00 04 lw ra,(sp+4)
8006174: 37 9c 00 08 addi sp,sp,8
8006178: c3 a0 00 00 ret
0800dad4 <_CORE_message_queue_Initialize>:
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
800dad4: 37 9c ff e4 addi sp,sp,-28
800dad8: 5b 8b 00 1c sw (sp+28),r11
800dadc: 5b 8c 00 18 sw (sp+24),r12
800dae0: 5b 8d 00 14 sw (sp+20),r13
800dae4: 5b 8e 00 10 sw (sp+16),r14
800dae8: 5b 8f 00 0c sw (sp+12),r15
800daec: 5b 90 00 08 sw (sp+8),r16
800daf0: 5b 9d 00 04 sw (sp+4),ra
800daf4: b8 20 58 00 mv r11,r1
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
the_message_queue->number_of_pending_messages = 0;
800daf8: 58 20 00 48 sw (r1+72),r0
the_message_queue->maximum_message_size = maximum_message_size;
800dafc: 58 24 00 4c sw (r1+76),r4
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
800db00: 58 20 00 60 sw (r1+96),r0
the_message_queue->notify_argument = the_argument;
800db04: 58 20 00 64 sw (r1+100),r0
)
{
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
800db08: 59 63 00 44 sw (r11+68),r3
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
800db0c: 20 81 00 03 andi r1,r4,0x3
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
800db10: b8 40 80 00 mv r16,r2
800db14: b8 60 70 00 mv r14,r3
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
800db18: b8 80 60 00 mv r12,r4
800db1c: 44 20 00 06 be r1,r0,800db34 <_CORE_message_queue_Initialize+0x60>
allocated_message_size += sizeof(uint32_t);
800db20: 34 8c 00 04 addi r12,r4,4
allocated_message_size &= ~(sizeof(uint32_t) - 1);
800db24: 34 01 ff fc mvi r1,-4
800db28: a1 81 60 00 and r12,r12,r1
}
if (allocated_message_size < maximum_message_size)
return false;
800db2c: 34 0d 00 00 mvi r13,0
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
allocated_message_size += sizeof(uint32_t);
allocated_message_size &= ~(sizeof(uint32_t) - 1);
}
if (allocated_message_size < maximum_message_size)
800db30: 54 8c 00 1c bgu r4,r12,800dba0 <_CORE_message_queue_Initialize+0xcc><== NEVER TAKEN
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
800db34: 35 8f 00 14 addi r15,r12,20
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
800db38: b9 e0 08 00 mv r1,r15
800db3c: b9 c0 10 00 mv r2,r14
800db40: f8 00 5e 6c calli 80254f0 <__mulsi3>
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
return false;
800db44: 34 0d 00 00 mvi r13,0
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
800db48: 55 81 00 16 bgu r12,r1,800dba0 <_CORE_message_queue_Initialize+0xcc><== NEVER TAKEN
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
800db4c: f8 00 0e f5 calli 8011720 <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
800db50: 59 61 00 5c sw (r11+92),r1
_Workspace_Allocate( message_buffering_required );
800db54: b8 20 28 00 mv r5,r1
if (the_message_queue->message_buffers == 0)
800db58: 44 20 00 12 be r1,r0,800dba0 <_CORE_message_queue_Initialize+0xcc>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
800db5c: b8 a0 10 00 mv r2,r5
800db60: 35 61 00 68 addi r1,r11,104
800db64: b9 c0 18 00 mv r3,r14
800db68: b9 e0 20 00 mv r4,r15
800db6c: f8 00 1a 3e calli 8014464 <_Chain_Initialize>
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
800db70: 35 61 00 54 addi r1,r11,84
head->next = tail;
800db74: 59 61 00 50 sw (r11+80),r1
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
800db78: 35 61 00 50 addi r1,r11,80
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
800db7c: 59 61 00 58 sw (r11+88),r1
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
800db80: 59 60 00 54 sw (r11+84),r0
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
800db84: 2a 02 00 00 lw r2,(r16+0)
800db88: b9 60 08 00 mv r1,r11
800db8c: 34 03 00 80 mvi r3,128
800db90: 64 42 00 01 cmpei r2,r2,1
800db94: 34 04 00 06 mvi r4,6
800db98: f8 00 0b c7 calli 8010ab4 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
800db9c: 34 0d 00 01 mvi r13,1
}
800dba0: b9 a0 08 00 mv r1,r13
800dba4: 2b 9d 00 04 lw ra,(sp+4)
800dba8: 2b 8b 00 1c lw r11,(sp+28)
800dbac: 2b 8c 00 18 lw r12,(sp+24)
800dbb0: 2b 8d 00 14 lw r13,(sp+20)
800dbb4: 2b 8e 00 10 lw r14,(sp+16)
800dbb8: 2b 8f 00 0c lw r15,(sp+12)
800dbbc: 2b 90 00 08 lw r16,(sp+8)
800dbc0: 37 9c 00 1c addi sp,sp,28
800dbc4: c3 a0 00 00 ret
0800dbc8 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
800dbc8: 37 9c ff f0 addi sp,sp,-16
800dbcc: 5b 8b 00 10 sw (sp+16),r11
800dbd0: 5b 8c 00 0c sw (sp+12),r12
800dbd4: 5b 8d 00 08 sw (sp+8),r13
800dbd8: 5b 9d 00 04 sw (sp+4),ra
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
800dbdc: 78 07 08 02 mvhi r7,0x802
800dbe0: 38 e7 8f 4c ori r7,r7,0x8f4c
800dbe4: 28 e7 00 0c lw r7,(r7+12)
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
800dbe8: b8 20 58 00 mv r11,r1
800dbec: 20 a5 00 ff andi r5,r5,0xff
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
800dbf0: 58 e0 00 34 sw (r7+52),r0
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
800dbf4: b8 60 08 00 mv r1,r3
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
_ISR_Disable( level );
800dbf8: 90 00 40 00 rcsr r8,IE
800dbfc: 34 03 ff fe mvi r3,-2
800dc00: a1 03 18 00 and r3,r8,r3
800dc04: d0 03 00 00 wcsr IE,r3
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
800dc08: 29 6c 00 50 lw r12,(r11+80)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
800dc0c: 35 63 00 54 addi r3,r11,84
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
800dc10: 45 83 00 07 be r12,r3,800dc2c <_CORE_message_queue_Seize+0x64>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
800dc14: 29 83 00 00 lw r3,(r12+0)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
800dc18: 35 69 00 50 addi r9,r11,80
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
800dc1c: 59 63 00 50 sw (r11+80),r3
new_first->previous = head;
800dc20: 58 69 00 04 sw (r3+4),r9
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
800dc24: 5d 80 00 04 bne r12,r0,800dc34 <_CORE_message_queue_Seize+0x6c><== ALWAYS TAKEN
800dc28: e0 00 00 25 bi 800dcbc <_CORE_message_queue_Seize+0xf4> <== NOT EXECUTED
)
{
if ( !_Chain_Is_empty(the_chain))
return _Chain_Get_first_unprotected(the_chain);
else
return NULL;
800dc2c: 34 0c 00 00 mvi r12,0
800dc30: e0 00 00 23 bi 800dcbc <_CORE_message_queue_Seize+0xf4>
the_message_queue->number_of_pending_messages -= 1;
800dc34: 29 62 00 48 lw r2,(r11+72)
800dc38: 34 42 ff ff addi r2,r2,-1
800dc3c: 59 62 00 48 sw (r11+72),r2
_ISR_Enable( level );
800dc40: d0 08 00 00 wcsr IE,r8
*size_p = the_message->Contents.size;
800dc44: 29 83 00 0c lw r3,(r12+12)
_Thread_Executing->Wait.count =
800dc48: 78 02 08 02 mvhi r2,0x802
800dc4c: 38 42 8f 4c ori r2,r2,0x8f4c
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
_ISR_Enable( level );
*size_p = the_message->Contents.size;
800dc50: 58 83 00 00 sw (r4+0),r3
_Thread_Executing->Wait.count =
800dc54: 29 84 00 08 lw r4,(r12+8)
800dc58: 28 42 00 0c lw r2,(r2+12)
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
800dc5c: 35 8d 00 10 addi r13,r12,16
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
_ISR_Enable( level );
*size_p = the_message->Contents.size;
_Thread_Executing->Wait.count =
800dc60: 58 44 00 24 sw (r2+36),r4
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
800dc64: b9 a0 10 00 mv r2,r13
800dc68: f8 00 27 8a calli 8017a90 <memcpy>
* is not, then we can go ahead and free the buffer.
*
* NOTE: If we note that the queue was not full before this receive,
* then we can avoid this dequeue.
*/
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
800dc6c: b9 60 08 00 mv r1,r11
800dc70: f8 00 0a 33 calli 801053c <_Thread_queue_Dequeue>
800dc74: b8 20 20 00 mv r4,r1
if ( !the_thread ) {
800dc78: 5c 20 00 05 bne r1,r0,800dc8c <_CORE_message_queue_Seize+0xc4>
RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer (
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message
)
{
_Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node );
800dc7c: 35 61 00 68 addi r1,r11,104
800dc80: b9 80 10 00 mv r2,r12
800dc84: fb ff ff 64 calli 800da14 <_Chain_Append>
_CORE_message_queue_Free_message_buffer(
the_message_queue,
the_message
);
return;
800dc88: e0 00 00 1e bi 800dd00 <_CORE_message_queue_Seize+0x138>
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
800dc8c: 28 21 00 24 lw r1,(r1+36)
*/
_CORE_message_queue_Set_message_priority(
the_message,
the_thread->Wait.count
);
the_message->Contents.size = (size_t) the_thread->Wait.option;
800dc90: 28 83 00 30 lw r3,(r4+48)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
800dc94: 28 82 00 2c lw r2,(r4+44)
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
800dc98: 59 81 00 08 sw (r12+8),r1
800dc9c: 59 83 00 0c sw (r12+12),r3
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
800dca0: b9 a0 08 00 mv r1,r13
800dca4: f8 00 27 7b calli 8017a90 <memcpy>
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
800dca8: 29 83 00 08 lw r3,(r12+8)
800dcac: b9 60 08 00 mv r1,r11
800dcb0: b9 80 10 00 mv r2,r12
800dcb4: f8 00 19 f9 calli 8014498 <_CORE_message_queue_Insert_message>
the_message_queue,
the_message,
_CORE_message_queue_Get_message_priority( the_message )
);
return;
800dcb8: e0 00 00 12 bi 800dd00 <_CORE_message_queue_Seize+0x138>
}
#endif
}
if ( !wait ) {
800dcbc: 5c ac 00 05 bne r5,r12,800dcd0 <_CORE_message_queue_Seize+0x108>
_ISR_Enable( level );
800dcc0: d0 08 00 00 wcsr IE,r8
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
800dcc4: 34 01 00 04 mvi r1,4
800dcc8: 58 e1 00 34 sw (r7+52),r1
return;
800dccc: e0 00 00 0d bi 800dd00 <_CORE_message_queue_Seize+0x138>
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
800dcd0: 34 03 00 01 mvi r3,1
800dcd4: 59 63 00 30 sw (r11+48),r3
}
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
800dcd8: 58 eb 00 44 sw (r7+68),r11
executing->Wait.id = id;
800dcdc: 58 e2 00 20 sw (r7+32),r2
executing->Wait.return_argument_second.mutable_object = buffer;
800dce0: 58 e1 00 2c sw (r7+44),r1
executing->Wait.return_argument = size_p;
800dce4: 58 e4 00 28 sw (r7+40),r4
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
800dce8: d0 08 00 00 wcsr IE,r8
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
800dcec: 78 03 08 01 mvhi r3,0x801
800dcf0: b9 60 08 00 mv r1,r11
800dcf4: b8 c0 10 00 mv r2,r6
800dcf8: 38 63 0b f4 ori r3,r3,0xbf4
800dcfc: f8 00 0a 83 calli 8010708 <_Thread_queue_Enqueue_with_handler>
}
800dd00: 2b 9d 00 04 lw ra,(sp+4)
800dd04: 2b 8b 00 10 lw r11,(sp+16)
800dd08: 2b 8c 00 0c lw r12,(sp+12)
800dd0c: 2b 8d 00 08 lw r13,(sp+8)
800dd10: 37 9c 00 10 addi sp,sp,16
800dd14: c3 a0 00 00 ret
08004d30 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
8004d30: 37 9c ff e8 addi sp,sp,-24
8004d34: 5b 8b 00 14 sw (sp+20),r11
8004d38: 5b 8c 00 10 sw (sp+16),r12
8004d3c: 5b 8d 00 0c sw (sp+12),r13
8004d40: 5b 8e 00 08 sw (sp+8),r14
8004d44: 5b 9d 00 04 sw (sp+4),ra
8004d48: b8 20 58 00 mv r11,r1
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
8004d4c: 78 01 08 01 mvhi r1,0x801
8004d50: 38 21 99 90 ori r1,r1,0x9990
8004d54: 28 21 00 00 lw r1,(r1+0)
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
8004d58: 5b 85 00 18 sw (sp+24),r5
8004d5c: b8 40 70 00 mv r14,r2
8004d60: b8 80 68 00 mv r13,r4
8004d64: 20 6c 00 ff andi r12,r3,0xff
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
8004d68: 44 20 00 0b be r1,r0,8004d94 <_CORE_mutex_Seize+0x64>
8004d6c: 45 80 00 0a be r12,r0,8004d94 <_CORE_mutex_Seize+0x64> <== NEVER TAKEN
8004d70: 78 01 08 01 mvhi r1,0x801
8004d74: 38 21 9a e8 ori r1,r1,0x9ae8
8004d78: 28 21 00 00 lw r1,(r1+0)
8004d7c: 34 02 00 01 mvi r2,1
8004d80: 50 41 00 05 bgeu r2,r1,8004d94 <_CORE_mutex_Seize+0x64>
8004d84: 34 01 00 00 mvi r1,0
8004d88: 34 02 00 00 mvi r2,0
8004d8c: 34 03 00 12 mvi r3,18
8004d90: f8 00 02 0a calli 80055b8 <_Internal_error_Occurred>
8004d94: b9 60 08 00 mv r1,r11
8004d98: 37 82 00 18 addi r2,sp,24
8004d9c: f8 00 26 51 calli 800e6e0 <_CORE_mutex_Seize_interrupt_trylock>
8004da0: 44 20 00 19 be r1,r0,8004e04 <_CORE_mutex_Seize+0xd4>
8004da4: 78 01 08 01 mvhi r1,0x801
8004da8: 38 21 9e 3c ori r1,r1,0x9e3c
8004dac: 5d 80 00 07 bne r12,r0,8004dc8 <_CORE_mutex_Seize+0x98>
8004db0: 2b 82 00 18 lw r2,(sp+24)
8004db4: d0 02 00 00 wcsr IE,r2
8004db8: 28 21 00 0c lw r1,(r1+12)
8004dbc: 34 02 00 01 mvi r2,1
8004dc0: 58 22 00 34 sw (r1+52),r2
8004dc4: e0 00 00 10 bi 8004e04 <_CORE_mutex_Seize+0xd4>
8004dc8: 28 21 00 0c lw r1,(r1+12)
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
8004dcc: 34 02 00 01 mvi r2,1
8004dd0: 59 62 00 30 sw (r11+48),r2
8004dd4: 58 2b 00 44 sw (r1+68),r11
8004dd8: 58 2e 00 20 sw (r1+32),r14
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
8004ddc: 78 01 08 01 mvhi r1,0x801
8004de0: 38 21 99 90 ori r1,r1,0x9990
8004de4: 28 22 00 00 lw r2,(r1+0)
8004de8: 34 42 00 01 addi r2,r2,1
8004dec: 58 22 00 00 sw (r1+0),r2
8004df0: 2b 81 00 18 lw r1,(sp+24)
8004df4: d0 01 00 00 wcsr IE,r1
8004df8: b9 60 08 00 mv r1,r11
8004dfc: b9 a0 10 00 mv r2,r13
8004e00: fb ff ff ab calli 8004cac <_CORE_mutex_Seize_interrupt_blocking>
}
8004e04: 2b 9d 00 04 lw ra,(sp+4)
8004e08: 2b 8b 00 14 lw r11,(sp+20)
8004e0c: 2b 8c 00 10 lw r12,(sp+16)
8004e10: 2b 8d 00 0c lw r13,(sp+12)
8004e14: 2b 8e 00 08 lw r14,(sp+8)
8004e18: 37 9c 00 18 addi sp,sp,24
8004e1c: c3 a0 00 00 ret
08004f98 <_CORE_semaphore_Surrender>:
CORE_semaphore_Status _CORE_semaphore_Surrender(
CORE_semaphore_Control *the_semaphore,
Objects_Id id,
CORE_semaphore_API_mp_support_callout api_semaphore_mp_support
)
{
8004f98: 37 9c ff f8 addi sp,sp,-8
8004f9c: 5b 8b 00 08 sw (sp+8),r11
8004fa0: 5b 9d 00 04 sw (sp+4),ra
8004fa4: b8 20 58 00 mv r11,r1
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
8004fa8: f8 00 07 d5 calli 8006efc <_Thread_queue_Dequeue>
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
8004fac: 34 02 00 00 mvi r2,0
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
8004fb0: 5c 20 00 0d bne r1,r0,8004fe4 <_CORE_semaphore_Surrender+0x4c>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
8004fb4: 90 00 08 00 rcsr r1,IE
8004fb8: 34 02 ff fe mvi r2,-2
8004fbc: a0 22 10 00 and r2,r1,r2
8004fc0: d0 02 00 00 wcsr IE,r2
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
8004fc4: 29 63 00 48 lw r3,(r11+72)
8004fc8: 29 64 00 40 lw r4,(r11+64)
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
8004fcc: 34 02 00 04 mvi r2,4
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
8004fd0: 50 64 00 04 bgeu r3,r4,8004fe0 <_CORE_semaphore_Surrender+0x48><== NEVER TAKEN
the_semaphore->count += 1;
8004fd4: 34 63 00 01 addi r3,r3,1
8004fd8: 59 63 00 48 sw (r11+72),r3
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
8004fdc: 34 02 00 00 mvi r2,0
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
8004fe0: d0 01 00 00 wcsr IE,r1
}
return status;
}
8004fe4: b8 40 08 00 mv r1,r2
8004fe8: 2b 9d 00 04 lw ra,(sp+4)
8004fec: 2b 8b 00 08 lw r11,(sp+8)
8004ff0: 37 9c 00 08 addi sp,sp,8
8004ff4: c3 a0 00 00 ret
0800dadc <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
800dadc: 37 9c ff f8 addi sp,sp,-8
800dae0: 5b 8b 00 08 sw (sp+8),r11
800dae4: 5b 9d 00 04 sw (sp+4),ra
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
RTEMS_API_Control *api;
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
800dae8: 28 24 01 1c lw r4,(r1+284)
option_set = (rtems_option) the_thread->Wait.option;
800daec: 28 28 00 30 lw r8,(r1+48)
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
800daf0: b8 20 58 00 mv r11,r1
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
800daf4: 90 00 08 00 rcsr r1,IE
800daf8: 34 07 ff fe mvi r7,-2
800dafc: a0 27 38 00 and r7,r1,r7
800db00: d0 07 00 00 wcsr IE,r7
pending_events = api->pending_events;
800db04: 28 85 00 00 lw r5,(r4+0)
event_condition = (rtems_event_set) the_thread->Wait.count;
800db08: 29 66 00 24 lw r6,(r11+36)
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Get(
rtems_event_set the_event_set,
rtems_event_set the_event_condition
)
{
return ( the_event_set & the_event_condition );
800db0c: a0 c5 10 00 and r2,r6,r5
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
800db10: 5c 40 00 03 bne r2,r0,800db1c <_Event_Surrender+0x40>
_ISR_Enable( level );
800db14: d0 01 00 00 wcsr IE,r1
return;
800db18: e0 00 00 3d bi 800dc0c <_Event_Surrender+0x130>
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
800db1c: 78 03 08 01 mvhi r3,0x801
800db20: 38 63 9e 3c ori r3,r3,0x9e3c
800db24: 28 69 00 08 lw r9,(r3+8)
800db28: 45 20 00 1a be r9,r0,800db90 <_Event_Surrender+0xb4>
800db2c: 28 63 00 0c lw r3,(r3+12)
800db30: 5d 63 00 18 bne r11,r3,800db90 <_Event_Surrender+0xb4>
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
800db34: 78 03 08 01 mvhi r3,0x801
800db38: 38 63 a3 30 ori r3,r3,0xa330
800db3c: 28 6a 00 00 lw r10,(r3+0)
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
800db40: 34 09 00 02 mvi r9,2
800db44: 45 49 00 04 be r10,r9,800db54 <_Event_Surrender+0x78> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
800db48: 28 69 00 00 lw r9,(r3+0)
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
800db4c: 34 03 00 01 mvi r3,1
800db50: 5d 23 00 10 bne r9,r3,800db90 <_Event_Surrender+0xb4>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
800db54: 44 46 00 03 be r2,r6,800db60 <_Event_Surrender+0x84>
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_any (
rtems_option option_set
)
{
return (option_set & RTEMS_EVENT_ANY) ? true : false;
800db58: 21 08 00 02 andi r8,r8,0x2
800db5c: 45 00 00 0b be r8,r0,800db88 <_Event_Surrender+0xac> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
800db60: a4 40 18 00 not r3,r2
800db64: a0 65 28 00 and r5,r3,r5
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
800db68: 29 63 00 28 lw r3,(r11+40)
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
800db6c: 58 85 00 00 sw (r4+0),r5
the_thread->Wait.count = 0;
800db70: 59 60 00 24 sw (r11+36),r0
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
800db74: 58 62 00 00 sw (r3+0),r2
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
800db78: 78 02 08 01 mvhi r2,0x801
800db7c: 38 42 a3 30 ori r2,r2,0xa330
800db80: 34 03 00 03 mvi r3,3
800db84: 58 43 00 00 sw (r2+0),r3
}
_ISR_Enable( level );
800db88: d0 01 00 00 wcsr IE,r1
return;
800db8c: e0 00 00 20 bi 800dc0c <_Event_Surrender+0x130>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_EVENT);
800db90: 29 63 00 10 lw r3,(r11+16)
800db94: 20 63 01 00 andi r3,r3,0x100
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
800db98: 44 60 00 1c be r3,r0,800dc08 <_Event_Surrender+0x12c>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
800db9c: 44 46 00 03 be r2,r6,800dba8 <_Event_Surrender+0xcc>
800dba0: 21 08 00 02 andi r8,r8,0x2
800dba4: 45 00 00 19 be r8,r0,800dc08 <_Event_Surrender+0x12c> <== NEVER TAKEN
800dba8: a4 40 18 00 not r3,r2
800dbac: a0 65 28 00 and r5,r3,r5
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
800dbb0: 29 63 00 28 lw r3,(r11+40)
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
800dbb4: 58 85 00 00 sw (r4+0),r5
the_thread->Wait.count = 0;
800dbb8: 59 60 00 24 sw (r11+36),r0
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
800dbbc: 58 62 00 00 sw (r3+0),r2
_ISR_Flash( level );
800dbc0: d0 01 00 00 wcsr IE,r1
800dbc4: d0 07 00 00 wcsr IE,r7
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
800dbc8: 29 63 00 50 lw r3,(r11+80)
800dbcc: 34 02 00 02 mvi r2,2
800dbd0: 44 62 00 03 be r3,r2,800dbdc <_Event_Surrender+0x100>
_ISR_Enable( level );
800dbd4: d0 01 00 00 wcsr IE,r1
800dbd8: e0 00 00 06 bi 800dbf0 <_Event_Surrender+0x114>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
800dbdc: 34 02 00 03 mvi r2,3
800dbe0: 59 62 00 50 sw (r11+80),r2
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
800dbe4: d0 01 00 00 wcsr IE,r1
(void) _Watchdog_Remove( &the_thread->Timer );
800dbe8: 35 61 00 48 addi r1,r11,72
800dbec: fb ff e8 6e calli 8007da4 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
800dbf0: 78 03 08 01 mvhi r3,0x801
800dbf4: 38 63 81 74 ori r3,r3,0x8174
800dbf8: 28 62 00 00 lw r2,(r3+0)
800dbfc: b9 60 08 00 mv r1,r11
800dc00: f8 00 05 04 calli 800f010 <_Thread_Clear_state>
800dc04: e0 00 00 02 bi 800dc0c <_Event_Surrender+0x130>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
800dc08: d0 01 00 00 wcsr IE,r1
}
800dc0c: 2b 9d 00 04 lw ra,(sp+4)
800dc10: 2b 8b 00 08 lw r11,(sp+8)
800dc14: 37 9c 00 08 addi sp,sp,8
800dc18: c3 a0 00 00 ret
0800dc1c <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
800dc1c: 37 9c ff f8 addi sp,sp,-8
800dc20: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
800dc24: 37 82 00 08 addi r2,sp,8
800dc28: fb ff e3 cd calli 8006b5c <_Thread_Get>
switch ( location ) {
800dc2c: 2b 82 00 08 lw r2,(sp+8)
800dc30: 5c 40 00 1d bne r2,r0,800dca4 <_Event_Timeout+0x88> <== NEVER TAKEN
*
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
800dc34: 90 00 18 00 rcsr r3,IE
800dc38: 34 02 ff fe mvi r2,-2
800dc3c: a0 62 10 00 and r2,r3,r2
800dc40: d0 02 00 00 wcsr IE,r2
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
800dc44: 78 02 08 01 mvhi r2,0x801
800dc48: 38 42 9e 3c ori r2,r2,0x9e3c
return;
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
800dc4c: 28 42 00 0c lw r2,(r2+12)
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
800dc50: 58 20 00 24 sw (r1+36),r0
if ( _Thread_Is_executing( the_thread ) ) {
800dc54: 5c 22 00 08 bne r1,r2,800dc74 <_Event_Timeout+0x58>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
800dc58: 78 02 08 01 mvhi r2,0x801
800dc5c: 38 42 a3 30 ori r2,r2,0xa330
800dc60: 28 45 00 00 lw r5,(r2+0)
800dc64: 34 04 00 01 mvi r4,1
800dc68: 5c a4 00 03 bne r5,r4,800dc74 <_Event_Timeout+0x58> <== ALWAYS TAKEN
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
800dc6c: 34 04 00 02 mvi r4,2 <== NOT EXECUTED
800dc70: 58 44 00 00 sw (r2+0),r4 <== NOT EXECUTED
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
800dc74: 34 02 00 06 mvi r2,6
800dc78: 58 22 00 34 sw (r1+52),r2
_ISR_Enable( level );
800dc7c: d0 03 00 00 wcsr IE,r3
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
800dc80: 78 03 08 01 mvhi r3,0x801
800dc84: 38 63 81 74 ori r3,r3,0x8174
800dc88: 28 62 00 00 lw r2,(r3+0)
800dc8c: f8 00 04 e1 calli 800f010 <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
800dc90: 78 01 08 01 mvhi r1,0x801
800dc94: 38 21 99 90 ori r1,r1,0x9990
800dc98: 28 22 00 00 lw r2,(r1+0)
800dc9c: 34 42 ff ff addi r2,r2,-1
800dca0: 58 22 00 00 sw (r1+0),r2
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
800dca4: 2b 9d 00 04 lw ra,(sp+4)
800dca8: 37 9c 00 08 addi sp,sp,8
800dcac: c3 a0 00 00 ret
08009fb4 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
8009fb4: 37 9c ff b8 addi sp,sp,-72
8009fb8: 5b 8b 00 40 sw (sp+64),r11
8009fbc: 5b 8c 00 3c sw (sp+60),r12
8009fc0: 5b 8d 00 38 sw (sp+56),r13
8009fc4: 5b 8e 00 34 sw (sp+52),r14
8009fc8: 5b 8f 00 30 sw (sp+48),r15
8009fcc: 5b 90 00 2c sw (sp+44),r16
8009fd0: 5b 91 00 28 sw (sp+40),r17
8009fd4: 5b 92 00 24 sw (sp+36),r18
8009fd8: 5b 93 00 20 sw (sp+32),r19
8009fdc: 5b 94 00 1c sw (sp+28),r20
8009fe0: 5b 95 00 18 sw (sp+24),r21
8009fe4: 5b 96 00 14 sw (sp+20),r22
8009fe8: 5b 97 00 10 sw (sp+16),r23
8009fec: 5b 98 00 0c sw (sp+12),r24
8009ff0: 5b 99 00 08 sw (sp+8),r25
8009ff4: 5b 9d 00 04 sw (sp+4),ra
8009ff8: b8 40 70 00 mv r14,r2
Heap_Block *start_block = first_block;
Heap_Block *merge_below_block = NULL;
Heap_Block *merge_above_block = NULL;
Heap_Block *link_below_block = NULL;
Heap_Block *link_above_block = NULL;
Heap_Block *extend_first_block = NULL;
8009ffc: 5b 80 00 48 sw (sp+72),r0
Heap_Block *extend_last_block = NULL;
800a000: 5b 80 00 44 sw (sp+68),r0
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
800a004: b5 c3 68 00 add r13,r14,r3
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
800a008: b8 80 a0 00 mv r20,r4
800a00c: b8 20 58 00 mv r11,r1
800a010: b8 60 10 00 mv r2,r3
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
800a014: 28 35 00 20 lw r21,(r1+32)
Heap_Block *merge_above_block = NULL;
Heap_Block *link_below_block = NULL;
Heap_Block *link_above_block = NULL;
Heap_Block *extend_first_block = NULL;
Heap_Block *extend_last_block = NULL;
uintptr_t const page_size = heap->page_size;
800a018: 28 36 00 10 lw r22,(r1+16)
uintptr_t const min_block_size = heap->min_block_size;
800a01c: 28 24 00 14 lw r4,(r1+20)
uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
uintptr_t const free_size = stats->free_size;
800a020: 28 37 00 30 lw r23,(r1+48)
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
return false;
800a024: 34 0c 00 00 mvi r12,0
uintptr_t const free_size = stats->free_size;
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
800a028: 55 cd 00 8e bgu r14,r13,800a260 <_Heap_Extend+0x2ac>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
800a02c: b9 c0 08 00 mv r1,r14
800a030: ba c0 18 00 mv r3,r22
800a034: 37 85 00 48 addi r5,sp,72
800a038: 37 86 00 44 addi r6,sp,68
800a03c: fb ff e7 d7 calli 8003f98 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
800a040: 44 20 00 88 be r1,r0,800a260 <_Heap_Extend+0x2ac>
800a044: ba a0 78 00 mv r15,r21
800a048: 34 11 00 00 mvi r17,0
800a04c: 34 13 00 00 mvi r19,0
800a050: 34 10 00 00 mvi r16,0
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
800a054: 29 61 00 18 lw r1,(r11+24)
- 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;
800a058: 34 18 ff fe mvi r24,-2
800a05c: e0 00 00 02 bi 800a064 <_Heap_Extend+0xb0>
800a060: b9 e0 08 00 mv r1,r15
uintptr_t const sub_area_end = start_block->prev_size;
800a064: 29 f2 00 00 lw r18,(r15+0)
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
800a068: f5 a1 18 00 cmpgu r3,r13,r1
800a06c: f6 4e 10 00 cmpgu r2,r18,r14
(uintptr_t) start_block : heap->area_begin;
uintptr_t const sub_area_end = start_block->prev_size;
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
800a070: a0 62 10 00 and r2,r3,r2
800a074: 5c 40 00 7a bne r2,r0,800a25c <_Heap_Extend+0x2a8>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
800a078: 45 a1 00 03 be r13,r1,800a084 <_Heap_Extend+0xd0>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
800a07c: 56 4d 00 04 bgu r18,r13,800a08c <_Heap_Extend+0xd8>
800a080: e0 00 00 04 bi 800a090 <_Heap_Extend+0xdc>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
800a084: b9 e0 80 00 mv r16,r15
800a088: e0 00 00 02 bi 800a090 <_Heap_Extend+0xdc>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
800a08c: b9 e0 98 00 mv r19,r15
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
800a090: ba 40 08 00 mv r1,r18
800a094: ba c0 10 00 mv r2,r22
800a098: 36 59 ff f8 addi r25,r18,-8
800a09c: f8 00 20 c1 calli 80123a0 <__umodsi3>
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
800a0a0: cb 21 08 00 sub r1,r25,r1
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
800a0a4: 5d d2 00 04 bne r14,r18,800a0b4 <_Heap_Extend+0x100>
start_block->prev_size = extend_area_end;
800a0a8: 59 ed 00 00 sw (r15+0),r13
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area(
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
800a0ac: b8 20 60 00 mv r12,r1
800a0b0: e0 00 00 04 bi 800a0c0 <_Heap_Extend+0x10c>
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
800a0b4: 55 d2 00 02 bgu r14,r18,800a0bc <_Heap_Extend+0x108>
800a0b8: e0 00 00 02 bi 800a0c0 <_Heap_Extend+0x10c>
800a0bc: b8 20 88 00 mv r17,r1
- 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;
800a0c0: 28 2f 00 04 lw r15,(r1+4)
800a0c4: a3 0f 78 00 and r15,r24,r15
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
800a0c8: b4 2f 78 00 add r15,r1,r15
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
800a0cc: 5d f5 ff e5 bne r15,r21,800a060 <_Heap_Extend+0xac>
if ( extend_area_begin < heap->area_begin ) {
800a0d0: 29 61 00 18 lw r1,(r11+24)
800a0d4: 51 c1 00 03 bgeu r14,r1,800a0e0 <_Heap_Extend+0x12c>
heap->area_begin = extend_area_begin;
800a0d8: 59 6e 00 18 sw (r11+24),r14
800a0dc: e0 00 00 04 bi 800a0ec <_Heap_Extend+0x138>
} else if ( heap->area_end < extend_area_end ) {
800a0e0: 29 61 00 1c lw r1,(r11+28)
800a0e4: 50 2d 00 02 bgeu r1,r13,800a0ec <_Heap_Extend+0x138>
heap->area_end = extend_area_end;
800a0e8: 59 6d 00 1c sw (r11+28),r13
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
800a0ec: 2b 81 00 44 lw r1,(sp+68)
800a0f0: 2b 82 00 48 lw r2,(sp+72)
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
800a0f4: c8 22 18 00 sub r3,r1,r2
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
800a0f8: 58 4d 00 00 sw (r2+0),r13
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
800a0fc: 38 64 00 01 ori r4,r3,0x1
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
800a100: 58 23 00 00 sw (r1+0),r3
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
800a104: 29 63 00 20 lw r3,(r11+32)
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
800a108: 58 44 00 04 sw (r2+4),r4
extend_first_block_size | HEAP_PREV_BLOCK_USED;
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
extend_last_block->size_and_flag = 0;
800a10c: 58 20 00 04 sw (r1+4),r0
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
800a110: 50 43 00 03 bgeu r2,r3,800a11c <_Heap_Extend+0x168>
heap->first_block = extend_first_block;
800a114: 59 62 00 20 sw (r11+32),r2
800a118: e0 00 00 04 bi 800a128 <_Heap_Extend+0x174>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
800a11c: 29 62 00 24 lw r2,(r11+36)
800a120: 50 41 00 02 bgeu r2,r1,800a128 <_Heap_Extend+0x174>
heap->last_block = extend_last_block;
800a124: 59 61 00 24 sw (r11+36),r1
}
if ( merge_below_block != NULL ) {
800a128: 46 00 00 12 be r16,r0,800a170 <_Heap_Extend+0x1bc>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
800a12c: 29 6f 00 10 lw r15,(r11+16)
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
800a130: 35 ce 00 08 addi r14,r14,8
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
800a134: b9 c0 08 00 mv r1,r14
800a138: b9 e0 10 00 mv r2,r15
800a13c: f8 00 20 99 calli 80123a0 <__umodsi3>
if ( remainder != 0 ) {
800a140: 44 20 00 03 be r1,r0,800a14c <_Heap_Extend+0x198>
return value - remainder + alignment;
800a144: b5 cf 70 00 add r14,r14,r15
800a148: c9 c1 70 00 sub r14,r14,r1
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
800a14c: 2a 01 00 00 lw r1,(r16+0)
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
800a150: 35 c2 ff f8 addi r2,r14,-8
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
800a154: 59 c1 ff f8 sw (r14+-8),r1
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
800a158: ca 02 08 00 sub r1,r16,r2
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
800a15c: 38 21 00 01 ori r1,r1,0x1
800a160: 58 41 00 04 sw (r2+4),r1
_Heap_Free_block( heap, new_first_block );
800a164: b9 60 08 00 mv r1,r11
800a168: fb ff ff 86 calli 8009f80 <_Heap_Free_block>
800a16c: e0 00 00 06 bi 800a184 <_Heap_Extend+0x1d0>
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
_Heap_Merge_below( heap, extend_area_begin, merge_below_block );
} else if ( link_below_block != NULL ) {
800a170: 46 70 00 05 be r19,r16,800a184 <_Heap_Extend+0x1d0>
_Heap_Link_below(
800a174: 2b 81 00 44 lw r1,(sp+68)
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
800a178: ca 61 98 00 sub r19,r19,r1
800a17c: 3a 73 00 01 ori r19,r19,0x1
)
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
800a180: 58 33 00 04 sw (r1+4),r19
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
800a184: 45 80 00 14 be r12,r0,800a1d4 <_Heap_Extend+0x220>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
800a188: 29 62 00 10 lw r2,(r11+16)
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE,
800a18c: 35 ad ff f8 addi r13,r13,-8
uintptr_t extend_area_end
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
800a190: c9 ac 68 00 sub r13,r13,r12
800a194: b9 a0 08 00 mv r1,r13
800a198: f8 00 20 82 calli 80123a0 <__umodsi3>
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
(last_block->size_and_flag - last_block_new_size)
800a19c: 29 83 00 04 lw r3,(r12+4)
800a1a0: c9 a1 08 00 sub r1,r13,r1
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
800a1a4: b4 2c 10 00 add r2,r1,r12
(last_block->size_and_flag - last_block_new_size)
800a1a8: c8 61 18 00 sub r3,r3,r1
| HEAP_PREV_BLOCK_USED;
800a1ac: 38 63 00 01 ori r3,r3,0x1
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
800a1b0: 58 43 00 04 sw (r2+4),r3
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
800a1b4: 29 82 00 04 lw r2,(r12+4)
800a1b8: 20 42 00 01 andi r2,r2,0x1
block->size_and_flag = size | flag;
800a1bc: b8 22 08 00 or r1,r1,r2
800a1c0: 59 81 00 04 sw (r12+4),r1
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
800a1c4: b9 80 10 00 mv r2,r12
800a1c8: b9 60 08 00 mv r1,r11
800a1cc: fb ff ff 6d calli 8009f80 <_Heap_Free_block>
800a1d0: e0 00 00 0c bi 800a200 <_Heap_Extend+0x24c>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
800a1d4: 46 2c 00 0b be r17,r12,800a200 <_Heap_Extend+0x24c>
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
800a1d8: 2a 21 00 04 lw r1,(r17+4)
)
{
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
800a1dc: 2b 83 00 48 lw r3,(sp+72)
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
_Heap_Link_above(
800a1e0: 2b 82 00 44 lw r2,(sp+68)
800a1e4: 20 21 00 01 andi r1,r1,0x1
)
{
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
800a1e8: c8 71 18 00 sub r3,r3,r17
block->size_and_flag = size | flag;
800a1ec: b8 61 08 00 or r1,r3,r1
800a1f0: 5a 21 00 04 sw (r17+4),r1
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
800a1f4: 28 41 00 04 lw r1,(r2+4)
800a1f8: 38 21 00 01 ori r1,r1,0x1
800a1fc: 58 41 00 04 sw (r2+4),r1
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
800a200: 65 8c 00 00 cmpei r12,r12,0
800a204: 66 10 00 00 cmpei r16,r16,0
800a208: a1 90 60 00 and r12,r12,r16
800a20c: 45 80 00 04 be r12,r0,800a21c <_Heap_Extend+0x268>
_Heap_Free_block( heap, extend_first_block );
800a210: 2b 82 00 48 lw r2,(sp+72)
800a214: b9 60 08 00 mv r1,r11
800a218: fb ff ff 5a calli 8009f80 <_Heap_Free_block>
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
heap->last_block,
(uintptr_t) heap->first_block - (uintptr_t) heap->last_block
800a21c: 29 61 00 24 lw r1,(r11+36)
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
800a220: 29 63 00 20 lw r3,(r11+32)
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
800a224: 34 0c 00 01 mvi r12,1
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
800a228: 28 22 00 04 lw r2,(r1+4)
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
800a22c: c8 61 18 00 sub r3,r3,r1
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
800a230: 20 42 00 01 andi r2,r2,0x1
block->size_and_flag = size | flag;
800a234: b8 62 10 00 or r2,r3,r2
800a238: 58 22 00 04 sw (r1+4),r2
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
800a23c: 29 61 00 30 lw r1,(r11+48)
/* Statistics */
stats->size += extended_size;
800a240: 29 62 00 2c lw r2,(r11+44)
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
800a244: c8 37 08 00 sub r1,r1,r23
/* Statistics */
stats->size += extended_size;
800a248: b4 41 10 00 add r2,r2,r1
800a24c: 59 62 00 2c sw (r11+44),r2
if ( extended_size_ptr != NULL )
800a250: 46 80 00 04 be r20,r0,800a260 <_Heap_Extend+0x2ac> <== NEVER TAKEN
*extended_size_ptr = extended_size;
800a254: 5a 81 00 00 sw (r20+0),r1
800a258: e0 00 00 02 bi 800a260 <_Heap_Extend+0x2ac>
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
800a25c: 34 0c 00 00 mvi r12,0
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
800a260: b9 80 08 00 mv r1,r12
800a264: 2b 9d 00 04 lw ra,(sp+4)
800a268: 2b 8b 00 40 lw r11,(sp+64)
800a26c: 2b 8c 00 3c lw r12,(sp+60)
800a270: 2b 8d 00 38 lw r13,(sp+56)
800a274: 2b 8e 00 34 lw r14,(sp+52)
800a278: 2b 8f 00 30 lw r15,(sp+48)
800a27c: 2b 90 00 2c lw r16,(sp+44)
800a280: 2b 91 00 28 lw r17,(sp+40)
800a284: 2b 92 00 24 lw r18,(sp+36)
800a288: 2b 93 00 20 lw r19,(sp+32)
800a28c: 2b 94 00 1c lw r20,(sp+28)
800a290: 2b 95 00 18 lw r21,(sp+24)
800a294: 2b 96 00 14 lw r22,(sp+20)
800a298: 2b 97 00 10 lw r23,(sp+16)
800a29c: 2b 98 00 0c lw r24,(sp+12)
800a2a0: 2b 99 00 08 lw r25,(sp+8)
800a2a4: 37 9c 00 48 addi sp,sp,72
800a2a8: c3 a0 00 00 ret
0800eab8 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
800eab8: 37 9c ff f4 addi sp,sp,-12
800eabc: 5b 8b 00 0c sw (sp+12),r11
800eac0: 5b 8c 00 08 sw (sp+8),r12
800eac4: 5b 9d 00 04 sw (sp+4),ra
800eac8: b8 20 58 00 mv r11,r1
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
return true;
800eacc: 34 01 00 01 mvi r1,1
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
800ead0: 44 40 00 73 be r2,r0,800ec9c <_Heap_Free+0x1e4>
800ead4: 34 4c ff f8 addi r12,r2,-8
800ead8: b8 40 08 00 mv r1,r2
800eadc: 29 62 00 10 lw r2,(r11+16)
800eae0: f8 00 21 f6 calli 80172b8 <__umodsi3>
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
800eae4: 29 67 00 20 lw r7,(r11+32)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
800eae8: c9 81 18 00 sub r3,r12,r1
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;
800eaec: 34 01 00 00 mvi r1,0
800eaf0: 54 e3 00 03 bgu r7,r3,800eafc <_Heap_Free+0x44>
800eaf4: 29 61 00 24 lw r1,(r11+36)
800eaf8: f0 23 08 00 cmpgeu r1,r1,r3
}
alloc_begin = (uintptr_t) alloc_begin_ptr;
block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
800eafc: b8 20 10 00 mv r2,r1
return false;
800eb00: 34 01 00 00 mvi r1,0
}
alloc_begin = (uintptr_t) alloc_begin_ptr;
block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
800eb04: 44 40 00 66 be r2,r0,800ec9c <_Heap_Free+0x1e4>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
800eb08: 28 66 00 04 lw r6,(r3+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;
800eb0c: 34 04 ff fe mvi r4,-2
800eb10: a0 c4 20 00 and r4,r6,r4
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
800eb14: b4 64 10 00 add r2,r3,r4
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;
800eb18: 54 e2 00 03 bgu r7,r2,800eb24 <_Heap_Free+0x6c> <== NEVER TAKEN
800eb1c: 29 61 00 24 lw r1,(r11+36)
800eb20: f0 22 08 00 cmpgeu r1,r1,r2
_Heap_Protection_block_check( heap, block );
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
800eb24: b8 20 28 00 mv r5,r1
return false;
800eb28: 34 01 00 00 mvi r1,0
_Heap_Protection_block_check( heap, block );
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
800eb2c: 44 a0 00 5c be r5,r0,800ec9c <_Heap_Free+0x1e4> <== NEVER TAKEN
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
800eb30: 28 45 00 04 lw r5,(r2+4)
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;
800eb34: 20 a8 00 01 andi r8,r5,0x1
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
800eb38: 45 00 00 59 be r8,r0,800ec9c <_Heap_Free+0x1e4> <== NEVER TAKEN
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
800eb3c: 29 69 00 24 lw r9,(r11+36)
- 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;
800eb40: 34 01 ff fe mvi r1,-2
800eb44: a0 a1 28 00 and r5,r5,r1
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
800eb48: 34 08 00 00 mvi r8,0
800eb4c: 45 22 00 05 be r9,r2,800eb60 <_Heap_Free+0xa8>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
800eb50: b4 45 08 00 add r1,r2,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;
800eb54: 28 28 00 04 lw r8,(r1+4)
800eb58: 21 08 00 01 andi r8,r8,0x1
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
800eb5c: 65 08 00 00 cmpei r8,r8,0
800eb60: 20 c6 00 01 andi r6,r6,0x1
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
800eb64: 21 08 00 ff andi r8,r8,0xff
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
800eb68: 5c c0 00 24 bne r6,r0,800ebf8 <_Heap_Free+0x140>
uintptr_t const prev_size = block->prev_size;
800eb6c: 28 66 00 00 lw r6,(r3+0)
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;
800eb70: 34 01 00 00 mvi r1,0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
800eb74: c8 66 18 00 sub r3,r3,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;
800eb78: 54 e3 00 02 bgu r7,r3,800eb80 <_Heap_Free+0xc8> <== NEVER TAKEN
800eb7c: f1 23 08 00 cmpgeu r1,r9,r3
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
800eb80: b8 20 38 00 mv r7,r1
_HAssert( false );
return( false );
800eb84: 34 01 00 00 mvi r1,0
if ( !_Heap_Is_prev_used( block ) ) {
uintptr_t const prev_size = block->prev_size;
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
800eb88: 44 e0 00 45 be r7,r0,800ec9c <_Heap_Free+0x1e4> <== NEVER TAKEN
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;
800eb8c: 28 67 00 04 lw r7,(r3+4)
800eb90: 20 e7 00 01 andi r7,r7,0x1
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) ) {
800eb94: 44 e0 00 42 be r7,r0,800ec9c <_Heap_Free+0x1e4> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
800eb98: 45 00 00 0f be r8,r0,800ebd4 <_Heap_Free+0x11c>
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
800eb9c: 28 41 00 08 lw r1,(r2+8)
Heap_Block *prev = block->prev;
800eba0: 28 42 00 0c lw r2,(r2+12)
uintptr_t const size = block_size + prev_size + next_block_size;
800eba4: b4 85 28 00 add r5,r4,r5
800eba8: b4 a6 30 00 add r6,r5,r6
prev->next = next;
800ebac: 58 41 00 08 sw (r2+8),r1
next->prev = prev;
800ebb0: 58 22 00 0c sw (r1+12),r2
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
800ebb4: 29 61 00 38 lw r1,(r11+56)
800ebb8: 34 21 ff ff addi r1,r1,-1
800ebbc: 59 61 00 38 sw (r11+56),r1
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
800ebc0: 38 c1 00 01 ori r1,r6,0x1
800ebc4: 58 61 00 04 sw (r3+4),r1
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
800ebc8: b4 66 18 00 add r3,r3,r6
800ebcc: 58 66 00 00 sw (r3+0),r6
800ebd0: e0 00 00 29 bi 800ec74 <_Heap_Free+0x1bc>
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
800ebd4: b4 86 30 00 add r6,r4,r6
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
800ebd8: 38 c1 00 01 ori r1,r6,0x1
800ebdc: 58 61 00 04 sw (r3+4),r1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
800ebe0: 28 43 00 04 lw r3,(r2+4)
800ebe4: 34 01 ff fe mvi r1,-2
next_block->prev_size = size;
800ebe8: 58 46 00 00 sw (r2+0),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;
800ebec: a0 61 08 00 and r1,r3,r1
800ebf0: 58 41 00 04 sw (r2+4),r1
800ebf4: e0 00 00 20 bi 800ec74 <_Heap_Free+0x1bc>
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
800ebf8: 45 00 00 0d be r8,r0,800ec2c <_Heap_Free+0x174>
uintptr_t const size = block_size + next_block_size;
800ebfc: b4 a4 08 00 add r1,r5,r4
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
800ec00: 28 45 00 08 lw r5,(r2+8)
Heap_Block *prev = old_block->prev;
800ec04: 28 42 00 0c lw r2,(r2+12)
new_block->next = next;
800ec08: 58 65 00 08 sw (r3+8),r5
new_block->prev = prev;
800ec0c: 58 62 00 0c sw (r3+12),r2
next->prev = new_block;
prev->next = new_block;
800ec10: 58 43 00 08 sw (r2+8),r3
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
800ec14: 38 22 00 01 ori r2,r1,0x1
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
800ec18: 58 a3 00 0c sw (r5+12),r3
800ec1c: 58 62 00 04 sw (r3+4),r2
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
800ec20: b4 61 18 00 add r3,r3,r1
800ec24: 58 61 00 00 sw (r3+0),r1
800ec28: e0 00 00 13 bi 800ec74 <_Heap_Free+0x1bc>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
800ec2c: 29 61 00 08 lw r1,(r11+8)
new_block->next = next;
new_block->prev = block_before;
800ec30: 58 6b 00 0c sw (r3+12),r11
/* 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;
next_block->prev_size = block_size;
800ec34: 58 44 00 00 sw (r2+0),r4
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
800ec38: 58 61 00 08 sw (r3+8),r1
new_block->prev = block_before;
block_before->next = new_block;
next->prev = new_block;
800ec3c: 58 23 00 0c sw (r1+12),r3
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;
800ec40: 38 81 00 01 ori r1,r4,0x1
800ec44: 58 61 00 04 sw (r3+4),r1
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
800ec48: 59 63 00 08 sw (r11+8),r3
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
800ec4c: 28 43 00 04 lw r3,(r2+4)
800ec50: 34 01 ff fe mvi r1,-2
800ec54: a0 61 08 00 and r1,r3,r1
800ec58: 58 41 00 04 sw (r2+4),r1
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
800ec5c: 29 61 00 38 lw r1,(r11+56)
if ( stats->max_free_blocks < stats->free_blocks ) {
800ec60: 29 62 00 3c lw r2,(r11+60)
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
800ec64: 34 21 00 01 addi r1,r1,1
800ec68: 59 61 00 38 sw (r11+56),r1
if ( stats->max_free_blocks < stats->free_blocks ) {
800ec6c: 50 41 00 02 bgeu r2,r1,800ec74 <_Heap_Free+0x1bc>
stats->max_free_blocks = stats->free_blocks;
800ec70: 59 61 00 3c sw (r11+60),r1
}
}
/* Statistics */
--stats->used_blocks;
800ec74: 29 61 00 40 lw r1,(r11+64)
800ec78: 34 21 ff ff addi r1,r1,-1
800ec7c: 59 61 00 40 sw (r11+64),r1
++stats->frees;
800ec80: 29 61 00 50 lw r1,(r11+80)
800ec84: 34 21 00 01 addi r1,r1,1
800ec88: 59 61 00 50 sw (r11+80),r1
stats->free_size += block_size;
800ec8c: 29 61 00 30 lw r1,(r11+48)
800ec90: b4 24 20 00 add r4,r1,r4
800ec94: 59 64 00 30 sw (r11+48),r4
return( true );
800ec98: 34 01 00 01 mvi r1,1
}
800ec9c: 2b 9d 00 04 lw ra,(sp+4)
800eca0: 2b 8b 00 0c lw r11,(sp+12)
800eca4: 2b 8c 00 08 lw r12,(sp+8)
800eca8: 37 9c 00 0c addi sp,sp,12
800ecac: c3 a0 00 00 ret
0800ee0c <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
800ee0c: 37 9c ff ec addi sp,sp,-20
800ee10: 5b 8b 00 14 sw (sp+20),r11
800ee14: 5b 8c 00 10 sw (sp+16),r12
800ee18: 5b 8d 00 0c sw (sp+12),r13
800ee1c: 5b 8e 00 08 sw (sp+8),r14
800ee20: 5b 9d 00 04 sw (sp+4),ra
800ee24: b8 20 58 00 mv r11,r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
800ee28: 34 4e ff f8 addi r14,r2,-8
800ee2c: b8 40 08 00 mv r1,r2
800ee30: b8 40 60 00 mv r12,r2
800ee34: 29 62 00 10 lw r2,(r11+16)
800ee38: b8 60 68 00 mv r13,r3
800ee3c: f8 00 21 1f calli 80172b8 <__umodsi3>
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
800ee40: 29 62 00 20 lw r2,(r11+32)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
800ee44: c9 c1 20 00 sub r4,r14,r1
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;
800ee48: 34 01 00 00 mvi r1,0
800ee4c: 54 44 00 03 bgu r2,r4,800ee58 <_Heap_Size_of_alloc_area+0x4c>
800ee50: 29 61 00 24 lw r1,(r11+36)
800ee54: f0 24 08 00 cmpgeu r1,r1,r4
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
Heap_Block *next_block = NULL;
uintptr_t block_size = 0;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
800ee58: b8 20 18 00 mv r3,r1
return false;
800ee5c: 34 01 00 00 mvi r1,0
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
Heap_Block *next_block = NULL;
uintptr_t block_size = 0;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
800ee60: 44 60 00 13 be r3,r0,800eeac <_Heap_Size_of_alloc_area+0xa0><== NEVER TAKEN
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
800ee64: 28 83 00 04 lw r3,(r4+4)
800ee68: 34 01 ff fe mvi r1,-2
800ee6c: a0 23 08 00 and r1,r1,r3
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
800ee70: b4 81 20 00 add r4,r4,r1
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;
800ee74: 34 01 00 00 mvi r1,0
800ee78: 54 44 00 03 bgu r2,r4,800ee84 <_Heap_Size_of_alloc_area+0x78><== NEVER TAKEN
800ee7c: 29 61 00 24 lw r1,(r11+36)
800ee80: f0 24 08 00 cmpgeu r1,r1,r4
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
800ee84: b8 20 10 00 mv r2,r1
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
800ee88: 34 01 00 00 mvi r1,0
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
800ee8c: 44 40 00 08 be r2,r0,800eeac <_Heap_Size_of_alloc_area+0xa0><== NEVER TAKEN
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;
800ee90: 28 82 00 04 lw r2,(r4+4)
800ee94: 20 42 00 01 andi r2,r2,0x1
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
800ee98: 44 40 00 05 be r2,r0,800eeac <_Heap_Size_of_alloc_area+0xa0><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
800ee9c: c8 8c 20 00 sub r4,r4,r12
800eea0: 34 84 00 04 addi r4,r4,4
800eea4: 59 a4 00 00 sw (r13+0),r4
return true;
800eea8: 34 01 00 01 mvi r1,1
}
800eeac: 2b 9d 00 04 lw ra,(sp+4)
800eeb0: 2b 8b 00 14 lw r11,(sp+20)
800eeb4: 2b 8c 00 10 lw r12,(sp+16)
800eeb8: 2b 8d 00 0c lw r13,(sp+12)
800eebc: 2b 8e 00 08 lw r14,(sp+8)
800eec0: 37 9c 00 14 addi sp,sp,20
800eec4: c3 a0 00 00 ret
08004c4c <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
8004c4c: 37 9c ff a0 addi sp,sp,-96
8004c50: 5b 8b 00 50 sw (sp+80),r11
8004c54: 5b 8c 00 4c sw (sp+76),r12
8004c58: 5b 8d 00 48 sw (sp+72),r13
8004c5c: 5b 8e 00 44 sw (sp+68),r14
8004c60: 5b 8f 00 40 sw (sp+64),r15
8004c64: 5b 90 00 3c sw (sp+60),r16
8004c68: 5b 91 00 38 sw (sp+56),r17
8004c6c: 5b 92 00 34 sw (sp+52),r18
8004c70: 5b 93 00 30 sw (sp+48),r19
8004c74: 5b 94 00 2c sw (sp+44),r20
8004c78: 5b 95 00 28 sw (sp+40),r21
8004c7c: 5b 96 00 24 sw (sp+36),r22
8004c80: 5b 97 00 20 sw (sp+32),r23
8004c84: 5b 98 00 1c sw (sp+28),r24
8004c88: 5b 99 00 18 sw (sp+24),r25
8004c8c: 5b 9b 00 14 sw (sp+20),fp
8004c90: 5b 9d 00 10 sw (sp+16),ra
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;
8004c94: 78 0d 08 00 mvhi r13,0x800
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
8004c98: 20 63 00 ff andi r3,r3,0xff
8004c9c: b8 20 60 00 mv r12,r1
8004ca0: b8 40 70 00 mv r14,r2
uintptr_t const page_size = heap->page_size;
8004ca4: 28 33 00 10 lw r19,(r1+16)
uintptr_t const min_block_size = heap->min_block_size;
8004ca8: 28 35 00 14 lw r21,(r1+20)
Heap_Block *const first_block = heap->first_block;
8004cac: 28 34 00 20 lw r20,(r1+32)
Heap_Block *const last_block = heap->last_block;
8004cb0: 28 36 00 24 lw r22,(r1+36)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
8004cb4: 39 ad 4b b4 ori r13,r13,0x4bb4
8004cb8: 44 60 00 03 be r3,r0,8004cc4 <_Heap_Walk+0x78>
8004cbc: 78 0d 08 00 mvhi r13,0x800
8004cc0: 39 ad 4b d8 ori r13,r13,0x4bd8
if ( !_System_state_Is_up( _System_state_Get() ) ) {
8004cc4: 78 03 08 01 mvhi r3,0x801
8004cc8: 38 63 6a a8 ori r3,r3,0x6aa8
8004ccc: 28 67 00 00 lw r7,(r3+0)
8004cd0: 34 02 00 03 mvi r2,3
return true;
8004cd4: 34 03 00 01 mvi r3,1
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() ) ) {
8004cd8: 5c e2 01 08 bne r7,r2,80050f8 <_Heap_Walk+0x4ac> <== NEVER TAKEN
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)(
8004cdc: 29 81 00 08 lw r1,(r12+8)
8004ce0: 29 86 00 18 lw r6,(r12+24)
8004ce4: 29 87 00 1c lw r7,(r12+28)
8004ce8: 5b 81 00 08 sw (sp+8),r1
8004cec: 29 81 00 0c lw r1,(r12+12)
8004cf0: 78 03 08 01 mvhi r3,0x801
8004cf4: 5b 96 00 04 sw (sp+4),r22
8004cf8: 5b 81 00 0c sw (sp+12),r1
8004cfc: 34 02 00 00 mvi r2,0
8004d00: b9 c0 08 00 mv r1,r14
8004d04: 38 63 41 e4 ori r3,r3,0x41e4
8004d08: ba 60 20 00 mv r4,r19
8004d0c: ba a0 28 00 mv r5,r21
8004d10: ba 80 40 00 mv r8,r20
8004d14: d9 a0 00 00 call r13
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
8004d18: 5e 60 00 06 bne r19,r0,8004d30 <_Heap_Walk+0xe4>
(*printer)( source, true, "page size is zero\n" );
8004d1c: 78 03 08 01 mvhi r3,0x801
8004d20: b9 c0 08 00 mv r1,r14
8004d24: 34 02 00 01 mvi r2,1
8004d28: 38 63 42 78 ori r3,r3,0x4278
8004d2c: e0 00 00 25 bi 8004dc0 <_Heap_Walk+0x174>
)
{
#if (CPU_ALIGNMENT == 0)
return true;
#else
return (((uintptr_t)address % CPU_ALIGNMENT) == 0);
8004d30: 22 6f 00 07 andi r15,r19,0x7
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
8004d34: 45 e0 00 07 be r15,r0,8004d50 <_Heap_Walk+0x104>
(*printer)(
8004d38: 78 03 08 01 mvhi r3,0x801
8004d3c: b9 c0 08 00 mv r1,r14
8004d40: 34 02 00 01 mvi r2,1
8004d44: 38 63 42 8c ori r3,r3,0x428c
8004d48: ba 60 20 00 mv r4,r19
8004d4c: e0 00 01 04 bi 800515c <_Heap_Walk+0x510>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
8004d50: ba a0 08 00 mv r1,r21
8004d54: ba 60 10 00 mv r2,r19
8004d58: fb ff ef 94 calli 8000ba8 <__umodsi3>
8004d5c: b8 20 58 00 mv r11,r1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
8004d60: 44 2f 00 07 be r1,r15,8004d7c <_Heap_Walk+0x130>
(*printer)(
8004d64: 78 03 08 01 mvhi r3,0x801
8004d68: b9 c0 08 00 mv r1,r14
8004d6c: 34 02 00 01 mvi r2,1
8004d70: 38 63 42 ac ori r3,r3,0x42ac
8004d74: ba a0 20 00 mv r4,r21
8004d78: e0 00 00 f9 bi 800515c <_Heap_Walk+0x510>
8004d7c: 36 81 00 08 addi r1,r20,8
8004d80: ba 60 10 00 mv r2,r19
8004d84: fb ff ef 89 calli 8000ba8 <__umodsi3>
);
return false;
}
if (
8004d88: 44 2b 00 07 be r1,r11,8004da4 <_Heap_Walk+0x158>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
8004d8c: 78 03 08 01 mvhi r3,0x801
8004d90: b9 c0 08 00 mv r1,r14
8004d94: 34 02 00 01 mvi r2,1
8004d98: 38 63 42 d0 ori r3,r3,0x42d0
8004d9c: ba 80 20 00 mv r4,r20
8004da0: e0 00 00 ef bi 800515c <_Heap_Walk+0x510>
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;
8004da4: 2a 82 00 04 lw r2,(r20+4)
8004da8: 20 42 00 01 andi r2,r2,0x1
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
8004dac: 5c 41 00 07 bne r2,r1,8004dc8 <_Heap_Walk+0x17c>
(*printer)(
8004db0: 78 03 08 01 mvhi r3,0x801
8004db4: b9 c0 08 00 mv r1,r14
8004db8: 34 02 00 01 mvi r2,1
8004dbc: 38 63 43 04 ori r3,r3,0x4304
8004dc0: d9 a0 00 00 call r13
8004dc4: e0 00 00 40 bi 8004ec4 <_Heap_Walk+0x278>
- 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;
8004dc8: 2a cf 00 04 lw r15,(r22+4)
8004dcc: 34 02 ff fe mvi r2,-2
8004dd0: a0 4f 78 00 and r15,r2,r15
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
8004dd4: b6 cf 78 00 add r15,r22,r15
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;
8004dd8: 29 e2 00 04 lw r2,(r15+4)
8004ddc: 20 42 00 01 andi r2,r2,0x1
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
8004de0: 5c 41 00 06 bne r2,r1,8004df8 <_Heap_Walk+0x1ac>
(*printer)(
8004de4: 78 03 08 01 mvhi r3,0x801
8004de8: b9 c0 08 00 mv r1,r14
8004dec: 34 02 00 01 mvi r2,1
8004df0: 38 63 43 34 ori r3,r3,0x4334
8004df4: e3 ff ff f3 bi 8004dc0 <_Heap_Walk+0x174>
);
return false;
}
if (
8004df8: 45 f4 00 06 be r15,r20,8004e10 <_Heap_Walk+0x1c4>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
8004dfc: 78 03 08 01 mvhi r3,0x801
8004e00: b9 c0 08 00 mv r1,r14
8004e04: 34 02 00 01 mvi r2,1
8004e08: 38 63 43 4c ori r3,r3,0x434c
8004e0c: e3 ff ff ed bi 8004dc0 <_Heap_Walk+0x174>
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
8004e10: 29 92 00 10 lw r18,(r12+16)
block = next_block;
} while ( block != first_block );
return true;
}
8004e14: 29 8b 00 08 lw r11,(r12+8)
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
8004e18: b9 80 80 00 mv r16,r12
- 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;
8004e1c: 34 11 ff fe mvi r17,-2
8004e20: e0 00 00 2d bi 8004ed4 <_Heap_Walk+0x288>
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;
8004e24: 29 83 00 20 lw r3,(r12+32)
8004e28: 34 01 00 00 mvi r1,0
8004e2c: 54 6b 00 03 bgu r3,r11,8004e38 <_Heap_Walk+0x1ec>
8004e30: 29 81 00 24 lw r1,(r12+36)
8004e34: f0 2b 08 00 cmpgeu r1,r1,r11
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
8004e38: 5c 20 00 06 bne r1,r0,8004e50 <_Heap_Walk+0x204>
(*printer)(
8004e3c: 78 03 08 01 mvhi r3,0x801
8004e40: b9 c0 08 00 mv r1,r14
8004e44: 34 02 00 01 mvi r2,1
8004e48: 38 63 43 7c ori r3,r3,0x437c
8004e4c: e0 00 00 14 bi 8004e9c <_Heap_Walk+0x250>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
8004e50: 35 61 00 08 addi r1,r11,8
8004e54: ba 40 10 00 mv r2,r18
8004e58: fb ff ef 54 calli 8000ba8 <__umodsi3>
);
return false;
}
if (
8004e5c: 44 20 00 06 be r1,r0,8004e74 <_Heap_Walk+0x228>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
8004e60: 78 03 08 01 mvhi r3,0x801
8004e64: b9 c0 08 00 mv r1,r14
8004e68: 34 02 00 01 mvi r2,1
8004e6c: 38 63 43 9c ori r3,r3,0x439c
8004e70: e0 00 00 0b bi 8004e9c <_Heap_Walk+0x250>
- 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;
8004e74: 29 63 00 04 lw r3,(r11+4)
8004e78: a2 23 18 00 and r3,r17,r3
block = next_block;
} while ( block != first_block );
return true;
}
8004e7c: b5 63 18 00 add r3,r11,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;
8004e80: 28 63 00 04 lw r3,(r3+4)
8004e84: 20 63 00 01 andi r3,r3,0x1
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
8004e88: 44 61 00 07 be r3,r1,8004ea4 <_Heap_Walk+0x258>
(*printer)(
8004e8c: 78 03 08 01 mvhi r3,0x801
8004e90: b9 c0 08 00 mv r1,r14
8004e94: 34 02 00 01 mvi r2,1
8004e98: 38 63 43 cc ori r3,r3,0x43cc
8004e9c: b9 60 20 00 mv r4,r11
8004ea0: e0 00 00 af bi 800515c <_Heap_Walk+0x510>
);
return false;
}
if ( free_block->prev != prev_block ) {
8004ea4: 29 65 00 0c lw r5,(r11+12)
8004ea8: 44 b0 00 09 be r5,r16,8004ecc <_Heap_Walk+0x280>
(*printer)(
8004eac: 78 03 08 01 mvhi r3,0x801
8004eb0: b9 c0 08 00 mv r1,r14
8004eb4: 34 02 00 01 mvi r2,1
8004eb8: 38 63 43 e8 ori r3,r3,0x43e8
8004ebc: b9 60 20 00 mv r4,r11
8004ec0: d9 a0 00 00 call r13
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
8004ec4: 34 03 00 00 mvi r3,0
8004ec8: e0 00 00 8c bi 80050f8 <_Heap_Walk+0x4ac>
return false;
}
prev_block = free_block;
free_block = free_block->next;
8004ecc: b9 60 80 00 mv r16,r11
8004ed0: 29 6b 00 08 lw r11,(r11+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 ) {
8004ed4: 5d 6c ff d4 bne r11,r12,8004e24 <_Heap_Walk+0x1d8>
8004ed8: e0 00 00 03 bi 8004ee4 <_Heap_Walk+0x298>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
8004edc: ba 20 78 00 mv r15,r17
8004ee0: e0 00 00 15 bi 8004f34 <_Heap_Walk+0x2e8>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
8004ee4: 78 01 08 01 mvhi r1,0x801
8004ee8: 38 21 45 98 ori r1,r1,0x4598
8004eec: 5b 81 00 54 sw (sp+84),r1
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
(*printer)(
8004ef0: 78 01 08 01 mvhi r1,0x801
8004ef4: 38 21 45 80 ori r1,r1,0x4580
8004ef8: 5b 81 00 58 sw (sp+88),r1
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)(
8004efc: 78 01 08 01 mvhi r1,0x801
8004f00: 38 21 41 ac ori r1,r1,0x41ac
8004f04: 5b 81 00 5c sw (sp+92),r1
8004f08: 78 01 08 01 mvhi r1,0x801
8004f0c: 38 21 41 c8 ori r1,r1,0x41c8
8004f10: 78 1b 08 01 mvhi fp,0x801
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
8004f14: 78 17 08 01 mvhi r23,0x801
8004f18: 78 19 08 01 mvhi r25,0x801
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
8004f1c: 78 18 08 01 mvhi r24,0x801
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)(
8004f20: 5b 81 00 60 sw (sp+96),r1
8004f24: 3b 7b 44 dc ori fp,fp,0x44dc
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
8004f28: 3a f7 45 4c ori r23,r23,0x454c
8004f2c: 3b 39 41 d8 ori r25,r25,0x41d8
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
8004f30: 3b 18 41 bc ori r24,r24,0x41bc
block = next_block;
} while ( block != first_block );
return true;
}
8004f34: 29 f2 00 04 lw r18,(r15+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;
8004f38: 34 01 ff fe mvi r1,-2
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;
8004f3c: 29 84 00 20 lw r4,(r12+32)
- 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;
8004f40: a2 41 80 00 and r16,r18,r1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
8004f44: b5 f0 88 00 add r17,r15,r16
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;
8004f48: 34 06 00 00 mvi r6,0
8004f4c: 54 91 00 03 bgu r4,r17,8004f58 <_Heap_Walk+0x30c> <== NEVER TAKEN
8004f50: 29 86 00 24 lw r6,(r12+36)
8004f54: f0 d1 30 00 cmpgeu r6,r6,r17
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
8004f58: 5c c0 00 06 bne r6,r0,8004f70 <_Heap_Walk+0x324>
(*printer)(
8004f5c: 78 03 08 01 mvhi r3,0x801
8004f60: b9 c0 08 00 mv r1,r14
8004f64: 34 02 00 01 mvi r2,1
8004f68: 38 63 44 1c ori r3,r3,0x441c
8004f6c: e0 00 00 1f bi 8004fe8 <_Heap_Walk+0x39c>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
8004f70: ba 00 08 00 mv r1,r16
8004f74: ba 60 10 00 mv r2,r19
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;
8004f78: fd f6 58 00 cmpne r11,r15,r22
8004f7c: fb ff ef 0b calli 8000ba8 <__umodsi3>
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
8004f80: 44 20 00 09 be r1,r0,8004fa4 <_Heap_Walk+0x358>
8004f84: 45 60 00 08 be r11,r0,8004fa4 <_Heap_Walk+0x358>
(*printer)(
8004f88: 78 03 08 01 mvhi r3,0x801
8004f8c: b9 c0 08 00 mv r1,r14
8004f90: 34 02 00 01 mvi r2,1
8004f94: 38 63 44 4c ori r3,r3,0x444c
8004f98: b9 e0 20 00 mv r4,r15
8004f9c: ba 00 28 00 mv r5,r16
8004fa0: e3 ff ff c8 bi 8004ec0 <_Heap_Walk+0x274>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
8004fa4: 52 15 00 0b bgeu r16,r21,8004fd0 <_Heap_Walk+0x384>
8004fa8: 45 60 00 0a be r11,r0,8004fd0 <_Heap_Walk+0x384> <== NEVER TAKEN
(*printer)(
8004fac: 78 03 08 01 mvhi r3,0x801
8004fb0: b9 c0 08 00 mv r1,r14
8004fb4: 34 02 00 01 mvi r2,1
8004fb8: 38 63 44 7c ori r3,r3,0x447c
8004fbc: b9 e0 20 00 mv r4,r15
8004fc0: ba 00 28 00 mv r5,r16
8004fc4: ba a0 30 00 mv r6,r21
8004fc8: d9 a0 00 00 call r13
8004fcc: e3 ff ff be bi 8004ec4 <_Heap_Walk+0x278>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
8004fd0: 56 2f 00 09 bgu r17,r15,8004ff4 <_Heap_Walk+0x3a8>
8004fd4: 45 60 00 08 be r11,r0,8004ff4 <_Heap_Walk+0x3a8>
(*printer)(
8004fd8: 78 03 08 01 mvhi r3,0x801
8004fdc: b9 c0 08 00 mv r1,r14
8004fe0: 34 02 00 01 mvi r2,1
8004fe4: 38 63 44 a8 ori r3,r3,0x44a8
8004fe8: b9 e0 20 00 mv r4,r15
8004fec: ba 20 28 00 mv r5,r17
8004ff0: e3 ff ff b4 bi 8004ec0 <_Heap_Walk+0x274>
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;
8004ff4: 2a 24 00 04 lw r4,(r17+4)
8004ff8: 22 52 00 01 andi r18,r18,0x1
8004ffc: 20 84 00 01 andi r4,r4,0x1
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
8005000: 5c 80 00 2d bne r4,r0,80050b4 <_Heap_Walk+0x468>
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 ?
8005004: 29 e6 00 0c lw r6,(r15+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)(
8005008: 29 85 00 08 lw r5,(r12+8)
block = next_block;
} while ( block != first_block );
return true;
}
800500c: 29 84 00 0c lw r4,(r12+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)(
8005010: 2b 87 00 5c lw r7,(sp+92)
8005014: 44 c5 00 04 be r6,r5,8005024 <_Heap_Walk+0x3d8>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
8005018: ba e0 38 00 mv r7,r23
800501c: 5c cc 00 02 bne r6,r12,8005024 <_Heap_Walk+0x3d8>
8005020: bb 00 38 00 mv r7,r24
block->next,
block->next == last_free_block ?
8005024: 29 e8 00 08 lw r8,(r15+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)(
8005028: 2b 89 00 60 lw r9,(sp+96)
800502c: 45 04 00 04 be r8,r4,800503c <_Heap_Walk+0x3f0>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
8005030: ba e0 48 00 mv r9,r23
8005034: 5d 0c 00 02 bne r8,r12,800503c <_Heap_Walk+0x3f0>
8005038: bb 20 48 00 mv r9,r25
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)(
800503c: 5b 89 00 04 sw (sp+4),r9
8005040: b9 c0 08 00 mv r1,r14
8005044: 34 02 00 00 mvi r2,0
8005048: bb 60 18 00 mv r3,fp
800504c: b9 e0 20 00 mv r4,r15
8005050: ba 00 28 00 mv r5,r16
8005054: d9 a0 00 00 call r13
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
8005058: 2a 26 00 00 lw r6,(r17+0)
800505c: 46 06 00 0a be r16,r6,8005084 <_Heap_Walk+0x438>
(*printer)(
8005060: 78 03 08 01 mvhi r3,0x801
8005064: b9 c0 08 00 mv r1,r14
8005068: 34 02 00 01 mvi r2,1
800506c: 38 63 45 14 ori r3,r3,0x4514
8005070: b9 e0 20 00 mv r4,r15
8005074: ba 00 28 00 mv r5,r16
8005078: ba 20 38 00 mv r7,r17
800507c: d9 a0 00 00 call r13
8005080: e3 ff ff 91 bi 8004ec4 <_Heap_Walk+0x278>
);
return false;
}
if ( !prev_used ) {
8005084: 5e 40 00 06 bne r18,r0,800509c <_Heap_Walk+0x450>
(*printer)(
8005088: 78 03 08 01 mvhi r3,0x801
800508c: b9 c0 08 00 mv r1,r14
8005090: 34 02 00 01 mvi r2,1
8005094: 38 63 45 50 ori r3,r3,0x4550
8005098: e0 00 00 30 bi 8005158 <_Heap_Walk+0x50c>
block = next_block;
} while ( block != first_block );
return true;
}
800509c: 29 85 00 08 lw r5,(r12+8)
80050a0: e0 00 00 03 bi 80050ac <_Heap_Walk+0x460>
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
if ( free_block == block ) {
80050a4: 44 af 00 13 be r5,r15,80050f0 <_Heap_Walk+0x4a4>
return true;
}
free_block = free_block->next;
80050a8: 28 a5 00 08 lw r5,(r5+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 ) {
80050ac: 5c ac ff fe bne r5,r12,80050a4 <_Heap_Walk+0x458>
80050b0: e0 00 00 26 bi 8005148 <_Heap_Walk+0x4fc>
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
80050b4: 46 40 00 08 be r18,r0,80050d4 <_Heap_Walk+0x488>
(*printer)(
80050b8: 2b 83 00 58 lw r3,(sp+88)
80050bc: b9 c0 08 00 mv r1,r14
80050c0: 34 02 00 00 mvi r2,0
80050c4: b9 e0 20 00 mv r4,r15
80050c8: ba 00 28 00 mv r5,r16
80050cc: d9 a0 00 00 call r13
80050d0: e0 00 00 08 bi 80050f0 <_Heap_Walk+0x4a4>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
80050d4: 2b 83 00 54 lw r3,(sp+84)
80050d8: 29 e6 00 00 lw r6,(r15+0)
80050dc: b9 c0 08 00 mv r1,r14
80050e0: 34 02 00 00 mvi r2,0
80050e4: b9 e0 20 00 mv r4,r15
80050e8: ba 00 28 00 mv r5,r16
80050ec: d9 a0 00 00 call r13
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
80050f0: 5e 91 ff 7b bne r20,r17,8004edc <_Heap_Walk+0x290>
return true;
80050f4: 34 03 00 01 mvi r3,1
}
80050f8: b8 60 08 00 mv r1,r3
80050fc: 2b 9d 00 10 lw ra,(sp+16)
8005100: 2b 8b 00 50 lw r11,(sp+80)
8005104: 2b 8c 00 4c lw r12,(sp+76)
8005108: 2b 8d 00 48 lw r13,(sp+72)
800510c: 2b 8e 00 44 lw r14,(sp+68)
8005110: 2b 8f 00 40 lw r15,(sp+64)
8005114: 2b 90 00 3c lw r16,(sp+60)
8005118: 2b 91 00 38 lw r17,(sp+56)
800511c: 2b 92 00 34 lw r18,(sp+52)
8005120: 2b 93 00 30 lw r19,(sp+48)
8005124: 2b 94 00 2c lw r20,(sp+44)
8005128: 2b 95 00 28 lw r21,(sp+40)
800512c: 2b 96 00 24 lw r22,(sp+36)
8005130: 2b 97 00 20 lw r23,(sp+32)
8005134: 2b 98 00 1c lw r24,(sp+28)
8005138: 2b 99 00 18 lw r25,(sp+24)
800513c: 2b 9b 00 14 lw fp,(sp+20)
8005140: 37 9c 00 60 addi sp,sp,96
8005144: c3 a0 00 00 ret
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
8005148: 78 03 08 01 mvhi r3,0x801
800514c: b9 c0 08 00 mv r1,r14
8005150: 34 02 00 01 mvi r2,1
8005154: 38 63 45 c0 ori r3,r3,0x45c0
8005158: b9 e0 20 00 mv r4,r15
800515c: d9 a0 00 00 call r13
8005160: e3 ff ff 59 bi 8004ec4 <_Heap_Walk+0x278>
08004534 <_IO_Manager_initialization>:
* workspace.
*
*/
void _IO_Manager_initialization(void)
{
8004534: 37 9c ff e8 addi sp,sp,-24
8004538: 5b 8b 00 18 sw (sp+24),r11
800453c: 5b 8c 00 14 sw (sp+20),r12
8004540: 5b 8d 00 10 sw (sp+16),r13
8004544: 5b 8e 00 0c sw (sp+12),r14
8004548: 5b 8f 00 08 sw (sp+8),r15
800454c: 5b 9d 00 04 sw (sp+4),ra
uint32_t index;
rtems_driver_address_table *driver_table;
uint32_t drivers_in_table;
uint32_t number_of_drivers;
driver_table = Configuration.Device_driver_table;
8004550: 78 01 08 01 mvhi r1,0x801
8004554: 38 21 90 dc ori r1,r1,0x90dc
drivers_in_table = Configuration.number_of_device_drivers;
8004558: 28 2d 00 30 lw r13,(r1+48)
number_of_drivers = Configuration.maximum_drivers;
800455c: 28 2b 00 2c lw r11,(r1+44)
uint32_t index;
rtems_driver_address_table *driver_table;
uint32_t drivers_in_table;
uint32_t number_of_drivers;
driver_table = Configuration.Device_driver_table;
8004560: 28 2e 00 34 lw r14,(r1+52)
/*
* If the user claims there are less drivers than are actually in
* the table, then let's just go with the table's count.
*/
if ( number_of_drivers <= drivers_in_table )
8004564: 51 ab 00 03 bgeu r13,r11,8004570 <_IO_Manager_initialization+0x3c>
/*
* If the maximum number of driver is the same as the number in the
* table, then we do not have to copy the driver table. They can't
* register any dynamically.
*/
if ( number_of_drivers == drivers_in_table ) {
8004568: 5d 6d 00 0a bne r11,r13,8004590 <_IO_Manager_initialization+0x5c><== ALWAYS TAKEN
800456c: e0 00 00 02 bi 8004574 <_IO_Manager_initialization+0x40> <== NOT EXECUTED
/*
* If the user claims there are less drivers than are actually in
* the table, then let's just go with the table's count.
*/
if ( number_of_drivers <= drivers_in_table )
8004570: b9 a0 58 00 mv r11,r13
* If the maximum number of driver is the same as the number in the
* table, then we do not have to copy the driver table. They can't
* register any dynamically.
*/
if ( number_of_drivers == drivers_in_table ) {
_IO_Driver_address_table = driver_table;
8004574: 78 01 08 01 mvhi r1,0x801
8004578: 38 21 a2 ac ori r1,r1,0xa2ac
800457c: 58 2e 00 00 sw (r1+0),r14
_IO_Number_of_drivers = number_of_drivers;
8004580: 78 01 08 01 mvhi r1,0x801
8004584: 38 21 a2 a8 ori r1,r1,0xa2a8
8004588: 58 2b 00 00 sw (r1+0),r11
return;
800458c: e0 00 00 27 bi 8004628 <_IO_Manager_initialization+0xf4>
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
8004590: 34 02 00 01 mvi r2,1
8004594: b9 60 08 00 mv r1,r11
8004598: f8 00 4a 5e calli 8016f10 <__ashlsi3>
800459c: 34 02 00 03 mvi r2,3
80045a0: b4 2b 08 00 add r1,r1,r11
80045a4: f8 00 4a 5b calli 8016f10 <__ashlsi3>
80045a8: b8 20 78 00 mv r15,r1
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
_Workspace_Allocate_or_fatal_error(
80045ac: f8 00 0e 58 calli 8007f0c <_Workspace_Allocate_or_fatal_error>
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
80045b0: 78 02 08 01 mvhi r2,0x801
80045b4: 38 42 a2 a8 ori r2,r2,0xa2a8
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
80045b8: 78 0c 08 01 mvhi r12,0x801
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
80045bc: 58 4b 00 00 sw (r2+0),r11
memset(
80045c0: b9 e0 18 00 mv r3,r15
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
80045c4: 39 8c a2 ac ori r12,r12,0xa2ac
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
memset(
80045c8: 34 02 00 00 mvi r2,0
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
80045cc: 59 81 00 00 sw (r12+0),r1
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
memset(
80045d0: f8 00 36 9f calli 801204c <memset>
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
80045d4: 34 03 00 00 mvi r3,0
80045d8: 34 04 00 00 mvi r4,0
80045dc: e0 00 00 12 bi 8004624 <_IO_Manager_initialization+0xf0>
_IO_Driver_address_table[index] = driver_table[index];
80045e0: 29 82 00 00 lw r2,(r12+0)
* registration. The driver table is now allocated in the
* workspace.
*
*/
void _IO_Manager_initialization(void)
80045e4: b5 c3 08 00 add r1,r14,r3
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
80045e8: 28 29 00 00 lw r9,(r1+0)
80045ec: 28 28 00 04 lw r8,(r1+4)
80045f0: 28 27 00 08 lw r7,(r1+8)
80045f4: 28 26 00 0c lw r6,(r1+12)
80045f8: 28 25 00 10 lw r5,(r1+16)
80045fc: 28 21 00 14 lw r1,(r1+20)
8004600: b4 43 10 00 add r2,r2,r3
8004604: 58 49 00 00 sw (r2+0),r9
8004608: 58 48 00 04 sw (r2+4),r8
800460c: 58 47 00 08 sw (r2+8),r7
8004610: 58 46 00 0c sw (r2+12),r6
8004614: 58 45 00 10 sw (r2+16),r5
8004618: 58 41 00 14 sw (r2+20),r1
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
800461c: 34 84 00 01 addi r4,r4,1
8004620: 34 63 00 18 addi r3,r3,24
8004624: 55 a4 ff ef bgu r13,r4,80045e0 <_IO_Manager_initialization+0xac>
_IO_Driver_address_table[index] = driver_table[index];
}
8004628: 2b 9d 00 04 lw ra,(sp+4)
800462c: 2b 8b 00 18 lw r11,(sp+24)
8004630: 2b 8c 00 14 lw r12,(sp+20)
8004634: 2b 8d 00 10 lw r13,(sp+16)
8004638: 2b 8e 00 0c lw r14,(sp+12)
800463c: 2b 8f 00 08 lw r15,(sp+8)
8004640: 37 9c 00 18 addi sp,sp,24
8004644: c3 a0 00 00 ret
0800567c <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
800567c: 37 9c ff ec addi sp,sp,-20
8005680: 5b 8b 00 14 sw (sp+20),r11
8005684: 5b 8c 00 10 sw (sp+16),r12
8005688: 5b 8d 00 0c sw (sp+12),r13
800568c: 5b 8e 00 08 sw (sp+8),r14
8005690: 5b 9d 00 04 sw (sp+4),ra
8005694: b8 20 58 00 mv r11,r1
* If the application is using the optional manager stubs and
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
8005698: 28 21 00 18 lw r1,(r1+24)
return NULL;
800569c: 34 0c 00 00 mvi r12,0
* If the application is using the optional manager stubs and
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
80056a0: 44 20 00 1e be r1,r0,8005718 <_Objects_Allocate+0x9c> <== NEVER TAKEN
/*
* OK. The manager should be initialized and configured to have objects.
* With any luck, it is safe to attempt to allocate an object.
*/
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
80056a4: 35 6d 00 20 addi r13,r11,32
80056a8: b9 a0 08 00 mv r1,r13
80056ac: fb ff fd 3d calli 8004ba0 <_Chain_Get>
80056b0: b8 20 60 00 mv r12,r1
80056b4: b8 20 70 00 mv r14,r1
if ( information->auto_extend ) {
80056b8: 41 61 00 12 lbu r1,(r11+18)
80056bc: 44 20 00 17 be r1,r0,8005718 <_Objects_Allocate+0x9c>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
80056c0: 5d 80 00 07 bne r12,r0,80056dc <_Objects_Allocate+0x60>
_Objects_Extend_information( information );
80056c4: b9 60 08 00 mv r1,r11
80056c8: f8 00 00 32 calli 8005790 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
80056cc: b9 a0 08 00 mv r1,r13
80056d0: fb ff fd 34 calli 8004ba0 <_Chain_Get>
80056d4: b8 20 60 00 mv r12,r1
}
if ( the_object ) {
80056d8: 44 2e 00 10 be r1,r14,8005718 <_Objects_Allocate+0x9c>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
80056dc: 2d 82 00 0a lhu r2,(r12+10)
80056e0: 2d 61 00 0a lhu r1,(r11+10)
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
80056e4: c8 41 08 00 sub r1,r2,r1
80056e8: 2d 62 00 14 lhu r2,(r11+20)
80056ec: f8 00 46 e3 calli 8017278 <__udivsi3>
information->inactive_per_block[ block ]--;
80056f0: 34 02 00 02 mvi r2,2
80056f4: f8 00 46 07 calli 8016f10 <__ashlsi3>
80056f8: 29 62 00 30 lw r2,(r11+48)
80056fc: b4 41 08 00 add r1,r2,r1
8005700: 28 22 00 00 lw r2,(r1+0)
8005704: 34 42 ff ff addi r2,r2,-1
8005708: 58 22 00 00 sw (r1+0),r2
information->inactive--;
800570c: 2d 61 00 2c lhu r1,(r11+44)
8005710: 34 21 ff ff addi r1,r1,-1
8005714: 0d 61 00 2c sh (r11+44),r1
);
}
#endif
return the_object;
}
8005718: b9 80 08 00 mv r1,r12
800571c: 2b 9d 00 04 lw ra,(sp+4)
8005720: 2b 8b 00 14 lw r11,(sp+20)
8005724: 2b 8c 00 10 lw r12,(sp+16)
8005728: 2b 8d 00 0c lw r13,(sp+12)
800572c: 2b 8e 00 08 lw r14,(sp+8)
8005730: 37 9c 00 14 addi sp,sp,20
8005734: c3 a0 00 00 ret
0800ef14 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
800ef14: 37 9c ff ec addi sp,sp,-20
800ef18: 5b 8b 00 14 sw (sp+20),r11
800ef1c: 5b 8c 00 10 sw (sp+16),r12
800ef20: 5b 8d 00 0c sw (sp+12),r13
800ef24: 5b 8e 00 08 sw (sp+8),r14
800ef28: 5b 9d 00 04 sw (sp+4),ra
800ef2c: 20 4c ff ff andi r12,r2,0xffff
800ef30: b8 20 70 00 mv r14,r1
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
800ef34: 34 0b 00 00 mvi r11,0
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
800ef38: 45 80 00 16 be r12,r0,800ef90 <_Objects_Get_information+0x7c>
/*
* This call implicitly validates the_api so we do not call
* _Objects_Is_api_valid above here.
*/
the_class_api_maximum = _Objects_API_maximum_class( the_api );
800ef3c: f8 00 08 9a calli 80111a4 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
800ef40: 44 20 00 14 be r1,r0,800ef90 <_Objects_Get_information+0x7c>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
800ef44: 55 81 00 13 bgu r12,r1,800ef90 <_Objects_Get_information+0x7c>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
800ef48: 78 0d 08 01 mvhi r13,0x801
800ef4c: b9 c0 08 00 mv r1,r14
800ef50: 34 02 00 02 mvi r2,2
800ef54: 39 ad 99 2c ori r13,r13,0x992c
800ef58: f8 00 1f ee calli 8016f10 <__ashlsi3>
800ef5c: b5 a1 08 00 add r1,r13,r1
800ef60: 28 2d 00 00 lw r13,(r1+0)
800ef64: 45 a0 00 0b be r13,r0,800ef90 <_Objects_Get_information+0x7c><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
800ef68: b9 80 08 00 mv r1,r12
800ef6c: 34 02 00 02 mvi r2,2
800ef70: f8 00 1f e8 calli 8016f10 <__ashlsi3>
800ef74: b5 a1 08 00 add r1,r13,r1
800ef78: 28 2b 00 00 lw r11,(r1+0)
if ( !info )
800ef7c: 45 60 00 05 be r11,r0,800ef90 <_Objects_Get_information+0x7c><== NEVER TAKEN
* In a multprocessing configuration, we may access remote objects.
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
800ef80: 2d 61 00 10 lhu r1,(r11+16)
return NULL;
800ef84: 7c 21 00 00 cmpnei r1,r1,0
800ef88: c8 01 08 00 sub r1,r0,r1
800ef8c: a1 61 58 00 and r11,r11,r1
#endif
return info;
}
800ef90: b9 60 08 00 mv r1,r11
800ef94: 2b 9d 00 04 lw ra,(sp+4)
800ef98: 2b 8b 00 14 lw r11,(sp+20)
800ef9c: 2b 8c 00 10 lw r12,(sp+16)
800efa0: 2b 8d 00 0c lw r13,(sp+12)
800efa4: 2b 8e 00 08 lw r14,(sp+8)
800efa8: 37 9c 00 14 addi sp,sp,20
800efac: c3 a0 00 00 ret
08017954 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
8017954: 37 9c ff f4 addi sp,sp,-12
8017958: 5b 8b 00 0c sw (sp+12),r11
801795c: 5b 8c 00 08 sw (sp+8),r12
8017960: 5b 9d 00 04 sw (sp+4),ra
8017964: b8 20 20 00 mv r4,r1
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
8017968: 28 21 00 08 lw r1,(r1+8)
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
801796c: b8 60 58 00 mv r11,r3
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
8017970: c8 41 08 00 sub r1,r2,r1
if ( information->maximum >= index ) {
8017974: 2c 82 00 10 lhu r2,(r4+16)
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
8017978: 34 21 00 01 addi r1,r1,1
if ( information->maximum >= index ) {
801797c: 54 22 00 09 bgu r1,r2,80179a0 <_Objects_Get_no_protection+0x4c>
if ( (the_object = information->local_table[ index ]) != NULL ) {
8017980: 28 8c 00 1c lw r12,(r4+28)
8017984: 34 02 00 02 mvi r2,2
8017988: fb ff d9 5b calli 800def4 <__ashlsi3>
801798c: b5 81 08 00 add r1,r12,r1
8017990: 28 21 00 00 lw r1,(r1+0)
8017994: 44 20 00 03 be r1,r0,80179a0 <_Objects_Get_no_protection+0x4c><== NEVER TAKEN
*location = OBJECTS_LOCAL;
8017998: 59 60 00 00 sw (r11+0),r0
return the_object;
801799c: e0 00 00 04 bi 80179ac <_Objects_Get_no_protection+0x58>
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
80179a0: 34 01 00 01 mvi r1,1
80179a4: 59 61 00 00 sw (r11+0),r1
return NULL;
80179a8: 34 01 00 00 mvi r1,0
}
80179ac: 2b 9d 00 04 lw ra,(sp+4)
80179b0: 2b 8b 00 0c lw r11,(sp+12)
80179b4: 2b 8c 00 08 lw r12,(sp+8)
80179b8: 37 9c 00 0c addi sp,sp,12
80179bc: c3 a0 00 00 ret
08006278 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
8006278: 37 9c ff e8 addi sp,sp,-24
800627c: 5b 8b 00 14 sw (sp+20),r11
8006280: 5b 8c 00 10 sw (sp+16),r12
8006284: 5b 8d 00 0c sw (sp+12),r13
8006288: 5b 8e 00 08 sw (sp+8),r14
800628c: 5b 9d 00 04 sw (sp+4),ra
8006290: b8 40 70 00 mv r14,r2
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
8006294: b8 20 58 00 mv r11,r1
8006298: 5c 20 00 05 bne r1,r0,80062ac <_Objects_Id_to_name+0x34>
800629c: 78 01 08 02 mvhi r1,0x802
80062a0: 38 21 0e 0c ori r1,r1,0xe0c
80062a4: 28 21 00 0c lw r1,(r1+12)
80062a8: 28 2b 00 08 lw r11,(r1+8)
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
80062ac: 34 02 00 18 mvi r2,24
80062b0: b9 60 08 00 mv r1,r11
80062b4: f8 00 58 76 calli 801c48c <__lshrsi3>
80062b8: 20 21 00 07 andi r1,r1,0x7
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
80062bc: 34 23 ff ff addi r3,r1,-1
80062c0: 34 02 00 02 mvi r2,2
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
80062c4: 34 0d 00 03 mvi r13,3
80062c8: 54 62 00 14 bgu r3,r2,8006318 <_Objects_Id_to_name+0xa0>
80062cc: e0 00 00 1b bi 8006338 <_Objects_Id_to_name+0xc0>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
80062d0: 34 02 00 1b mvi r2,27
80062d4: b9 60 08 00 mv r1,r11
80062d8: f8 00 58 6d calli 801c48c <__lshrsi3>
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
80062dc: 34 02 00 02 mvi r2,2
80062e0: fb ff ec d7 calli 800163c <__ashlsi3>
80062e4: b5 81 08 00 add r1,r12,r1
80062e8: 28 21 00 00 lw r1,(r1+0)
if ( !information )
80062ec: 44 20 00 0b be r1,r0,8006318 <_Objects_Id_to_name+0xa0> <== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
80062f0: 40 2c 00 38 lbu r12,(r1+56)
80062f4: 5d 80 00 09 bne r12,r0,8006318 <_Objects_Id_to_name+0xa0> <== NEVER TAKEN
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
80062f8: b9 60 10 00 mv r2,r11
80062fc: 37 83 00 18 addi r3,sp,24
8006300: fb ff ff b8 calli 80061e0 <_Objects_Get>
if ( !the_object )
8006304: 44 2c 00 05 be r1,r12,8006318 <_Objects_Id_to_name+0xa0>
return OBJECTS_INVALID_ID;
*name = the_object->name;
8006308: 28 21 00 0c lw r1,(r1+12)
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
800630c: 34 0d 00 00 mvi r13,0
the_object = _Objects_Get( information, tmpId, &ignored_location );
if ( !the_object )
return OBJECTS_INVALID_ID;
*name = the_object->name;
8006310: 59 c1 00 00 sw (r14+0),r1
_Thread_Enable_dispatch();
8006314: f8 00 03 dc calli 8007284 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
8006318: b9 a0 08 00 mv r1,r13
800631c: 2b 9d 00 04 lw ra,(sp+4)
8006320: 2b 8b 00 14 lw r11,(sp+20)
8006324: 2b 8c 00 10 lw r12,(sp+16)
8006328: 2b 8d 00 0c lw r13,(sp+12)
800632c: 2b 8e 00 08 lw r14,(sp+8)
8006330: 37 9c 00 18 addi sp,sp,24
8006334: c3 a0 00 00 ret
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
8006338: 78 0c 08 02 mvhi r12,0x802
800633c: 34 02 00 02 mvi r2,2
8006340: 39 8c 08 fc ori r12,r12,0x8fc
8006344: fb ff ec be calli 800163c <__ashlsi3>
8006348: b5 81 08 00 add r1,r12,r1
800634c: 28 2c 00 00 lw r12,(r1+0)
8006350: 5d 80 ff e0 bne r12,r0,80062d0 <_Objects_Id_to_name+0x58>
8006354: e3 ff ff f1 bi 8006318 <_Objects_Id_to_name+0xa0>
08005ca4 <_Objects_Initialize_information>:
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
8005ca4: 37 9c ff e4 addi sp,sp,-28
8005ca8: 5b 8b 00 1c sw (sp+28),r11
8005cac: 5b 8c 00 18 sw (sp+24),r12
8005cb0: 5b 8d 00 14 sw (sp+20),r13
8005cb4: 5b 8e 00 10 sw (sp+16),r14
8005cb8: 5b 8f 00 0c sw (sp+12),r15
8005cbc: 5b 90 00 08 sw (sp+8),r16
8005cc0: 5b 9d 00 04 sw (sp+4),ra
8005cc4: 20 6d ff ff andi r13,r3,0xffff
8005cc8: b8 20 58 00 mv r11,r1
8005ccc: 20 a5 ff ff andi r5,r5,0xffff
uint32_t index;
#endif
information->the_api = the_api;
information->the_class = the_class;
information->size = size;
8005cd0: 58 25 00 18 sw (r1+24),r5
information->local_table = 0;
information->inactive_per_block = 0;
information->object_blocks = 0;
information->inactive = 0;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
information->is_string = is_string;
8005cd4: 30 26 00 38 sb (r1+56),r6
uint32_t maximum_per_allocation;
#if defined(RTEMS_MULTIPROCESSING)
uint32_t index;
#endif
information->the_api = the_api;
8005cd8: 59 62 00 00 sw (r11+0),r2
information->the_class = the_class;
8005cdc: 0c 2d 00 04 sh (r1+4),r13
information->size = size;
information->local_table = 0;
8005ce0: 58 20 00 1c sw (r1+28),r0
information->inactive_per_block = 0;
8005ce4: 58 20 00 30 sw (r1+48),r0
information->object_blocks = 0;
8005ce8: 58 20 00 34 sw (r1+52),r0
information->inactive = 0;
8005cec: 0c 20 00 2c sh (r1+44),r0
/*
* Set the maximum value to 0. It will be updated when objects are
* added to the inactive set from _Objects_Extend_information()
*/
information->maximum = 0;
8005cf0: 0c 20 00 10 sh (r1+16),r0
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
8005cf4: b8 40 70 00 mv r14,r2
information->maximum = 0;
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
8005cf8: b8 40 08 00 mv r1,r2
8005cfc: 78 0f 08 01 mvhi r15,0x801
8005d00: 34 02 00 02 mvi r2,2
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
8005d04: b8 80 60 00 mv r12,r4
8005d08: b8 e0 80 00 mv r16,r7
information->maximum = 0;
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
8005d0c: 39 ef 99 2c ori r15,r15,0x992c
8005d10: f8 00 44 80 calli 8016f10 <__ashlsi3>
8005d14: b5 e1 08 00 add r1,r15,r1
8005d18: 28 2f 00 00 lw r15,(r1+0)
8005d1c: 34 02 00 02 mvi r2,2
8005d20: b9 a0 08 00 mv r1,r13
8005d24: f8 00 44 7b calli 8016f10 <__ashlsi3>
8005d28: b5 e1 08 00 add r1,r15,r1
8005d2c: 58 2b 00 00 sw (r1+0),r11
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
8005d30: 34 02 00 1f mvi r2,31
8005d34: b9 80 08 00 mv r1,r12
8005d38: f8 00 44 c4 calli 8017048 <__lshrsi3>
maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;
8005d3c: 78 03 08 01 mvhi r3,0x801
8005d40: 38 63 81 68 ori r3,r3,0x8168
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
8005d44: 20 22 00 ff andi r2,r1,0xff
maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;
8005d48: 28 61 00 00 lw r1,(r3+0)
_Objects_Information_table[ the_api ][ the_class ] = information;
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
8005d4c: 31 62 00 12 sb (r11+18),r2
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;
8005d50: a1 81 60 00 and r12,r12,r1
/*
* Unlimited and maximum of zero is illogical.
*/
if ( information->auto_extend && maximum_per_allocation == 0) {
8005d54: 44 40 00 06 be r2,r0,8005d6c <_Objects_Initialize_information+0xc8>
8005d58: 5d 80 00 05 bne r12,r0,8005d6c <_Objects_Initialize_information+0xc8><== ALWAYS TAKEN
_Internal_error_Occurred(
8005d5c: 34 01 00 00 mvi r1,0 <== NOT EXECUTED
8005d60: 34 02 00 01 mvi r2,1 <== NOT EXECUTED
8005d64: 34 03 00 13 mvi r3,19 <== NOT EXECUTED
8005d68: fb ff fe 14 calli 80055b8 <_Internal_error_Occurred> <== NOT EXECUTED
information->allocation_size = maximum_per_allocation;
/*
* Provide a null local table entry for the case of any empty table.
*/
information->local_table = &null_local_table;
8005d6c: 78 01 08 01 mvhi r1,0x801
8005d70: 38 21 97 54 ori r1,r1,0x9754
8005d74: 59 61 00 1c sw (r11+28),r1
8005d78: 34 02 00 18 mvi r2,24
8005d7c: b9 c0 08 00 mv r1,r14
}
/*
* The allocation unit is the maximum value
*/
information->allocation_size = maximum_per_allocation;
8005d80: 0d 6c 00 14 sh (r11+20),r12
8005d84: f8 00 44 63 calli 8016f10 <__ashlsi3>
8005d88: 78 0e 00 01 mvhi r14,0x1
8005d8c: b8 2e 70 00 or r14,r1,r14
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
8005d90: 34 02 00 1b mvi r2,27
8005d94: b9 a0 08 00 mv r1,r13
8005d98: f8 00 44 5e calli 8016f10 <__ashlsi3>
information->local_table = &null_local_table;
/*
* Calculate minimum and maximum Id's
*/
minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
8005d9c: 7d 82 00 00 cmpnei r2,r12,0
8005da0: b9 c1 08 00 or r1,r14,r1
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
8005da4: b8 22 08 00 or r1,r1,r2
information->minimum_id =
8005da8: 59 61 00 08 sw (r11+8),r1
* lengths that may be an odd number of bytes.
*/
name_length = maximum_name_length;
#if defined(RTEMS_POSIX_API)
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
8005dac: 22 01 00 03 andi r1,r16,0x3
8005db0: ba 00 38 00 mv r7,r16
8005db4: 44 20 00 04 be r1,r0,8005dc4 <_Objects_Initialize_information+0x120>
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
8005db8: 36 07 00 04 addi r7,r16,4
8005dbc: 34 01 ff fc mvi r1,-4
8005dc0: a0 e1 38 00 and r7,r7,r1
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 );
8005dc4: 35 61 00 24 addi r1,r11,36
head->next = tail;
8005dc8: 59 61 00 20 sw (r11+32),r1
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
8005dcc: 35 61 00 20 addi r1,r11,32
~(OBJECTS_NAME_ALIGNMENT-1);
#endif
information->name_length = name_length;
8005dd0: 0d 67 00 3a sh (r11+58),r7
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
8005dd4: 59 60 00 24 sw (r11+36),r0
tail->previous = head;
8005dd8: 59 61 00 28 sw (r11+40),r1
_Chain_Initialize_empty( &information->Inactive );
/*
* Initialize objects .. if there are any
*/
if ( maximum_per_allocation ) {
8005ddc: 45 80 00 03 be r12,r0,8005de8 <_Objects_Initialize_information+0x144>
/*
* Always have the maximum size available so the current performance
* figures are create are met. If the user moves past the maximum
* number then a performance hit is taken.
*/
_Objects_Extend_information( information );
8005de0: b9 60 08 00 mv r1,r11
8005de4: fb ff fe 6b calli 8005790 <_Objects_Extend_information>
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
8005de8: 2b 9d 00 04 lw ra,(sp+4)
8005dec: 2b 8b 00 1c lw r11,(sp+28)
8005df0: 2b 8c 00 18 lw r12,(sp+24)
8005df4: 2b 8d 00 14 lw r13,(sp+20)
8005df8: 2b 8e 00 10 lw r14,(sp+16)
8005dfc: 2b 8f 00 0c lw r15,(sp+12)
8005e00: 2b 90 00 08 lw r16,(sp+8)
8005e04: 37 9c 00 1c addi sp,sp,28
8005e08: c3 a0 00 00 ret
08003f80 <_POSIX_Condition_variables_Wait_support>:
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
8003f80: 37 9c ff e0 addi sp,sp,-32
8003f84: 5b 8b 00 1c sw (sp+28),r11
8003f88: 5b 8c 00 18 sw (sp+24),r12
8003f8c: 5b 8d 00 14 sw (sp+20),r13
8003f90: 5b 8e 00 10 sw (sp+16),r14
8003f94: 5b 8f 00 0c sw (sp+12),r15
8003f98: 5b 90 00 08 sw (sp+8),r16
8003f9c: 5b 9d 00 04 sw (sp+4),ra
8003fa0: b8 20 70 00 mv r14,r1
8003fa4: b8 40 60 00 mv r12,r2
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
8003fa8: b8 40 08 00 mv r1,r2
8003fac: 37 82 00 20 addi r2,sp,32
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
8003fb0: b8 60 78 00 mv r15,r3
8003fb4: 20 90 00 ff andi r16,r4,0xff
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
8003fb8: f8 00 00 62 calli 8004140 <_POSIX_Mutex_Get>
return EINVAL;
8003fbc: 34 0b 00 16 mvi r11,22
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
8003fc0: 44 20 00 33 be r1,r0,800408c <_POSIX_Condition_variables_Wait_support+0x10c><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
8003fc4: 78 05 08 01 mvhi r5,0x801
8003fc8: 38 a5 78 d8 ori r5,r5,0x78d8
8003fcc: 28 a1 00 00 lw r1,(r5+0)
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
8003fd0: 37 82 00 20 addi r2,sp,32
8003fd4: 34 21 ff ff addi r1,r1,-1
8003fd8: 58 a1 00 00 sw (r5+0),r1
8003fdc: b9 c0 08 00 mv r1,r14
8003fe0: fb ff ff 4d calli 8003d14 <_POSIX_Condition_variables_Get>
switch ( location ) {
8003fe4: 2b 85 00 20 lw r5,(sp+32)
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
8003fe8: b8 20 68 00 mv r13,r1
switch ( location ) {
8003fec: 5c a0 00 28 bne r5,r0,800408c <_POSIX_Condition_variables_Wait_support+0x10c><== NEVER TAKEN
case OBJECTS_LOCAL:
if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {
8003ff0: 28 21 00 14 lw r1,(r1+20)
8003ff4: 44 25 00 05 be r1,r5,8004008 <_POSIX_Condition_variables_Wait_support+0x88>
8003ff8: 29 82 00 00 lw r2,(r12+0)
8003ffc: 44 22 00 03 be r1,r2,8004008 <_POSIX_Condition_variables_Wait_support+0x88>
_Thread_Enable_dispatch();
8004000: f8 00 0e 61 calli 8007984 <_Thread_Enable_dispatch>
return EINVAL;
8004004: e0 00 00 22 bi 800408c <_POSIX_Condition_variables_Wait_support+0x10c>
}
(void) pthread_mutex_unlock( mutex );
8004008: b9 80 08 00 mv r1,r12
800400c: f8 00 01 17 calli 8004468 <pthread_mutex_unlock>
_Thread_Enable_dispatch();
return EINVAL;
}
*/
if ( !already_timedout ) {
8004010: 5e 00 00 19 bne r16,r0,8004074 <_POSIX_Condition_variables_Wait_support+0xf4>
the_cond->Mutex = *mutex;
8004014: 29 81 00 00 lw r1,(r12+0)
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
8004018: 78 0b 08 01 mvhi r11,0x801
800401c: 39 6b 7d 84 ori r11,r11,0x7d84
8004020: 29 64 00 0c lw r4,(r11+12)
return EINVAL;
}
*/
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
8004024: 59 a1 00 14 sw (r13+20),r1
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
8004028: 34 01 00 01 mvi r1,1
800402c: 59 a1 00 48 sw (r13+72),r1
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
8004030: 58 80 00 34 sw (r4+52),r0
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
_Thread_Executing->Wait.id = *cond;
8004034: 29 c1 00 00 lw r1,(r14+0)
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
8004038: 35 ad 00 18 addi r13,r13,24
_Thread_Executing->Wait.id = *cond;
_Thread_queue_Enqueue( &the_cond->Wait_queue, timeout );
800403c: 78 03 08 00 mvhi r3,0x800
the_cond->Mutex = *mutex;
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
_Thread_Executing->Wait.id = *cond;
8004040: 58 81 00 20 sw (r4+32),r1
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
8004044: 58 8d 00 44 sw (r4+68),r13
_Thread_Executing->Wait.id = *cond;
_Thread_queue_Enqueue( &the_cond->Wait_queue, timeout );
8004048: b9 a0 08 00 mv r1,r13
800404c: b9 e0 10 00 mv r2,r15
8004050: 38 63 83 d8 ori r3,r3,0x83d8
8004054: f8 00 0f 76 calli 8007e2c <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
8004058: f8 00 0e 4b calli 8007984 <_Thread_Enable_dispatch>
* a POSIX signal, then pthread_cond_wait returns spuriously,
* according to the POSIX standard. It means that pthread_cond_wait
* returns a success status, except for the fact that it was not
* woken up a pthread_cond_signal or a pthread_cond_broadcast.
*/
status = _Thread_Executing->Wait.return_code;
800405c: 29 61 00 0c lw r1,(r11+12)
8004060: 28 2b 00 34 lw r11,(r1+52)
if ( status == EINTR )
status = 0;
8004064: 7d 61 00 04 cmpnei r1,r11,4
8004068: c8 01 08 00 sub r1,r0,r1
800406c: a1 61 58 00 and r11,r11,r1
8004070: e0 00 00 03 bi 800407c <_POSIX_Condition_variables_Wait_support+0xfc>
} else {
_Thread_Enable_dispatch();
8004074: f8 00 0e 44 calli 8007984 <_Thread_Enable_dispatch>
status = ETIMEDOUT;
8004078: 34 0b 00 74 mvi r11,116
/*
* When we get here the dispatch disable level is 0.
*/
mutex_status = pthread_mutex_lock( mutex );
800407c: b9 80 08 00 mv r1,r12
8004080: f8 00 00 c7 calli 800439c <pthread_mutex_lock>
if ( mutex_status )
8004084: 44 20 00 02 be r1,r0,800408c <_POSIX_Condition_variables_Wait_support+0x10c>
return EINVAL;
8004088: 34 0b 00 16 mvi r11,22
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
800408c: b9 60 08 00 mv r1,r11
8004090: 2b 9d 00 04 lw ra,(sp+4)
8004094: 2b 8b 00 1c lw r11,(sp+28)
8004098: 2b 8c 00 18 lw r12,(sp+24)
800409c: 2b 8d 00 14 lw r13,(sp+20)
80040a0: 2b 8e 00 10 lw r14,(sp+16)
80040a4: 2b 8f 00 0c lw r15,(sp+12)
80040a8: 2b 90 00 08 lw r16,(sp+8)
80040ac: 37 9c 00 20 addi sp,sp,32
80040b0: c3 a0 00 00 ret
08008da8 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
8008da8: 37 9c ff dc addi sp,sp,-36
8008dac: 5b 8b 00 18 sw (sp+24),r11
8008db0: 5b 8c 00 14 sw (sp+20),r12
8008db4: 5b 8d 00 10 sw (sp+16),r13
8008db8: 5b 8e 00 0c sw (sp+12),r14
8008dbc: 5b 8f 00 08 sw (sp+8),r15
8008dc0: 5b 9d 00 04 sw (sp+4),ra
8008dc4: b8 20 58 00 mv r11,r1
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
8008dc8: 78 01 08 02 mvhi r1,0x802
8008dcc: b8 40 60 00 mv r12,r2
8008dd0: b8 60 78 00 mv r15,r3
8008dd4: b9 60 10 00 mv r2,r11
8008dd8: 38 21 a2 58 ori r1,r1,0xa258
8008ddc: 37 83 00 24 addi r3,sp,36
8008de0: 5b 86 00 1c sw (sp+28),r6
8008de4: b8 80 68 00 mv r13,r4
8008de8: 20 ae 00 ff andi r14,r5,0xff
8008dec: f8 00 0c c0 calli 800c0ec <_Objects_Get>
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
8008df0: 2b 82 00 24 lw r2,(sp+36)
8008df4: 2b 86 00 1c lw r6,(sp+28)
8008df8: 5c 40 00 2f bne r2,r0,8008eb4 <_POSIX_Message_queue_Receive_support+0x10c>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
8008dfc: 28 28 00 14 lw r8,(r1+20)
8008e00: 34 02 00 01 mvi r2,1
8008e04: 21 03 00 03 andi r3,r8,0x3
8008e08: 5c 62 00 03 bne r3,r2,8008e14 <_POSIX_Message_queue_Receive_support+0x6c>
_Thread_Enable_dispatch();
8008e0c: f8 00 10 b1 calli 800d0d0 <_Thread_Enable_dispatch>
8008e10: e0 00 00 29 bi 8008eb4 <_POSIX_Message_queue_Receive_support+0x10c>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
8008e14: 28 27 00 10 lw r7,(r1+16)
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
8008e18: 28 e1 00 68 lw r1,(r7+104)
8008e1c: 51 e1 00 05 bgeu r15,r1,8008e30 <_POSIX_Message_queue_Receive_support+0x88>
_Thread_Enable_dispatch();
8008e20: f8 00 10 ac calli 800d0d0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
8008e24: f8 00 2e cb calli 8014950 <__errno>
8008e28: 34 02 00 7a mvi r2,122
8008e2c: e0 00 00 24 bi 8008ebc <_POSIX_Message_queue_Receive_support+0x114>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
8008e30: 34 01 ff ff mvi r1,-1
8008e34: 5b 81 00 20 sw (sp+32),r1
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
8008e38: 34 05 00 00 mvi r5,0
8008e3c: 45 c0 00 03 be r14,r0,8008e48 <_POSIX_Message_queue_Receive_support+0xa0><== NEVER TAKEN
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
8008e40: 21 05 40 00 andi r5,r8,0x4000
8008e44: 64 a5 00 00 cmpei r5,r5,0
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
8008e48: b9 60 10 00 mv r2,r11
timeout
);
_Thread_Enable_dispatch();
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
8008e4c: 78 0b 08 02 mvhi r11,0x802
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
8008e50: 34 e1 00 1c addi r1,r7,28
8008e54: b9 80 18 00 mv r3,r12
8008e58: 37 84 00 20 addi r4,sp,32
timeout
);
_Thread_Enable_dispatch();
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
8008e5c: 39 6b a2 c4 ori r11,r11,0xa2c4
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
8008e60: f8 00 07 86 calli 800ac78 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
8008e64: f8 00 10 9b calli 800d0d0 <_Thread_Enable_dispatch>
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
8008e68: 29 6c 00 0c lw r12,(r11+12)
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
CORE_message_queue_Submit_types priority
)
{
/* absolute value without a library dependency */
return ((priority >= 0) ? priority : -priority);
8008e6c: 34 02 00 1f mvi r2,31
8008e70: 29 81 00 24 lw r1,(r12+36)
8008e74: f8 00 6e 14 calli 80246c4 <__ashrsi3>
8008e78: 29 82 00 24 lw r2,(r12+36)
8008e7c: 98 22 10 00 xor r2,r1,r2
8008e80: c8 41 08 00 sub r1,r2,r1
do_wait,
timeout
);
_Thread_Enable_dispatch();
*msg_prio =
8008e84: 59 a1 00 00 sw (r13+0),r1
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
if ( !_Thread_Executing->Wait.return_code )
8008e88: 29 81 00 34 lw r1,(r12+52)
8008e8c: 5c 20 00 03 bne r1,r0,8008e98 <_POSIX_Message_queue_Receive_support+0xf0>
return length_out;
8008e90: 2b 81 00 20 lw r1,(sp+32)
8008e94: e0 00 00 0c bi 8008ec4 <_POSIX_Message_queue_Receive_support+0x11c>
rtems_set_errno_and_return_minus_one(
8008e98: f8 00 2e ae calli 8014950 <__errno>
8008e9c: b8 20 60 00 mv r12,r1
8008ea0: 29 61 00 0c lw r1,(r11+12)
8008ea4: 28 21 00 34 lw r1,(r1+52)
8008ea8: f8 00 00 b9 calli 800918c <_POSIX_Message_queue_Translate_core_message_queue_return_code>
8008eac: 59 81 00 00 sw (r12+0),r1
8008eb0: e0 00 00 04 bi 8008ec0 <_POSIX_Message_queue_Receive_support+0x118>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
8008eb4: f8 00 2e a7 calli 8014950 <__errno>
8008eb8: 34 02 00 09 mvi r2,9
8008ebc: 58 22 00 00 sw (r1+0),r2
8008ec0: 34 01 ff ff mvi r1,-1
}
8008ec4: 2b 9d 00 04 lw ra,(sp+4)
8008ec8: 2b 8b 00 18 lw r11,(sp+24)
8008ecc: 2b 8c 00 14 lw r12,(sp+20)
8008ed0: 2b 8d 00 10 lw r13,(sp+16)
8008ed4: 2b 8e 00 0c lw r14,(sp+12)
8008ed8: 2b 8f 00 08 lw r15,(sp+8)
8008edc: 37 9c 00 24 addi sp,sp,36
8008ee0: c3 a0 00 00 ret
08008870 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
8008870: 37 9c ff fc addi sp,sp,-4
8008874: 5b 9d 00 04 sw (sp+4),ra
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
8008878: 28 22 01 20 lw r2,(r1+288)
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
800887c: 28 43 00 d8 lw r3,(r2+216)
8008880: 5c 60 00 0e bne r3,r0,80088b8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x48><== NEVER TAKEN
8008884: 28 44 00 dc lw r4,(r2+220)
8008888: 34 03 00 01 mvi r3,1
800888c: 5c 83 00 0b bne r4,r3,80088b8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x48>
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
8008890: 28 42 00 e0 lw r2,(r2+224)
8008894: 44 40 00 09 be r2,r0,80088b8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x48>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
8008898: 78 02 08 01 mvhi r2,0x801
800889c: 38 42 58 c8 ori r2,r2,0x58c8
80088a0: 28 43 00 00 lw r3,(r2+0)
80088a4: 34 63 ff ff addi r3,r3,-1
80088a8: 58 43 00 00 sw (r2+0),r3
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
80088ac: 34 02 ff ff mvi r2,-1
80088b0: f8 00 02 62 calli 8009238 <_POSIX_Thread_Exit>
80088b4: e0 00 00 02 bi 80088bc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x4c>
} else
_Thread_Enable_dispatch();
80088b8: fb ff f3 5a calli 8005620 <_Thread_Enable_dispatch>
}
80088bc: 2b 9d 00 04 lw ra,(sp+4)
80088c0: 37 9c 00 04 addi sp,sp,4
80088c4: c3 a0 00 00 ret
0800a1e4 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
800a1e4: 37 9c ff e8 addi sp,sp,-24
800a1e8: 5b 8b 00 18 sw (sp+24),r11
800a1ec: 5b 8c 00 14 sw (sp+20),r12
800a1f0: 5b 8d 00 10 sw (sp+16),r13
800a1f4: 5b 8e 00 0c sw (sp+12),r14
800a1f8: 5b 8f 00 08 sw (sp+8),r15
800a1fc: 5b 9d 00 04 sw (sp+4),ra
800a200: b8 20 68 00 mv r13,r1
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
800a204: 28 41 00 00 lw r1,(r2+0)
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
800a208: b8 40 58 00 mv r11,r2
800a20c: b8 60 70 00 mv r14,r3
800a210: b8 80 78 00 mv r15,r4
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
800a214: fb ff ff ec calli 800a1c4 <_POSIX_Priority_Is_valid>
return EINVAL;
800a218: 34 0c 00 16 mvi r12,22
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
800a21c: 44 20 00 2a be r1,r0,800a2c4 <_POSIX_Thread_Translate_sched_param+0xe0><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
800a220: 59 c0 00 00 sw (r14+0),r0
*budget_callout = NULL;
800a224: 59 e0 00 00 sw (r15+0),r0
if ( policy == SCHED_OTHER ) {
800a228: 5d a0 00 04 bne r13,r0,800a238 <_POSIX_Thread_Translate_sched_param+0x54>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
800a22c: 34 01 00 01 mvi r1,1
800a230: 59 c1 00 00 sw (r14+0),r1
800a234: e0 00 00 23 bi 800a2c0 <_POSIX_Thread_Translate_sched_param+0xdc>
return 0;
}
if ( policy == SCHED_FIFO ) {
800a238: 34 01 00 01 mvi r1,1
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
800a23c: 34 0c 00 00 mvi r12,0
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
800a240: 45 a1 00 21 be r13,r1,800a2c4 <_POSIX_Thread_Translate_sched_param+0xe0>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
800a244: 34 01 00 02 mvi r1,2
800a248: 5d a1 00 03 bne r13,r1,800a254 <_POSIX_Thread_Translate_sched_param+0x70>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
800a24c: 59 cd 00 00 sw (r14+0),r13
return 0;
800a250: e0 00 00 1d bi 800a2c4 <_POSIX_Thread_Translate_sched_param+0xe0>
}
if ( policy == SCHED_SPORADIC ) {
800a254: 34 01 00 04 mvi r1,4
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
800a258: 34 0c 00 16 mvi r12,22
if ( policy == SCHED_RR ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
800a25c: 5d a1 00 1a bne r13,r1,800a2c4 <_POSIX_Thread_Translate_sched_param+0xe0>
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
800a260: 29 61 00 08 lw r1,(r11+8)
800a264: 5c 20 00 03 bne r1,r0,800a270 <_POSIX_Thread_Translate_sched_param+0x8c>
800a268: 29 62 00 0c lw r2,(r11+12)
800a26c: 44 41 00 16 be r2,r1,800a2c4 <_POSIX_Thread_Translate_sched_param+0xe0>
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
800a270: 29 61 00 10 lw r1,(r11+16)
800a274: 5c 20 00 04 bne r1,r0,800a284 <_POSIX_Thread_Translate_sched_param+0xa0>
800a278: 29 62 00 14 lw r2,(r11+20)
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
800a27c: 34 0c 00 16 mvi r12,22
if ( policy == SCHED_SPORADIC ) {
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
800a280: 44 41 00 11 be r2,r1,800a2c4 <_POSIX_Thread_Translate_sched_param+0xe0>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
800a284: 35 61 00 08 addi r1,r11,8
800a288: fb ff f4 98 calli 80074e8 <_Timespec_To_ticks>
800a28c: b8 20 68 00 mv r13,r1
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
800a290: 35 61 00 10 addi r1,r11,16
800a294: fb ff f4 95 calli 80074e8 <_Timespec_To_ticks>
return EINVAL;
800a298: 34 0c 00 16 mvi r12,22
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
800a29c: 54 2d 00 0a bgu r1,r13,800a2c4 <_POSIX_Thread_Translate_sched_param+0xe0>
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
800a2a0: 29 61 00 04 lw r1,(r11+4)
800a2a4: fb ff ff c8 calli 800a1c4 <_POSIX_Priority_Is_valid>
800a2a8: 44 20 00 07 be r1,r0,800a2c4 <_POSIX_Thread_Translate_sched_param+0xe0>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
800a2ac: 34 01 00 03 mvi r1,3
800a2b0: 59 c1 00 00 sw (r14+0),r1
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
800a2b4: 78 01 08 00 mvhi r1,0x800
800a2b8: 38 21 38 2c ori r1,r1,0x382c
800a2bc: 59 e1 00 00 sw (r15+0),r1
return 0;
800a2c0: 34 0c 00 00 mvi r12,0
}
return EINVAL;
}
800a2c4: b9 80 08 00 mv r1,r12
800a2c8: 2b 9d 00 04 lw ra,(sp+4)
800a2cc: 2b 8b 00 18 lw r11,(sp+24)
800a2d0: 2b 8c 00 14 lw r12,(sp+20)
800a2d4: 2b 8d 00 10 lw r13,(sp+16)
800a2d8: 2b 8e 00 0c lw r14,(sp+12)
800a2dc: 2b 8f 00 08 lw r15,(sp+8)
800a2e0: 37 9c 00 18 addi sp,sp,24
800a2e4: c3 a0 00 00 ret
080034ac <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
80034ac: 37 9c ff a8 addi sp,sp,-88
80034b0: 5b 8b 00 14 sw (sp+20),r11
80034b4: 5b 8c 00 10 sw (sp+16),r12
80034b8: 5b 8d 00 0c sw (sp+12),r13
80034bc: 5b 8e 00 08 sw (sp+8),r14
80034c0: 5b 9d 00 04 sw (sp+4),ra
uint32_t maximum;
posix_initialization_threads_table *user_threads;
pthread_t thread_id;
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
80034c4: 78 01 08 01 mvhi r1,0x801
80034c8: 38 21 f0 d8 ori r1,r1,0xf0d8
maximum = Configuration_POSIX_API.number_of_initialization_threads;
80034cc: 28 2e 00 30 lw r14,(r1+48)
uint32_t maximum;
posix_initialization_threads_table *user_threads;
pthread_t thread_id;
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
80034d0: 28 2c 00 34 lw r12,(r1+52)
maximum = Configuration_POSIX_API.number_of_initialization_threads;
if ( !user_threads || maximum == 0 )
80034d4: 65 c2 00 00 cmpei r2,r14,0
80034d8: 65 81 00 00 cmpei r1,r12,0
80034dc: b8 41 08 00 or r1,r2,r1
80034e0: 5c 20 00 18 bne r1,r0,8003540 <_POSIX_Threads_Initialize_user_threads_body+0x94><== NEVER TAKEN
80034e4: 34 0d 00 00 mvi r13,0
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
80034e8: 37 8b 00 18 addi r11,sp,24
80034ec: b9 60 08 00 mv r1,r11
80034f0: f8 00 1b 7e calli 800a2e8 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
80034f4: 34 02 00 02 mvi r2,2
80034f8: b9 60 08 00 mv r1,r11
80034fc: f8 00 1b 88 calli 800a31c <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
8003500: 29 82 00 04 lw r2,(r12+4)
8003504: b9 60 08 00 mv r1,r11
8003508: f8 00 1b 91 calli 800a34c <pthread_attr_setstacksize>
status = pthread_create(
800350c: 29 83 00 00 lw r3,(r12+0)
8003510: 37 81 00 58 addi r1,sp,88
8003514: b9 60 10 00 mv r2,r11
8003518: 34 04 00 00 mvi r4,0
800351c: fb ff fe ed calli 80030d0 <pthread_create>
8003520: b8 20 18 00 mv r3,r1
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
8003524: 44 20 00 04 be r1,r0,8003534 <_POSIX_Threads_Initialize_user_threads_body+0x88><== ALWAYS TAKEN
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
8003528: 34 01 00 02 mvi r1,2 <== NOT EXECUTED
800352c: 34 02 00 01 mvi r2,1 <== NOT EXECUTED
8003530: f8 00 07 19 calli 8005194 <_Internal_error_Occurred> <== NOT EXECUTED
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
8003534: 35 ad 00 01 addi r13,r13,1
8003538: 35 8c 00 08 addi r12,r12,8
800353c: 55 cd ff ec bgu r14,r13,80034ec <_POSIX_Threads_Initialize_user_threads_body+0x40><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
8003540: 2b 9d 00 04 lw ra,(sp+4)
8003544: 2b 8b 00 14 lw r11,(sp+20)
8003548: 2b 8c 00 10 lw r12,(sp+16)
800354c: 2b 8d 00 0c lw r13,(sp+12)
8003550: 2b 8e 00 08 lw r14,(sp+8)
8003554: 37 9c 00 58 addi sp,sp,88
8003558: c3 a0 00 00 ret
0800d670 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
800d670: 37 9c ff f4 addi sp,sp,-12
800d674: 5b 8b 00 0c sw (sp+12),r11
800d678: 5b 8c 00 08 sw (sp+8),r12
800d67c: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *the_thread;
POSIX_API_Control *api;
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
800d680: 28 4c 01 20 lw r12,(r2+288)
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
800d684: b8 40 58 00 mv r11,r2
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
800d688: 35 81 00 98 addi r1,r12,152
800d68c: f8 00 07 73 calli 800f458 <_Timespec_To_ticks>
the_thread->cpu_time_budget = ticks;
800d690: 59 61 00 78 sw (r11+120),r1
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
800d694: 78 01 08 01 mvhi r1,0x801
800d698: 38 21 90 d8 ori r1,r1,0x90d8
800d69c: 40 21 00 00 lbu r1,(r1+0)
800d6a0: 29 82 00 88 lw r2,(r12+136)
800d6a4: c8 22 10 00 sub r2,r1,r2
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
800d6a8: 29 61 00 1c lw r1,(r11+28)
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
the_thread->cpu_time_budget = ticks;
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
800d6ac: 59 62 00 18 sw (r11+24),r2
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
800d6b0: 5c 20 00 06 bne r1,r0,800d6c8 <_POSIX_Threads_Sporadic_budget_TSR+0x58><== NEVER TAKEN
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
800d6b4: 29 61 00 14 lw r1,(r11+20)
800d6b8: 50 41 00 04 bgeu r2,r1,800d6c8 <_POSIX_Threads_Sporadic_budget_TSR+0x58>
_Thread_Change_priority( the_thread, new_priority, true );
800d6bc: b9 60 08 00 mv r1,r11
800d6c0: 34 03 00 01 mvi r3,1
800d6c4: fb ff e4 35 calli 8006798 <_Thread_Change_priority>
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
800d6c8: 35 81 00 90 addi r1,r12,144
800d6cc: f8 00 07 63 calli 800f458 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
800d6d0: 59 81 00 b4 sw (r12+180),r1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
800d6d4: 78 01 08 01 mvhi r1,0x801
800d6d8: 38 21 9a 50 ori r1,r1,0x9a50
800d6dc: 35 82 00 a8 addi r2,r12,168
800d6e0: fb ff e9 52 calli 8007c28 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
}
800d6e4: 2b 9d 00 04 lw ra,(sp+4)
800d6e8: 2b 8b 00 0c lw r11,(sp+12)
800d6ec: 2b 8c 00 08 lw r12,(sp+8)
800d6f0: 37 9c 00 0c addi sp,sp,12
800d6f4: c3 a0 00 00 ret
0800d6f8 <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
800d6f8: 37 9c ff fc addi sp,sp,-4
800d6fc: 5b 9d 00 04 sw (sp+4),ra
/*
* This will prevent the thread from consuming its entire "budget"
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
800d700: 34 02 ff ff mvi r2,-1
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
800d704: 28 25 01 20 lw r5,(r1+288)
/*
* This will prevent the thread from consuming its entire "budget"
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
800d708: 58 22 00 78 sw (r1+120),r2
800d70c: 78 02 08 01 mvhi r2,0x801
800d710: 38 42 90 d8 ori r2,r2,0x90d8
800d714: 40 44 00 00 lbu r4,(r2+0)
800d718: 28 a2 00 8c lw r2,(r5+140)
800d71c: c8 82 10 00 sub r2,r4,r2
*/
#if 0
printk( "callout %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
800d720: 28 24 00 1c lw r4,(r1+28)
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
800d724: 58 22 00 18 sw (r1+24),r2
*/
#if 0
printk( "callout %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
800d728: 5c 80 00 05 bne r4,r0,800d73c <_POSIX_Threads_Sporadic_budget_callout+0x44><== NEVER TAKEN
/*
* Make sure we are actually lowering it. If they have lowered it
* to logically lower than sched_ss_low_priority, then we do not want to
* change it.
*/
if ( the_thread->current_priority < new_priority ) {
800d72c: 28 23 00 14 lw r3,(r1+20)
800d730: 50 62 00 03 bgeu r3,r2,800d73c <_POSIX_Threads_Sporadic_budget_callout+0x44><== NEVER TAKEN
_Thread_Change_priority( the_thread, new_priority, true );
800d734: 34 03 00 01 mvi r3,1
800d738: fb ff e4 18 calli 8006798 <_Thread_Change_priority>
#if 0
printk( "lower priority\n" );
#endif
}
}
}
800d73c: 2b 9d 00 04 lw ra,(sp+4)
800d740: 37 9c 00 04 addi sp,sp,4
800d744: c3 a0 00 00 ret
080031ac <_POSIX_Timer_TSR>:
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
80031ac: 37 9c ff f8 addi sp,sp,-8
80031b0: 5b 8b 00 08 sw (sp+8),r11
80031b4: 5b 9d 00 04 sw (sp+4),ra
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
80031b8: 28 41 00 68 lw r1,(r2+104)
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
80031bc: b8 40 58 00 mv r11,r2
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
80031c0: 34 21 00 01 addi r1,r1,1
80031c4: 58 41 00 68 sw (r2+104),r1
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
80031c8: 28 41 00 54 lw r1,(r2+84)
80031cc: 5c 20 00 03 bne r1,r0,80031d8 <_POSIX_Timer_TSR+0x2c>
80031d0: 28 42 00 58 lw r2,(r2+88)
80031d4: 44 41 00 0d be r2,r1,8003208 <_POSIX_Timer_TSR+0x5c> <== NEVER TAKEN
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
80031d8: 29 62 00 64 lw r2,(r11+100)
80031dc: 29 63 00 08 lw r3,(r11+8)
80031e0: 78 04 08 00 mvhi r4,0x800
80031e4: 35 61 00 10 addi r1,r11,16
80031e8: 38 84 31 ac ori r4,r4,0x31ac
80031ec: b9 60 28 00 mv r5,r11
80031f0: f8 00 1a c3 calli 8009cfc <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
80031f4: 44 20 00 0b be r1,r0,8003220 <_POSIX_Timer_TSR+0x74> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
80031f8: 35 61 00 6c addi r1,r11,108
80031fc: f8 00 04 7d calli 80043f0 <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
8003200: 34 01 00 03 mvi r1,3
8003204: e0 00 00 02 bi 800320c <_POSIX_Timer_TSR+0x60>
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
8003208: 34 01 00 04 mvi r1,4 <== NOT EXECUTED
800320c: 31 61 00 3c sb (r11+60),r1
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
8003210: 29 62 00 44 lw r2,(r11+68)
8003214: 29 61 00 38 lw r1,(r11+56)
8003218: f8 00 19 6d calli 80097cc <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
800321c: 59 60 00 68 sw (r11+104),r0
}
8003220: 2b 9d 00 04 lw ra,(sp+4)
8003224: 2b 8b 00 08 lw r11,(sp+8)
8003228: 37 9c 00 08 addi sp,sp,8
800322c: c3 a0 00 00 ret
08010b34 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
8010b34: 37 9c ff b0 addi sp,sp,-80
8010b38: 5b 8b 00 1c sw (sp+28),r11
8010b3c: 5b 8c 00 18 sw (sp+24),r12
8010b40: 5b 8d 00 14 sw (sp+20),r13
8010b44: 5b 8e 00 10 sw (sp+16),r14
8010b48: 5b 8f 00 0c sw (sp+12),r15
8010b4c: 5b 90 00 08 sw (sp+8),r16
8010b50: 5b 9d 00 04 sw (sp+4),ra
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
8010b54: 37 90 00 48 addi r16,sp,72
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
8010b58: 20 64 00 ff andi r4,r3,0xff
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
8010b5c: 34 05 00 01 mvi r5,1
8010b60: ba 00 18 00 mv r3,r16
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
8010b64: b8 20 68 00 mv r13,r1
8010b68: b8 40 58 00 mv r11,r2
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
8010b6c: f8 00 00 37 calli 8010c48 <_POSIX_signals_Clear_signals>
is_global, true ) )
return false;
8010b70: 34 0f 00 00 mvi r15,0
{
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
8010b74: 44 20 00 2b be r1,r0,8010c20 <_POSIX_signals_Check_signal+0xec>
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
8010b78: 34 02 00 01 mvi r2,1
8010b7c: b9 60 08 00 mv r1,r11
8010b80: f8 00 18 e4 calli 8016f10 <__ashlsi3>
8010b84: 78 0c 08 01 mvhi r12,0x801
8010b88: b4 2b 08 00 add r1,r1,r11
8010b8c: 34 02 00 02 mvi r2,2
8010b90: f8 00 18 e0 calli 8016f10 <__ashlsi3>
8010b94: 39 8c 9e 88 ori r12,r12,0x9e88
8010b98: b5 81 60 00 add r12,r12,r1
8010b9c: 29 8e 00 08 lw r14,(r12+8)
8010ba0: 34 01 00 01 mvi r1,1
8010ba4: 45 c1 00 1f be r14,r1,8010c20 <_POSIX_signals_Check_signal+0xec><== NEVER TAKEN
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
8010ba8: 29 af 00 d0 lw r15,(r13+208)
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
8010bac: 29 81 00 04 lw r1,(r12+4)
/*
* We have to save the blocking information of the current wait queue
* because the signal handler may subsequently go on and put the thread
* on a wait queue, for its own purposes.
*/
memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
8010bb0: 34 03 00 28 mvi r3,40
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
8010bb4: b8 2f 08 00 or r1,r1,r15
8010bb8: 59 a1 00 d0 sw (r13+208),r1
/*
* We have to save the blocking information of the current wait queue
* because the signal handler may subsequently go on and put the thread
* on a wait queue, for its own purposes.
*/
memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
8010bbc: 78 01 08 01 mvhi r1,0x801
8010bc0: 38 21 9e 3c ori r1,r1,0x9e3c
8010bc4: 28 22 00 0c lw r2,(r1+12)
8010bc8: 37 81 00 20 addi r1,sp,32
8010bcc: 34 42 00 20 addi r2,r2,32
8010bd0: f8 00 04 de calli 8011f48 <memcpy>
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
8010bd4: 29 82 00 00 lw r2,(r12+0)
8010bd8: 34 01 00 02 mvi r1,2
8010bdc: 5c 41 00 06 bne r2,r1,8010bf4 <_POSIX_signals_Check_signal+0xc0>
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
8010be0: b9 60 08 00 mv r1,r11
8010be4: ba 00 10 00 mv r2,r16
8010be8: 34 03 00 00 mvi r3,0
8010bec: d9 c0 00 00 call r14
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
8010bf0: e0 00 00 03 bi 8010bfc <_POSIX_signals_Check_signal+0xc8>
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
8010bf4: b9 60 08 00 mv r1,r11
8010bf8: d9 c0 00 00 call r14
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
8010bfc: 78 01 08 01 mvhi r1,0x801
8010c00: 38 21 9e 3c ori r1,r1,0x9e3c
8010c04: 28 21 00 0c lw r1,(r1+12)
8010c08: 37 82 00 20 addi r2,sp,32
8010c0c: 34 03 00 28 mvi r3,40
8010c10: 34 21 00 20 addi r1,r1,32
8010c14: f8 00 04 cd calli 8011f48 <memcpy>
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
8010c18: 59 af 00 d0 sw (r13+208),r15
return true;
8010c1c: 34 0f 00 01 mvi r15,1
}
8010c20: b9 e0 08 00 mv r1,r15
8010c24: 2b 9d 00 04 lw ra,(sp+4)
8010c28: 2b 8b 00 1c lw r11,(sp+28)
8010c2c: 2b 8c 00 18 lw r12,(sp+24)
8010c30: 2b 8d 00 14 lw r13,(sp+20)
8010c34: 2b 8e 00 10 lw r14,(sp+16)
8010c38: 2b 8f 00 0c lw r15,(sp+12)
8010c3c: 2b 90 00 08 lw r16,(sp+8)
8010c40: 37 9c 00 50 addi sp,sp,80
8010c44: c3 a0 00 00 ret
08011308 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
8011308: 37 9c ff ec addi sp,sp,-20
801130c: 5b 8b 00 14 sw (sp+20),r11
8011310: 5b 8c 00 10 sw (sp+16),r12
8011314: 5b 8d 00 0c sw (sp+12),r13
8011318: 5b 8e 00 08 sw (sp+8),r14
801131c: 5b 9d 00 04 sw (sp+4),ra
8011320: b8 20 60 00 mv r12,r1
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
8011324: 90 00 68 00 rcsr r13,IE
8011328: 34 01 ff fe mvi r1,-2
801132c: a1 a1 08 00 and r1,r13,r1
8011330: d0 01 00 00 wcsr IE,r1
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
8011334: 34 02 00 01 mvi r2,1
8011338: b9 80 08 00 mv r1,r12
801133c: f8 00 16 f5 calli 8016f10 <__ashlsi3>
8011340: b4 2c 70 00 add r14,r1,r12
8011344: 34 02 00 02 mvi r2,2
8011348: 78 0b 08 01 mvhi r11,0x801
801134c: b9 c0 08 00 mv r1,r14
8011350: f8 00 16 f0 calli 8016f10 <__ashlsi3>
8011354: 39 6b 9e 88 ori r11,r11,0x9e88
8011358: b5 61 08 00 add r1,r11,r1
801135c: 28 22 00 00 lw r2,(r1+0)
8011360: 34 01 00 02 mvi r1,2
8011364: 5c 41 00 0a bne r2,r1,801138c <_POSIX_signals_Clear_process_signals+0x84>
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
}
8011368: 34 02 00 02 mvi r2,2
801136c: 78 0b 08 01 mvhi r11,0x801
8011370: b9 c0 08 00 mv r1,r14
8011374: f8 00 16 e7 calli 8016f10 <__ashlsi3>
8011378: 39 6b a0 80 ori r11,r11,0xa080
801137c: b5 61 08 00 add r1,r11,r1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
8011380: 34 22 00 04 addi r2,r1,4
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
8011384: 28 21 00 00 lw r1,(r1+0)
8011388: 5c 22 00 0a bne r1,r2,80113b0 <_POSIX_signals_Clear_process_signals+0xa8><== NEVER TAKEN
801138c: 35 82 ff ff addi r2,r12,-1
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
8011390: 78 0b 08 01 mvhi r11,0x801
8011394: 34 01 00 01 mvi r1,1
8011398: f8 00 16 de calli 8016f10 <__ashlsi3>
801139c: 39 6b a0 7c ori r11,r11,0xa07c
80113a0: 29 62 00 00 lw r2,(r11+0)
80113a4: a4 20 08 00 not r1,r1
80113a8: a0 22 08 00 and r1,r1,r2
80113ac: 59 61 00 00 sw (r11+0),r1
}
_ISR_Enable( level );
80113b0: d0 0d 00 00 wcsr IE,r13
}
80113b4: 2b 9d 00 04 lw ra,(sp+4)
80113b8: 2b 8b 00 14 lw r11,(sp+20)
80113bc: 2b 8c 00 10 lw r12,(sp+16)
80113c0: 2b 8d 00 0c lw r13,(sp+12)
80113c4: 2b 8e 00 08 lw r14,(sp+8)
80113c8: 37 9c 00 14 addi sp,sp,20
80113cc: c3 a0 00 00 ret
08003de8 <_POSIX_signals_Get_lowest>:
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
8003de8: 37 9c ff f0 addi sp,sp,-16
8003dec: 5b 8b 00 10 sw (sp+16),r11
8003df0: 5b 8c 00 0c sw (sp+12),r12
8003df4: 5b 8d 00 08 sw (sp+8),r13
8003df8: 5b 9d 00 04 sw (sp+4),ra
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
8003dfc: 34 0b 00 1b mvi r11,27
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
8003e00: b8 20 60 00 mv r12,r1
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
8003e04: 34 0d 00 20 mvi r13,32
8003e08: 34 01 00 01 mvi r1,1
8003e0c: 35 62 ff ff addi r2,r11,-1
8003e10: f8 00 67 69 calli 801dbb4 <__ashlsi3>
if ( set & signo_to_mask( signo ) ) {
8003e14: a0 2c 08 00 and r1,r1,r12
8003e18: 5c 20 00 0c bne r1,r0,8003e48 <_POSIX_signals_Get_lowest+0x60><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
8003e1c: 35 6b 00 01 addi r11,r11,1
8003e20: 5d 6d ff fa bne r11,r13,8003e08 <_POSIX_signals_Get_lowest+0x20>
8003e24: 34 0b 00 01 mvi r11,1
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
8003e28: 34 0d 00 1b mvi r13,27
8003e2c: 34 01 00 01 mvi r1,1
8003e30: 35 62 ff ff addi r2,r11,-1
8003e34: f8 00 67 60 calli 801dbb4 <__ashlsi3>
if ( set & signo_to_mask( signo ) ) {
8003e38: a0 2c 08 00 and r1,r1,r12
8003e3c: 5c 20 00 03 bne r1,r0,8003e48 <_POSIX_signals_Get_lowest+0x60>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
8003e40: 35 6b 00 01 addi r11,r11,1
8003e44: 5d 6d ff fa bne r11,r13,8003e2c <_POSIX_signals_Get_lowest+0x44><== ALWAYS TAKEN
* a return 0. This routine will NOT be called unless a signal
* is pending in the set passed in.
*/
found_it:
return signo;
}
8003e48: b9 60 08 00 mv r1,r11
8003e4c: 2b 9d 00 04 lw ra,(sp+4)
8003e50: 2b 8b 00 10 lw r11,(sp+16)
8003e54: 2b 8c 00 0c lw r12,(sp+12)
8003e58: 2b 8d 00 08 lw r13,(sp+8)
8003e5c: 37 9c 00 10 addi sp,sp,16
8003e60: c3 a0 00 00 ret
08025f4c <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
8025f4c: 37 9c ff ec addi sp,sp,-20
8025f50: 5b 8b 00 14 sw (sp+20),r11
8025f54: 5b 8c 00 10 sw (sp+16),r12
8025f58: 5b 8d 00 0c sw (sp+12),r13
8025f5c: 5b 8e 00 08 sw (sp+8),r14
8025f60: 5b 9d 00 04 sw (sp+4),ra
8025f64: b8 20 58 00 mv r11,r1
8025f68: b8 40 70 00 mv r14,r2
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
8025f6c: 28 2c 01 20 lw r12,(r1+288)
8025f70: 34 42 ff ff addi r2,r2,-1
8025f74: 34 01 00 01 mvi r1,1
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
8025f78: b8 60 68 00 mv r13,r3
8025f7c: fb ff 6f ca calli 8001ea4 <__ashlsi3>
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
8025f80: 78 03 08 02 mvhi r3,0x802
8025f84: 38 63 77 78 ori r3,r3,0x7778
8025f88: 29 64 00 10 lw r4,(r11+16)
8025f8c: 28 62 00 00 lw r2,(r3+0)
8025f90: a0 82 18 00 and r3,r4,r2
8025f94: 5c 62 00 1c bne r3,r2,8026004 <_POSIX_signals_Unblock_thread+0xb8>
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
8025f98: 29 62 00 30 lw r2,(r11+48)
8025f9c: a0 22 10 00 and r2,r1,r2
8025fa0: 5c 40 00 06 bne r2,r0,8025fb8 <_POSIX_signals_Unblock_thread+0x6c>
8025fa4: 29 82 00 d0 lw r2,(r12+208)
/*
* This should only be reached via pthread_kill().
*/
return false;
8025fa8: 34 0c 00 00 mvi r12,0
* 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) ) {
8025fac: a4 40 10 00 not r2,r2
8025fb0: a0 22 08 00 and r1,r1,r2
8025fb4: 44 2c 00 39 be r1,r12,8026098 <_POSIX_signals_Unblock_thread+0x14c>
the_thread->Wait.return_code = EINTR;
8025fb8: 34 01 00 04 mvi r1,4
8025fbc: 59 61 00 34 sw (r11+52),r1
the_info = (siginfo_t *) the_thread->Wait.return_argument;
8025fc0: 29 61 00 28 lw r1,(r11+40)
if ( !info ) {
8025fc4: 5d a0 00 06 bne r13,r0,8025fdc <_POSIX_signals_Unblock_thread+0x90>
the_info->si_signo = signo;
the_info->si_code = SI_USER;
8025fc8: 34 02 00 01 mvi r2,1
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
8025fcc: 58 2e 00 00 sw (r1+0),r14
the_info->si_code = SI_USER;
8025fd0: 58 22 00 04 sw (r1+4),r2
the_info->si_value.sival_int = 0;
8025fd4: 58 20 00 08 sw (r1+8),r0
8025fd8: e0 00 00 07 bi 8025ff4 <_POSIX_signals_Unblock_thread+0xa8>
} else {
*the_info = *info;
8025fdc: 29 a3 00 00 lw r3,(r13+0)
8025fe0: 29 a2 00 04 lw r2,(r13+4)
8025fe4: 29 a4 00 08 lw r4,(r13+8)
8025fe8: 58 23 00 00 sw (r1+0),r3
8025fec: 58 22 00 04 sw (r1+4),r2
8025ff0: 58 24 00 08 sw (r1+8),r4
}
_Thread_queue_Extract_with_proxy( the_thread );
8025ff4: b9 60 08 00 mv r1,r11
8025ff8: fb ff 9a 9b calli 800ca64 <_Thread_queue_Extract_with_proxy>
return true;
8025ffc: 34 0c 00 01 mvi r12,1
8026000: e0 00 00 26 bi 8026098 <_POSIX_signals_Unblock_thread+0x14c>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
8026004: 29 82 00 d0 lw r2,(r12+208)
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
8026008: 34 0c 00 00 mvi r12,0
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
802600c: a4 40 10 00 not r2,r2
8026010: a0 22 08 00 and r1,r1,r2
8026014: 44 20 00 21 be r1,r0,8026098 <_POSIX_signals_Unblock_thread+0x14c>
8026018: 78 01 10 00 mvhi r1,0x1000
802601c: a0 81 08 00 and r1,r4,r1
* 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 ) ) {
8026020: 44 20 00 15 be r1,r0,8026074 <_POSIX_signals_Unblock_thread+0x128>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
8026024: 78 02 08 02 mvhi r2,0x802
the_thread->Wait.return_code = EINTR;
8026028: 34 01 00 04 mvi r1,4
802602c: 38 42 75 2c ori r2,r2,0x752c
8026030: 59 61 00 34 sw (r11+52),r1
8026034: 28 41 00 00 lw r1,(r2+0)
8026038: a0 81 08 00 and r1,r4,r1
/*
* 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) )
802603c: 44 20 00 04 be r1,r0,802604c <_POSIX_signals_Unblock_thread+0x100>
_Thread_queue_Extract_with_proxy( the_thread );
8026040: b9 60 08 00 mv r1,r11
8026044: fb ff 9a 88 calli 800ca64 <_Thread_queue_Extract_with_proxy>
8026048: e0 00 00 14 bi 8026098 <_POSIX_signals_Unblock_thread+0x14c>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_delaying (
States_Control the_states
)
{
return (the_states & STATES_DELAYING);
802604c: 20 84 00 08 andi r4,r4,0x8
else if ( _States_Is_delaying(the_thread->current_state) ) {
8026050: 44 8c 00 12 be r4,r12,8026098 <_POSIX_signals_Unblock_thread+0x14c><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
8026054: 35 61 00 48 addi r1,r11,72
8026058: fb ff 9d 45 calli 800d56c <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
802605c: 78 03 08 02 mvhi r3,0x802
8026060: 38 63 73 90 ori r3,r3,0x7390
8026064: 28 62 00 00 lw r2,(r3+0)
8026068: b9 60 08 00 mv r1,r11
802606c: fb ff 97 52 calli 800bdb4 <_Thread_Clear_state>
8026070: e0 00 00 0a bi 8026098 <_POSIX_signals_Unblock_thread+0x14c>
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
8026074: 5c 8c 00 09 bne r4,r12,8026098 <_POSIX_signals_Unblock_thread+0x14c><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
8026078: 78 01 08 02 mvhi r1,0x802
802607c: 38 21 9f 2c ori r1,r1,0x9f2c
8026080: 28 22 00 08 lw r2,(r1+8)
8026084: 44 4c 00 05 be r2,r12,8026098 <_POSIX_signals_Unblock_thread+0x14c>
8026088: 28 22 00 0c lw r2,(r1+12)
802608c: 5d 62 00 03 bne r11,r2,8026098 <_POSIX_signals_Unblock_thread+0x14c><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
8026090: 34 02 00 01 mvi r2,1
8026094: 30 22 00 18 sb (r1+24),r2
}
}
return false;
}
8026098: b9 80 08 00 mv r1,r12
802609c: 2b 9d 00 04 lw ra,(sp+4)
80260a0: 2b 8b 00 14 lw r11,(sp+20)
80260a4: 2b 8c 00 10 lw r12,(sp+16)
80260a8: 2b 8d 00 0c lw r13,(sp+12)
80260ac: 2b 8e 00 08 lw r14,(sp+8)
80260b0: 37 9c 00 14 addi sp,sp,20
80260b4: c3 a0 00 00 ret
08004298 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
8004298: 37 9c ff e8 addi sp,sp,-24
800429c: 5b 8b 00 14 sw (sp+20),r11
80042a0: 5b 8c 00 10 sw (sp+16),r12
80042a4: 5b 8d 00 0c sw (sp+12),r13
80042a8: 5b 8e 00 08 sw (sp+8),r14
80042ac: 5b 9d 00 04 sw (sp+4),ra
rtems_initialization_tasks_table *user_tasks;
/*
* Move information into local variables
*/
user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
80042b0: 78 01 08 01 mvhi r1,0x801
80042b4: 38 21 90 a4 ori r1,r1,0x90a4
80042b8: 28 2b 00 2c lw r11,(r1+44)
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
80042bc: 28 2e 00 28 lw r14,(r1+40)
/*
* Verify that we have a set of user tasks to iterate
*/
if ( !user_tasks )
80042c0: 34 0d 00 00 mvi r13,0
80042c4: 5d 60 00 1a bne r11,r0,800432c <_RTEMS_tasks_Initialize_user_tasks_body+0x94>
80042c8: e0 00 00 1a bi 8004330 <_RTEMS_tasks_Initialize_user_tasks_body+0x98>
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
return_value = rtems_task_create(
80042cc: 29 61 00 00 lw r1,(r11+0)
80042d0: 29 62 00 08 lw r2,(r11+8)
80042d4: 29 63 00 04 lw r3,(r11+4)
80042d8: 29 64 00 14 lw r4,(r11+20)
80042dc: 29 65 00 0c lw r5,(r11+12)
80042e0: 37 86 00 18 addi r6,sp,24
80042e4: f8 00 26 f1 calli 800dea8 <rtems_task_create>
80042e8: b8 20 60 00 mv r12,r1
user_tasks[ index ].stack_size,
user_tasks[ index ].mode_set,
user_tasks[ index ].attribute_set,
&id
);
if ( !rtems_is_status_successful( return_value ) )
80042ec: 44 20 00 05 be r1,r0,8004300 <_RTEMS_tasks_Initialize_user_tasks_body+0x68><== ALWAYS TAKEN
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
80042f0: 34 01 00 01 mvi r1,1 <== NOT EXECUTED
80042f4: 34 02 00 01 mvi r2,1 <== NOT EXECUTED
80042f8: b9 80 18 00 mv r3,r12 <== NOT EXECUTED
80042fc: e0 00 00 0a bi 8004324 <_RTEMS_tasks_Initialize_user_tasks_body+0x8c><== NOT EXECUTED
return_value = rtems_task_start(
8004300: 29 63 00 18 lw r3,(r11+24)
8004304: 29 62 00 10 lw r2,(r11+16)
8004308: 2b 81 00 18 lw r1,(sp+24)
800430c: 35 6b 00 1c addi r11,r11,28
8004310: f8 00 00 0f calli 800434c <rtems_task_start>
8004314: b8 20 18 00 mv r3,r1
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
8004318: 44 2c 00 04 be r1,r12,8004328 <_RTEMS_tasks_Initialize_user_tasks_body+0x90>
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
800431c: 34 01 00 01 mvi r1,1 <== NOT EXECUTED
8004320: 34 02 00 01 mvi r2,1 <== NOT EXECUTED
8004324: f8 00 04 a5 calli 80055b8 <_Internal_error_Occurred> <== NOT EXECUTED
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
8004328: 35 ad 00 01 addi r13,r13,1
800432c: 55 cd ff e8 bgu r14,r13,80042cc <_RTEMS_tasks_Initialize_user_tasks_body+0x34>
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
}
}
8004330: 2b 9d 00 04 lw ra,(sp+4)
8004334: 2b 8b 00 14 lw r11,(sp+20)
8004338: 2b 8c 00 10 lw r12,(sp+16)
800433c: 2b 8d 00 0c lw r13,(sp+12)
8004340: 2b 8e 00 08 lw r14,(sp+8)
8004344: 37 9c 00 18 addi sp,sp,24
8004348: c3 a0 00 00 ret
08004634 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
8004634: 37 9c ff f4 addi sp,sp,-12
8004638: 5b 8b 00 08 sw (sp+8),r11
800463c: 5b 9d 00 04 sw (sp+4),ra
8004640: b8 20 10 00 mv r2,r1
8004644: 78 01 08 02 mvhi r1,0x802
8004648: 38 21 19 00 ori r1,r1,0x1900
800464c: 37 83 00 0c addi r3,sp,12
8004650: f8 00 08 dd calli 80069c4 <_Objects_Get>
/*
* When we get here, the Timer is already off the chain so we do not
* have to worry about that -- hence no _Watchdog_Remove().
*/
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
8004654: 2b 82 00 0c lw r2,(sp+12)
8004658: b8 20 58 00 mv r11,r1
800465c: 5c 40 00 22 bne r2,r0,80046e4 <_Rate_monotonic_Timeout+0xb0><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
8004660: 28 21 00 40 lw r1,(r1+64)
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_period (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_PERIOD);
8004664: 28 23 00 10 lw r3,(r1+16)
8004668: 20 63 40 00 andi r3,r3,0x4000
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
800466c: 44 62 00 09 be r3,r2,8004690 <_Rate_monotonic_Timeout+0x5c>
8004670: 28 23 00 20 lw r3,(r1+32)
8004674: 29 62 00 08 lw r2,(r11+8)
8004678: 5c 62 00 06 bne r3,r2,8004690 <_Rate_monotonic_Timeout+0x5c>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
800467c: 78 03 08 01 mvhi r3,0x801
8004680: 38 63 eb b4 ori r3,r3,0xebb4
8004684: 28 62 00 00 lw r2,(r3+0)
8004688: f8 00 0b dd calli 80075fc <_Thread_Clear_state>
800468c: e0 00 00 06 bi 80046a4 <_Rate_monotonic_Timeout+0x70>
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
8004690: 29 62 00 38 lw r2,(r11+56)
8004694: 34 01 00 01 mvi r1,1
8004698: 5c 41 00 0c bne r2,r1,80046c8 <_Rate_monotonic_Timeout+0x94><== ALWAYS TAKEN
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
800469c: 34 01 00 03 mvi r1,3 <== NOT EXECUTED
80046a0: 59 61 00 38 sw (r11+56),r1 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
80046a4: b9 60 08 00 mv r1,r11
80046a8: fb ff fe 2e calli 8003f60 <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
80046ac: 29 61 00 3c lw r1,(r11+60)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
80046b0: 35 62 00 10 addi r2,r11,16
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
80046b4: 59 61 00 1c sw (r11+28),r1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
80046b8: 78 01 08 02 mvhi r1,0x802
80046bc: 38 21 1a e8 ori r1,r1,0x1ae8
80046c0: f8 00 11 3b calli 8008bac <_Watchdog_Insert>
80046c4: e0 00 00 03 bi 80046d0 <_Rate_monotonic_Timeout+0x9c>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
80046c8: 34 01 00 04 mvi r1,4
80046cc: 59 61 00 38 sw (r11+56),r1
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
80046d0: 78 01 08 02 mvhi r1,0x802
80046d4: 38 21 1a 28 ori r1,r1,0x1a28
80046d8: 28 22 00 00 lw r2,(r1+0)
80046dc: 34 42 ff ff addi r2,r2,-1
80046e0: 58 22 00 00 sw (r1+0),r2
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
80046e4: 2b 9d 00 04 lw ra,(sp+4)
80046e8: 2b 8b 00 08 lw r11,(sp+8)
80046ec: 37 9c 00 0c addi sp,sp,12
80046f0: c3 a0 00 00 ret
08003ff4 <_Rate_monotonic_Update_statistics>:
void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
8003ff4: 37 9c ff e4 addi sp,sp,-28
8003ff8: 5b 8b 00 0c sw (sp+12),r11
8003ffc: 5b 8c 00 08 sw (sp+8),r12
8004000: 5b 9d 00 04 sw (sp+4),ra
8004004: b8 20 58 00 mv r11,r1
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
8004008: 28 21 00 54 lw r1,(r1+84)
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
800400c: 29 62 00 38 lw r2,(r11+56)
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
8004010: 34 21 00 01 addi r1,r1,1
8004014: 59 61 00 54 sw (r11+84),r1
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
8004018: 34 01 00 04 mvi r1,4
800401c: 5c 41 00 04 bne r2,r1,800402c <_Rate_monotonic_Update_statistics+0x38>
stats->missed_count++;
8004020: 29 61 00 58 lw r1,(r11+88)
8004024: 34 21 00 01 addi r1,r1,1
8004028: 59 61 00 58 sw (r11+88),r1
/*
* Grab status for time statistics.
*/
valid_status =
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
800402c: 37 8c 00 18 addi r12,sp,24
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
8004030: b9 60 08 00 mv r1,r11
8004034: 37 82 00 10 addi r2,sp,16
8004038: b9 80 18 00 mv r3,r12
800403c: fb ff ff 90 calli 8003e7c <_Rate_monotonic_Get_status>
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
8004040: 44 20 00 28 be r1,r0,80040e0 <_Rate_monotonic_Update_statistics+0xec><== NEVER TAKEN
/*
* Update CPU time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
8004044: b9 80 10 00 mv r2,r12
8004048: 35 61 00 6c addi r1,r11,108
800404c: f8 00 11 75 calli 8008620 <_Timespec_Add_to>
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
8004050: b9 80 08 00 mv r1,r12
8004054: 35 62 00 5c addi r2,r11,92
8004058: f8 00 11 d0 calli 8008798 <_Timespec_Less_than>
800405c: 44 20 00 05 be r1,r0,8004070 <_Rate_monotonic_Update_statistics+0x7c>
stats->min_cpu_time = executed;
8004060: 2b 81 00 18 lw r1,(sp+24)
8004064: 59 61 00 5c sw (r11+92),r1
8004068: 2b 81 00 1c lw r1,(sp+28)
800406c: 59 61 00 60 sw (r11+96),r1
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
8004070: 37 81 00 18 addi r1,sp,24
8004074: 35 62 00 64 addi r2,r11,100
8004078: f8 00 11 bd calli 800876c <_Timespec_Greater_than>
800407c: 44 20 00 05 be r1,r0,8004090 <_Rate_monotonic_Update_statistics+0x9c>
stats->max_cpu_time = executed;
8004080: 2b 81 00 18 lw r1,(sp+24)
8004084: 59 61 00 64 sw (r11+100),r1
8004088: 2b 81 00 1c lw r1,(sp+28)
800408c: 59 61 00 68 sw (r11+104),r1
/*
* Update Wall time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
8004090: 37 8c 00 10 addi r12,sp,16
8004094: b9 80 10 00 mv r2,r12
8004098: 35 61 00 84 addi r1,r11,132
800409c: f8 00 11 61 calli 8008620 <_Timespec_Add_to>
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
80040a0: b9 80 08 00 mv r1,r12
80040a4: 35 62 00 74 addi r2,r11,116
80040a8: f8 00 11 bc calli 8008798 <_Timespec_Less_than>
80040ac: 44 20 00 05 be r1,r0,80040c0 <_Rate_monotonic_Update_statistics+0xcc>
stats->min_wall_time = since_last_period;
80040b0: 2b 81 00 10 lw r1,(sp+16)
80040b4: 59 61 00 74 sw (r11+116),r1
80040b8: 2b 81 00 14 lw r1,(sp+20)
80040bc: 59 61 00 78 sw (r11+120),r1
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
80040c0: 37 81 00 10 addi r1,sp,16
80040c4: 35 62 00 7c addi r2,r11,124
80040c8: f8 00 11 a9 calli 800876c <_Timespec_Greater_than>
80040cc: 44 20 00 05 be r1,r0,80040e0 <_Rate_monotonic_Update_statistics+0xec>
stats->max_wall_time = since_last_period;
80040d0: 2b 81 00 10 lw r1,(sp+16)
80040d4: 59 61 00 7c sw (r11+124),r1
80040d8: 2b 81 00 14 lw r1,(sp+20)
80040dc: 59 61 00 80 sw (r11+128),r1
stats->min_wall_time = since_last_period;
if ( since_last_period > stats->max_wall_time )
stats->max_wall_time = since_last_period;
#endif
}
80040e0: 2b 9d 00 04 lw ra,(sp+4)
80040e4: 2b 8b 00 0c lw r11,(sp+12)
80040e8: 2b 8c 00 08 lw r12,(sp+8)
80040ec: 37 9c 00 1c addi sp,sp,28
80040f0: c3 a0 00 00 ret
08006108 <_Scheduler_priority_Block>:
#include <rtems/score/thread.h>
void _Scheduler_priority_Block(
Thread_Control *the_thread
)
{
8006108: 37 9c ff ec addi sp,sp,-20
800610c: 5b 8b 00 14 sw (sp+20),r11
8006110: 5b 8c 00 10 sw (sp+16),r12
8006114: 5b 8d 00 0c sw (sp+12),r13
8006118: 5b 8e 00 08 sw (sp+8),r14
800611c: 5b 9d 00 04 sw (sp+4),ra
8006120: b8 20 60 00 mv r12,r1
)
{
Scheduler_priority_Per_thread *sched_info;
Chain_Control *ready;
sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
8006124: 28 21 00 8c lw r1,(r1+140)
ready = sched_info->ready_chain;
8006128: 28 22 00 00 lw r2,(r1+0)
if ( _Chain_Has_only_one_node( ready ) ) {
800612c: 28 44 00 00 lw r4,(r2+0)
8006130: 28 43 00 08 lw r3,(r2+8)
8006134: 5c 83 00 12 bne r4,r3,800617c <_Scheduler_priority_Block+0x74>
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 );
8006138: 34 43 00 04 addi r3,r2,4
head->next = tail;
800613c: 58 43 00 00 sw (r2+0),r3
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
8006140: 28 23 00 04 lw r3,(r1+4)
head->previous = NULL;
8006144: 58 40 00 04 sw (r2+4),r0
tail->previous = head;
8006148: 58 42 00 08 sw (r2+8),r2
800614c: 2c 24 00 0e lhu r4,(r1+14)
8006150: 2c 62 00 00 lhu r2,(r3+0)
8006154: a0 44 10 00 and r2,r2,r4
8006158: 0c 62 00 00 sh (r3+0),r2
if ( *the_priority_map->minor == 0 )
800615c: 5c 40 00 0c bne r2,r0,800618c <_Scheduler_priority_Block+0x84>
_Priority_Major_bit_map &= the_priority_map->block_major;
8006160: 78 02 08 01 mvhi r2,0x801
8006164: 38 42 9e 58 ori r2,r2,0x9e58
8006168: 2c 43 00 00 lhu r3,(r2+0)
800616c: 2c 21 00 0c lhu r1,(r1+12)
8006170: a0 23 08 00 and r1,r1,r3
8006174: 0c 41 00 00 sh (r2+0),r1
8006178: e0 00 00 05 bi 800618c <_Scheduler_priority_Block+0x84>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
800617c: 29 82 00 00 lw r2,(r12+0)
previous = the_node->previous;
8006180: 29 81 00 04 lw r1,(r12+4)
next->previous = previous;
8006184: 58 41 00 04 sw (r2+4),r1
previous->next = next;
8006188: 58 22 00 00 sw (r1+0),r2
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Heir );
800618c: 78 01 08 01 mvhi r1,0x801
8006190: 38 21 9e 3c ori r1,r1,0x9e3c
_Scheduler_priority_Ready_queue_extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
8006194: 28 21 00 10 lw r1,(r1+16)
8006198: 5d 81 00 3b bne r12,r1,8006284 <_Scheduler_priority_Block+0x17c>
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
(Chain_Control *) _Scheduler.information
800619c: 78 01 08 01 mvhi r1,0x801
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
80061a0: 78 02 08 01 mvhi r2,0x801
80061a4: 38 21 90 1c ori r1,r1,0x901c
80061a8: 38 42 9e 58 ori r2,r2,0x9e58
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
80061ac: 28 2e 00 00 lw r14,(r1+0)
80061b0: 2c 41 00 00 lhu r1,(r2+0)
80061b4: 78 0b 08 01 mvhi r11,0x801
80061b8: 34 02 00 ff mvi r2,255
80061bc: 20 21 ff ff andi r1,r1,0xffff
80061c0: 39 6b 80 04 ori r11,r11,0x8004
80061c4: 54 22 00 05 bgu r1,r2,80061d8 <_Scheduler_priority_Block+0xd0>
80061c8: b5 61 58 00 add r11,r11,r1
80061cc: 41 6d 00 00 lbu r13,(r11+0)
80061d0: 35 ad 00 08 addi r13,r13,8
80061d4: e0 00 00 05 bi 80061e8 <_Scheduler_priority_Block+0xe0>
80061d8: 34 02 00 08 mvi r2,8
80061dc: f8 00 43 9b calli 8017048 <__lshrsi3>
80061e0: b5 61 58 00 add r11,r11,r1
80061e4: 41 6d 00 00 lbu r13,(r11+0)
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
80061e8: 34 02 00 01 mvi r2,1
80061ec: 78 0b 08 01 mvhi r11,0x801
80061f0: b9 a0 08 00 mv r1,r13
80061f4: f8 00 43 47 calli 8016f10 <__ashlsi3>
80061f8: 39 6b 9e 60 ori r11,r11,0x9e60
80061fc: b5 61 58 00 add r11,r11,r1
8006200: 2d 62 00 00 lhu r2,(r11+0)
8006204: 34 01 00 ff mvi r1,255
8006208: 78 0b 08 01 mvhi r11,0x801
800620c: 39 6b 80 04 ori r11,r11,0x8004
8006210: 54 41 00 05 bgu r2,r1,8006224 <_Scheduler_priority_Block+0x11c>
8006214: b5 62 58 00 add r11,r11,r2
8006218: 41 6b 00 00 lbu r11,(r11+0)
800621c: 35 6b 00 08 addi r11,r11,8
8006220: e0 00 00 06 bi 8006238 <_Scheduler_priority_Block+0x130>
8006224: b8 40 08 00 mv r1,r2
8006228: 34 02 00 08 mvi r2,8
800622c: f8 00 43 87 calli 8017048 <__lshrsi3>
8006230: b5 61 58 00 add r11,r11,r1
8006234: 41 6b 00 00 lbu r11,(r11+0)
return (_Priority_Bits_index( major ) << 4) +
8006238: 34 02 00 04 mvi r2,4
800623c: b9 a0 08 00 mv r1,r13
8006240: f8 00 43 34 calli 8016f10 <__ashlsi3>
8006244: b5 61 58 00 add r11,r11,r1
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
8006248: 34 02 00 01 mvi r2,1
800624c: b9 60 08 00 mv r1,r11
8006250: f8 00 43 30 calli 8016f10 <__ashlsi3>
8006254: 34 02 00 02 mvi r2,2
8006258: b4 2b 08 00 add r1,r1,r11
800625c: f8 00 43 2d calli 8016f10 <__ashlsi3>
8006260: b5 c1 08 00 add r1,r14,r1
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
8006264: 28 23 00 00 lw r3,(r1+0)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
8006268: 34 21 00 04 addi r1,r1,4
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
800626c: 34 02 00 00 mvi r2,0
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
8006270: 44 61 00 02 be r3,r1,8006278 <_Scheduler_priority_Block+0x170><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
8006274: b8 60 10 00 mv r2,r3
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
8006278: 78 01 08 01 mvhi r1,0x801
800627c: 38 21 9e 3c ori r1,r1,0x9e3c
8006280: 58 22 00 10 sw (r1+16),r2
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
8006284: 78 01 08 01 mvhi r1,0x801
8006288: 38 21 9e 3c ori r1,r1,0x9e3c
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
800628c: 28 22 00 0c lw r2,(r1+12)
8006290: 5d 82 00 03 bne r12,r2,800629c <_Scheduler_priority_Block+0x194>
_Thread_Dispatch_necessary = true;
8006294: 34 02 00 01 mvi r2,1
8006298: 30 22 00 18 sb (r1+24),r2
}
800629c: 2b 9d 00 04 lw ra,(sp+4)
80062a0: 2b 8b 00 14 lw r11,(sp+20)
80062a4: 2b 8c 00 10 lw r12,(sp+16)
80062a8: 2b 8d 00 0c lw r13,(sp+12)
80062ac: 2b 8e 00 08 lw r14,(sp+8)
80062b0: 37 9c 00 14 addi sp,sp,20
80062b4: c3 a0 00 00 ret
0800648c <_Scheduler_priority_Schedule>:
#include <rtems/system.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Schedule(void)
{
800648c: 37 9c ff f0 addi sp,sp,-16
8006490: 5b 8b 00 10 sw (sp+16),r11
8006494: 5b 8c 00 0c sw (sp+12),r12
8006498: 5b 8d 00 08 sw (sp+8),r13
800649c: 5b 9d 00 04 sw (sp+4),ra
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
(Chain_Control *) _Scheduler.information
80064a0: 78 01 08 01 mvhi r1,0x801
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
80064a4: 78 02 08 01 mvhi r2,0x801
80064a8: 38 21 90 1c ori r1,r1,0x901c
80064ac: 38 42 9e 58 ori r2,r2,0x9e58
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
80064b0: 28 2d 00 00 lw r13,(r1+0)
80064b4: 2c 41 00 00 lhu r1,(r2+0)
80064b8: 78 0b 08 01 mvhi r11,0x801
80064bc: 34 02 00 ff mvi r2,255
80064c0: 20 21 ff ff andi r1,r1,0xffff
80064c4: 39 6b 80 04 ori r11,r11,0x8004
80064c8: 54 22 00 05 bgu r1,r2,80064dc <_Scheduler_priority_Schedule+0x50>
80064cc: b5 61 58 00 add r11,r11,r1
80064d0: 41 6c 00 00 lbu r12,(r11+0)
80064d4: 35 8c 00 08 addi r12,r12,8
80064d8: e0 00 00 05 bi 80064ec <_Scheduler_priority_Schedule+0x60>
80064dc: 34 02 00 08 mvi r2,8
80064e0: f8 00 42 da calli 8017048 <__lshrsi3>
80064e4: b5 61 58 00 add r11,r11,r1
80064e8: 41 6c 00 00 lbu r12,(r11+0)
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
80064ec: 34 02 00 01 mvi r2,1
80064f0: 78 0b 08 01 mvhi r11,0x801
80064f4: b9 80 08 00 mv r1,r12
80064f8: f8 00 42 86 calli 8016f10 <__ashlsi3>
80064fc: 39 6b 9e 60 ori r11,r11,0x9e60
8006500: b5 61 58 00 add r11,r11,r1
8006504: 2d 62 00 00 lhu r2,(r11+0)
8006508: 34 01 00 ff mvi r1,255
800650c: 78 0b 08 01 mvhi r11,0x801
8006510: 39 6b 80 04 ori r11,r11,0x8004
8006514: 54 41 00 05 bgu r2,r1,8006528 <_Scheduler_priority_Schedule+0x9c>
8006518: b5 62 58 00 add r11,r11,r2
800651c: 41 6b 00 00 lbu r11,(r11+0)
8006520: 35 6b 00 08 addi r11,r11,8
8006524: e0 00 00 06 bi 800653c <_Scheduler_priority_Schedule+0xb0>
8006528: b8 40 08 00 mv r1,r2
800652c: 34 02 00 08 mvi r2,8
8006530: f8 00 42 c6 calli 8017048 <__lshrsi3>
8006534: b5 61 58 00 add r11,r11,r1
8006538: 41 6b 00 00 lbu r11,(r11+0)
return (_Priority_Bits_index( major ) << 4) +
800653c: 34 02 00 04 mvi r2,4
8006540: b9 80 08 00 mv r1,r12
8006544: f8 00 42 73 calli 8016f10 <__ashlsi3>
8006548: b5 61 58 00 add r11,r11,r1
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
800654c: 34 02 00 01 mvi r2,1
8006550: b9 60 08 00 mv r1,r11
8006554: f8 00 42 6f calli 8016f10 <__ashlsi3>
8006558: 34 02 00 02 mvi r2,2
800655c: b4 2b 08 00 add r1,r1,r11
8006560: f8 00 42 6c calli 8016f10 <__ashlsi3>
8006564: b5 a1 08 00 add r1,r13,r1
_Scheduler_priority_Schedule_body();
}
8006568: 28 23 00 00 lw r3,(r1+0)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
800656c: 34 21 00 04 addi r1,r1,4
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
8006570: 34 02 00 00 mvi r2,0
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
8006574: 44 61 00 02 be r3,r1,800657c <_Scheduler_priority_Schedule+0xf0><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
8006578: b8 60 10 00 mv r2,r3
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
800657c: 78 01 08 01 mvhi r1,0x801
8006580: 38 21 9e 3c ori r1,r1,0x9e3c
8006584: 58 22 00 10 sw (r1+16),r2
8006588: 2b 9d 00 04 lw ra,(sp+4)
800658c: 2b 8b 00 10 lw r11,(sp+16)
8006590: 2b 8c 00 0c lw r12,(sp+12)
8006594: 2b 8d 00 08 lw r13,(sp+8)
8006598: 37 9c 00 10 addi sp,sp,16
800659c: c3 a0 00 00 ret
0800428c <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
800428c: 37 9c ff f0 addi sp,sp,-16
8004290: 5b 8b 00 10 sw (sp+16),r11
8004294: 5b 8c 00 0c sw (sp+12),r12
8004298: 5b 8d 00 08 sw (sp+8),r13
800429c: 5b 9d 00 04 sw (sp+4),ra
80042a0: b8 20 58 00 mv r11,r1
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
80042a4: 78 01 08 02 mvhi r1,0x802
80042a8: 38 21 10 f4 ori r1,r1,0x10f4
80042ac: 28 22 00 0c lw r2,(r1+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;
80042b0: 34 0c 00 00 mvi r12,0
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) ||
80042b4: 45 60 00 22 be r11,r0,800433c <_TOD_Validate+0xb0> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
80042b8: 78 03 08 01 mvhi r3,0x801
80042bc: 38 63 e9 44 ori r3,r3,0xe944
80042c0: 28 61 00 00 lw r1,(r3+0)
80042c4: f8 00 63 fe calli 801d2bc <__udivsi3>
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
80042c8: 29 62 00 18 lw r2,(r11+24)
80042cc: 50 41 00 1c bgeu r2,r1,800433c <_TOD_Validate+0xb0>
(the_tod->ticks >= ticks_per_second) ||
80042d0: 29 62 00 14 lw r2,(r11+20)
80042d4: 34 01 00 3b mvi r1,59
80042d8: 54 41 00 19 bgu r2,r1,800433c <_TOD_Validate+0xb0>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
80042dc: 29 62 00 10 lw r2,(r11+16)
80042e0: 54 41 00 17 bgu r2,r1,800433c <_TOD_Validate+0xb0>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
80042e4: 29 62 00 0c lw r2,(r11+12)
80042e8: 34 01 00 17 mvi r1,23
80042ec: 54 41 00 14 bgu r2,r1,800433c <_TOD_Validate+0xb0>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
80042f0: 29 61 00 04 lw r1,(r11+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) ||
80042f4: 44 20 00 12 be r1,r0,800433c <_TOD_Validate+0xb0> <== NEVER TAKEN
(the_tod->month == 0) ||
80042f8: 34 02 00 0c mvi r2,12
80042fc: 54 22 00 10 bgu r1,r2,800433c <_TOD_Validate+0xb0>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
8004300: 29 62 00 00 lw r2,(r11+0)
(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) ||
8004304: 34 03 07 c3 mvi r3,1987
8004308: 50 62 00 0d bgeu r3,r2,800433c <_TOD_Validate+0xb0>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
800430c: 29 6d 00 08 lw r13,(r11+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) ||
8004310: 45 a0 00 0b be r13,r0,800433c <_TOD_Validate+0xb0> <== NEVER TAKEN
8004314: 78 0b 08 01 mvhi r11,0x801
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
8004318: 20 42 00 03 andi r2,r2,0x3
800431c: 39 6b f1 fc ori r11,r11,0xf1fc
8004320: 5c 40 00 02 bne r2,r0,8004328 <_TOD_Validate+0x9c>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
8004324: 34 21 00 0d addi r1,r1,13
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
8004328: 34 02 00 02 mvi r2,2
800432c: fb ff f3 dd calli 80012a0 <__ashlsi3>
8004330: b5 61 08 00 add r1,r11,r1
8004334: 28 2c 00 00 lw r12,(r1+0)
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
8004338: f1 8d 60 00 cmpgeu r12,r12,r13
if ( the_tod->day > days_in_month )
return false;
return true;
}
800433c: b9 80 08 00 mv r1,r12
8004340: 2b 9d 00 04 lw ra,(sp+4)
8004344: 2b 8b 00 10 lw r11,(sp+16)
8004348: 2b 8c 00 0c lw r12,(sp+12)
800434c: 2b 8d 00 08 lw r13,(sp+8)
8004350: 37 9c 00 10 addi sp,sp,16
8004354: c3 a0 00 00 ret
08006798 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
8006798: 37 9c ff e8 addi sp,sp,-24
800679c: 5b 8b 00 18 sw (sp+24),r11
80067a0: 5b 8c 00 14 sw (sp+20),r12
80067a4: 5b 8d 00 10 sw (sp+16),r13
80067a8: 5b 8e 00 0c sw (sp+12),r14
80067ac: 5b 8f 00 08 sw (sp+8),r15
80067b0: 5b 9d 00 04 sw (sp+4),ra
80067b4: b8 20 58 00 mv r11,r1
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
80067b8: 28 2f 00 10 lw r15,(r1+16)
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
80067bc: b8 40 60 00 mv r12,r2
80067c0: 20 6e 00 ff andi r14,r3,0xff
/*
* Set a transient state for the thread so it is pulled off the Ready chains.
* This will prevent it from being scheduled no matter what happens in an
* ISR.
*/
_Thread_Set_transient( the_thread );
80067c4: f8 00 03 9c calli 8007634 <_Thread_Set_transient>
/*
* Do not bother recomputing all the priority related information if
* we are not REALLY changing priority.
*/
if ( the_thread->current_priority != new_priority )
80067c8: 29 61 00 14 lw r1,(r11+20)
80067cc: 44 2c 00 04 be r1,r12,80067dc <_Thread_Change_priority+0x44>
_Thread_Set_priority( the_thread, new_priority );
80067d0: b9 60 08 00 mv r1,r11
80067d4: b9 80 10 00 mv r2,r12
80067d8: f8 00 03 76 calli 80075b0 <_Thread_Set_priority>
_ISR_Disable( level );
80067dc: 90 00 60 00 rcsr r12,IE
80067e0: 34 0d ff fe mvi r13,-2
80067e4: a1 8d 68 00 and r13,r12,r13
80067e8: d0 0d 00 00 wcsr IE,r13
/*
* If the thread has more than STATES_TRANSIENT set, then it is blocked,
* If it is blocked on a thread queue, then we need to requeue it.
*/
state = the_thread->current_state;
80067ec: 29 61 00 10 lw r1,(r11+16)
if ( state != STATES_TRANSIENT ) {
80067f0: 34 03 00 04 mvi r3,4
80067f4: 21 e2 00 04 andi r2,r15,0x4
80067f8: 44 23 00 0f be r1,r3,8006834 <_Thread_Change_priority+0x9c>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
80067fc: 5c 40 00 04 bne r2,r0,800680c <_Thread_Change_priority+0x74><== NEVER TAKEN
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
8006800: 34 02 ff fb mvi r2,-5
8006804: a0 22 10 00 and r2,r1,r2
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
8006808: 59 62 00 10 sw (r11+16),r2
_ISR_Enable( level );
800680c: d0 0c 00 00 wcsr IE,r12
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
8006810: 78 03 08 01 mvhi r3,0x801
8006814: 38 63 81 6c ori r3,r3,0x816c
8006818: 28 62 00 00 lw r2,(r3+0)
800681c: a0 22 08 00 and r1,r1,r2
if ( _States_Is_waiting_on_thread_queue( state ) ) {
8006820: 44 20 00 1f be r1,r0,800689c <_Thread_Change_priority+0x104>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
8006824: 29 61 00 44 lw r1,(r11+68)
8006828: b9 60 10 00 mv r2,r11
800682c: f8 00 03 2c calli 80074dc <_Thread_queue_Requeue>
8006830: e0 00 00 1b bi 800689c <_Thread_Change_priority+0x104>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
8006834: 5c 40 00 0a bne r2,r0,800685c <_Thread_Change_priority+0xc4><== NEVER TAKEN
8006838: 78 01 08 01 mvhi r1,0x801
* Interrupts are STILL disabled.
* We now know the thread will be in the READY state when we remove
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
800683c: 59 60 00 10 sw (r11+16),r0
8006840: 38 21 90 1c ori r1,r1,0x901c
if ( prepend_it )
8006844: 45 c2 00 03 be r14,r2,8006850 <_Thread_Change_priority+0xb8>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
8006848: 28 22 00 28 lw r2,(r1+40)
800684c: e0 00 00 02 bi 8006854 <_Thread_Change_priority+0xbc>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
8006850: 28 22 00 24 lw r2,(r1+36)
8006854: b9 60 08 00 mv r1,r11
8006858: d8 40 00 00 call r2
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
800685c: d0 0c 00 00 wcsr IE,r12
8006860: d0 0d 00 00 wcsr IE,r13
* This kernel routine implements the scheduling decision logic for
* the scheduler. It does NOT dispatch.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void )
{
_Scheduler.Operations.schedule();
8006864: 78 01 08 01 mvhi r1,0x801
8006868: 38 21 90 1c ori r1,r1,0x901c
800686c: 28 21 00 08 lw r1,(r1+8)
8006870: d8 20 00 00 call r1
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
8006874: 78 01 08 01 mvhi r1,0x801
8006878: 38 21 9e 3c ori r1,r1,0x9e3c
800687c: 28 22 00 0c lw r2,(r1+12)
* We altered the set of thread priorities. So let's figure out
* who is the heir and if we need to switch to them.
*/
_Scheduler_Schedule();
if ( !_Thread_Is_executing_also_the_heir() &&
8006880: 28 23 00 10 lw r3,(r1+16)
8006884: 44 43 00 05 be r2,r3,8006898 <_Thread_Change_priority+0x100>
8006888: 40 42 00 74 lbu r2,(r2+116)
800688c: 44 40 00 03 be r2,r0,8006898 <_Thread_Change_priority+0x100>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
8006890: 34 02 00 01 mvi r2,1
8006894: 30 22 00 18 sb (r1+24),r2
_ISR_Enable( level );
8006898: d0 0c 00 00 wcsr IE,r12
}
800689c: 2b 9d 00 04 lw ra,(sp+4)
80068a0: 2b 8b 00 18 lw r11,(sp+24)
80068a4: 2b 8c 00 14 lw r12,(sp+20)
80068a8: 2b 8d 00 10 lw r13,(sp+16)
80068ac: 2b 8e 00 0c lw r14,(sp+12)
80068b0: 2b 8f 00 08 lw r15,(sp+8)
80068b4: 37 9c 00 18 addi sp,sp,24
80068b8: c3 a0 00 00 ret
0800bfd4 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
800bfd4: 37 9c ff f8 addi sp,sp,-8
800bfd8: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
800bfdc: 37 82 00 08 addi r2,sp,8
800bfe0: f8 00 00 7c calli 800c1d0 <_Thread_Get>
switch ( location ) {
800bfe4: 2b 82 00 08 lw r2,(sp+8)
800bfe8: 5c 40 00 0a bne r2,r0,800c010 <_Thread_Delay_ended+0x3c> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
800bfec: 78 03 08 02 mvhi r3,0x802
800bff0: 38 63 75 34 ori r3,r3,0x7534
800bff4: 28 62 00 00 lw r2,(r3+0)
800bff8: fb ff ff 6f calli 800bdb4 <_Thread_Clear_state>
800bffc: 78 01 08 02 mvhi r1,0x802
800c000: 38 21 9a 80 ori r1,r1,0x9a80
800c004: 28 22 00 00 lw r2,(r1+0)
800c008: 34 42 ff ff addi r2,r2,-1
800c00c: 58 22 00 00 sw (r1+0),r2
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
800c010: 2b 9d 00 04 lw ra,(sp+4)
800c014: 37 9c 00 08 addi sp,sp,8
800c018: c3 a0 00 00 ret
080069a8 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
80069a8: 37 9c ff c0 addi sp,sp,-64
80069ac: 5b 8b 00 30 sw (sp+48),r11
80069b0: 5b 8c 00 2c sw (sp+44),r12
80069b4: 5b 8d 00 28 sw (sp+40),r13
80069b8: 5b 8e 00 24 sw (sp+36),r14
80069bc: 5b 8f 00 20 sw (sp+32),r15
80069c0: 5b 90 00 1c sw (sp+28),r16
80069c4: 5b 91 00 18 sw (sp+24),r17
80069c8: 5b 92 00 14 sw (sp+20),r18
80069cc: 5b 93 00 10 sw (sp+16),r19
80069d0: 5b 94 00 0c sw (sp+12),r20
80069d4: 5b 95 00 08 sw (sp+8),r21
80069d8: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
80069dc: 78 01 08 01 mvhi r1,0x801
80069e0: 38 21 9e 3c ori r1,r1,0x9e3c
80069e4: 28 2d 00 0c lw r13,(r1+12)
_ISR_Disable( level );
80069e8: 90 00 20 00 rcsr r4,IE
80069ec: 34 01 ff fe mvi r1,-2
80069f0: a0 81 08 00 and r1,r4,r1
80069f4: d0 01 00 00 wcsr IE,r1
while ( _Thread_Dispatch_necessary == true ) {
80069f8: 78 0c 08 01 mvhi r12,0x801
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
80069fc: 78 11 08 01 mvhi r17,0x801
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
8006a00: 78 0f 08 01 mvhi r15,0x801
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
8006a04: 78 0e 08 01 mvhi r14,0x801
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
8006a08: 78 10 08 01 mvhi r16,0x801
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
8006a0c: 39 8c 9e 3c ori r12,r12,0x9e3c
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
8006a10: 3a 31 99 90 ori r17,r17,0x9990
8006a14: 34 14 00 01 mvi r20,1
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
8006a18: 39 ef 99 28 ori r15,r15,0x9928
_ISR_Enable( level );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
8006a1c: 37 93 00 3c addi r19,sp,60
_Timestamp_Subtract(
8006a20: 39 ce 9a 3c ori r14,r14,0x9a3c
8006a24: 37 92 00 34 addi r18,sp,52
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
8006a28: 3a 10 9a 14 ori r16,r16,0x9a14
#endif
#endif
executing = _Thread_Executing;
_ISR_Disable( level );
8006a2c: 34 15 ff fe mvi r21,-2
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
8006a30: e0 00 00 28 bi 8006ad0 <_Thread_Dispatch+0x128>
heir = _Thread_Heir;
8006a34: 29 8b 00 10 lw r11,(r12+16)
_Thread_Dispatch_disable_level = 1;
8006a38: 5a 34 00 00 sw (r17+0),r20
_Thread_Dispatch_necessary = false;
8006a3c: 31 80 00 18 sb (r12+24),r0
_Thread_Executing = heir;
8006a40: 59 8b 00 0c sw (r12+12),r11
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
8006a44: 45 6d 00 26 be r11,r13,8006adc <_Thread_Dispatch+0x134>
*/
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
8006a48: 29 61 00 7c lw r1,(r11+124)
8006a4c: 5c 34 00 03 bne r1,r20,8006a58 <_Thread_Dispatch+0xb0>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
8006a50: 29 e1 00 00 lw r1,(r15+0)
8006a54: 59 61 00 78 sw (r11+120),r1
_ISR_Enable( level );
8006a58: d0 04 00 00 wcsr IE,r4
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
8006a5c: ba 60 08 00 mv r1,r19
8006a60: f8 00 1f 6e calli 800e818 <_TOD_Get_uptime>
_Timestamp_Subtract(
8006a64: b9 c0 08 00 mv r1,r14
8006a68: ba 60 10 00 mv r2,r19
8006a6c: ba 40 18 00 mv r3,r18
8006a70: f8 00 03 74 calli 8007840 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
8006a74: 35 a1 00 84 addi r1,r13,132
8006a78: ba 40 10 00 mv r2,r18
8006a7c: f8 00 03 58 calli 80077dc <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
8006a80: 2b 81 00 3c lw r1,(sp+60)
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
8006a84: 2a 04 00 00 lw r4,(r16+0)
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
8006a88: 59 c1 00 00 sw (r14+0),r1
8006a8c: 2b 81 00 40 lw r1,(sp+64)
8006a90: 59 c1 00 04 sw (r14+4),r1
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
8006a94: 44 80 00 05 be r4,r0,8006aa8 <_Thread_Dispatch+0x100> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
8006a98: 28 81 00 00 lw r1,(r4+0)
8006a9c: 59 a1 01 18 sw (r13+280),r1
*_Thread_libc_reent = heir->libc_reent;
8006aa0: 29 61 01 18 lw r1,(r11+280)
8006aa4: 58 81 00 00 sw (r4+0),r1
}
_User_extensions_Thread_switch( executing, heir );
8006aa8: b9 a0 08 00 mv r1,r13
8006aac: b9 60 10 00 mv r2,r11
8006ab0: f8 00 04 43 calli 8007bbc <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
8006ab4: 35 a1 00 c4 addi r1,r13,196
8006ab8: 35 62 00 c4 addi r2,r11,196
8006abc: f8 00 05 23 calli 8007f48 <_CPU_Context_switch>
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
8006ac0: 29 8d 00 0c lw r13,(r12+12)
_ISR_Disable( level );
8006ac4: 90 00 20 00 rcsr r4,IE
8006ac8: a0 95 08 00 and r1,r4,r21
8006acc: d0 01 00 00 wcsr IE,r1
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
8006ad0: 41 81 00 18 lbu r1,(r12+24)
8006ad4: 20 21 00 ff andi r1,r1,0xff
8006ad8: 5c 20 ff d7 bne r1,r0,8006a34 <_Thread_Dispatch+0x8c>
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
8006adc: 78 01 08 01 mvhi r1,0x801
8006ae0: 38 21 99 90 ori r1,r1,0x9990
8006ae4: 58 20 00 00 sw (r1+0),r0
_ISR_Enable( level );
8006ae8: d0 04 00 00 wcsr IE,r4
_API_extensions_Run_postswitch();
8006aec: fb ff f7 ce calli 8004a24 <_API_extensions_Run_postswitch>
}
8006af0: 2b 9d 00 04 lw ra,(sp+4)
8006af4: 2b 8b 00 30 lw r11,(sp+48)
8006af8: 2b 8c 00 2c lw r12,(sp+44)
8006afc: 2b 8d 00 28 lw r13,(sp+40)
8006b00: 2b 8e 00 24 lw r14,(sp+36)
8006b04: 2b 8f 00 20 lw r15,(sp+32)
8006b08: 2b 90 00 1c lw r16,(sp+28)
8006b0c: 2b 91 00 18 lw r17,(sp+24)
8006b10: 2b 92 00 14 lw r18,(sp+20)
8006b14: 2b 93 00 10 lw r19,(sp+16)
8006b18: 2b 94 00 0c lw r20,(sp+12)
8006b1c: 2b 95 00 08 lw r21,(sp+8)
8006b20: 37 9c 00 40 addi sp,sp,64
8006b24: c3 a0 00 00 ret
080111ec <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
80111ec: 37 9c ff f4 addi sp,sp,-12
80111f0: 5b 8b 00 0c sw (sp+12),r11
80111f4: 5b 8c 00 08 sw (sp+8),r12
80111f8: 5b 9d 00 04 sw (sp+4),ra
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
80111fc: 78 01 08 01 mvhi r1,0x801
8011200: 38 21 9e 3c ori r1,r1,0x9e3c
8011204: 28 2b 00 0c lw r11,(r1+12)
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
8011208: 29 61 00 ac lw r1,(r11+172)
_ISR_Set_level(level);
801120c: 64 21 00 00 cmpei r1,r1,0
8011210: d0 01 00 00 wcsr IE,r1
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
8011214: 78 01 08 01 mvhi r1,0x801
8011218: 38 21 97 ec ori r1,r1,0x97ec
801121c: 40 2c 00 00 lbu r12,(r1+0)
doneConstructors = 1;
8011220: 34 02 00 01 mvi r2,1
8011224: 30 22 00 00 sb (r1+0),r2
/*
* Take care that 'begin' extensions get to complete before
* 'switch' extensions can run. This means must keep dispatch
* disabled until all 'begin' extensions complete.
*/
_User_extensions_Thread_begin( executing );
8011228: b9 60 08 00 mv r1,r11
801122c: fb ff d9 d8 calli 800798c <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
8011230: fb ff d6 3e calli 8006b28 <_Thread_Enable_dispatch>
/*
* _init could be a weak symbol and we SHOULD test it but it isn't
* in any configuration I know of and it generates a warning on every
* RTEMS target configuration. --joel (12 May 2007)
*/
if (!doneCons) /* && (volatile void *)_init) */ {
8011234: 5d 80 00 02 bne r12,r0,801123c <_Thread_Handler+0x50>
INIT_NAME ();
8011238: fb ff bb 72 calli 8000000 <RamBase>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
801123c: 29 61 00 94 lw r1,(r11+148)
8011240: 5c 20 00 04 bne r1,r0,8011250 <_Thread_Handler+0x64>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
8011244: 29 62 00 90 lw r2,(r11+144)
8011248: 29 61 00 9c lw r1,(r11+156)
801124c: e0 00 00 05 bi 8011260 <_Thread_Handler+0x74>
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
8011250: 34 02 00 01 mvi r2,1
8011254: 5c 22 00 05 bne r1,r2,8011268 <_Thread_Handler+0x7c> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
8011258: 29 62 00 90 lw r2,(r11+144)
801125c: 29 61 00 98 lw r1,(r11+152)
8011260: d8 40 00 00 call r2
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
8011264: 59 61 00 28 sw (r11+40),r1
* was placed in return_argument. This assumed that if it returned
* anything (which is not supporting in all APIs), then it would be
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
8011268: b9 60 08 00 mv r1,r11
801126c: fb ff d9 e0 calli 80079ec <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
8011270: 34 01 00 00 mvi r1,0
8011274: 34 02 00 01 mvi r2,1
8011278: 34 03 00 05 mvi r3,5
801127c: fb ff d0 cf calli 80055b8 <_Internal_error_Occurred>
0800bda4 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
800bda4: 37 9c ff f8 addi sp,sp,-8
800bda8: 5b 8b 00 08 sw (sp+8),r11
800bdac: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *executing;
executing = _Thread_Executing;
800bdb0: 78 01 08 01 mvhi r1,0x801
800bdb4: 38 21 ae ec ori r1,r1,0xaeec
800bdb8: 28 2b 00 0c lw r11,(r1+12)
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
800bdbc: 41 61 00 74 lbu r1,(r11+116)
800bdc0: 44 20 00 1e be r1,r0,800be38 <_Thread_Tickle_timeslice+0x94>
return;
if ( !_States_Is_ready( executing->current_state ) )
800bdc4: 29 61 00 10 lw r1,(r11+16)
800bdc8: 5c 20 00 1c bne r1,r0,800be38 <_Thread_Tickle_timeslice+0x94>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
800bdcc: 29 61 00 7c lw r1,(r11+124)
800bdd0: 44 20 00 1a be r1,r0,800be38 <_Thread_Tickle_timeslice+0x94>
800bdd4: 34 02 00 02 mvi r2,2
800bdd8: 50 41 00 04 bgeu r2,r1,800bde8 <_Thread_Tickle_timeslice+0x44>
800bddc: 34 02 00 03 mvi r2,3
800bde0: 5c 22 00 16 bne r1,r2,800be38 <_Thread_Tickle_timeslice+0x94><== NEVER TAKEN
800bde4: e0 00 00 0e bi 800be1c <_Thread_Tickle_timeslice+0x78>
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
#endif
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
800bde8: 29 61 00 78 lw r1,(r11+120)
800bdec: 34 21 ff ff addi r1,r1,-1
800bdf0: 59 61 00 78 sw (r11+120),r1
800bdf4: 48 20 00 11 bg r1,r0,800be38 <_Thread_Tickle_timeslice+0x94>
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
800bdf8: 78 01 08 01 mvhi r1,0x801
800bdfc: 38 21 a0 1c ori r1,r1,0xa01c
800be00: 28 21 00 0c lw r1,(r1+12)
800be04: d8 20 00 00 call r1
* executing thread's timeslice is reset. Otherwise, the
* currently executing thread is placed at the rear of the
* FIFO for this priority and a new heir is selected.
*/
_Scheduler_Yield( );
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
800be08: 78 01 08 01 mvhi r1,0x801
800be0c: 38 21 a9 d8 ori r1,r1,0xa9d8
800be10: 28 21 00 00 lw r1,(r1+0)
800be14: 59 61 00 78 sw (r11+120),r1
800be18: e0 00 00 08 bi 800be38 <_Thread_Tickle_timeslice+0x94>
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
800be1c: 29 61 00 78 lw r1,(r11+120)
800be20: 34 21 ff ff addi r1,r1,-1
800be24: 59 61 00 78 sw (r11+120),r1
800be28: 5c 20 00 04 bne r1,r0,800be38 <_Thread_Tickle_timeslice+0x94>
(*executing->budget_callout)( executing );
800be2c: 29 62 00 80 lw r2,(r11+128)
800be30: b9 60 08 00 mv r1,r11
800be34: d8 40 00 00 call r2
break;
#endif
}
}
800be38: 2b 9d 00 04 lw ra,(sp+4)
800be3c: 2b 8b 00 08 lw r11,(sp+8)
800be40: 37 9c 00 08 addi sp,sp,8
800be44: c3 a0 00 00 ret
0800718c <_Thread_queue_Enqueue_priority>:
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
800718c: 37 9c ff cc addi sp,sp,-52
8007190: 5b 8b 00 34 sw (sp+52),r11
8007194: 5b 8c 00 30 sw (sp+48),r12
8007198: 5b 8d 00 2c sw (sp+44),r13
800719c: 5b 8e 00 28 sw (sp+40),r14
80071a0: 5b 8f 00 24 sw (sp+36),r15
80071a4: 5b 90 00 20 sw (sp+32),r16
80071a8: 5b 91 00 1c sw (sp+28),r17
80071ac: 5b 92 00 18 sw (sp+24),r18
80071b0: 5b 93 00 14 sw (sp+20),r19
80071b4: 5b 94 00 10 sw (sp+16),r20
80071b8: 5b 95 00 0c sw (sp+12),r21
80071bc: 5b 96 00 08 sw (sp+8),r22
80071c0: 5b 9d 00 04 sw (sp+4),ra
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
80071c4: 28 50 00 14 lw r16,(r2+20)
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
80071c8: b8 20 68 00 mv r13,r1
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 );
80071cc: 34 41 00 3c addi r1,r2,60
head->next = tail;
80071d0: 58 41 00 38 sw (r2+56),r1
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
80071d4: 34 41 00 38 addi r1,r2,56
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
80071d8: 58 41 00 40 sw (r2+64),r1
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
80071dc: 58 40 00 3c sw (r2+60),r0
80071e0: b8 40 60 00 mv r12,r2
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
80071e4: ba 00 08 00 mv r1,r16
80071e8: 34 02 00 06 mvi r2,6
80071ec: b8 60 a8 00 mv r21,r3
80071f0: f8 00 3f 96 calli 8017048 <__lshrsi3>
80071f4: b8 20 70 00 mv r14,r1
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
80071f8: 78 12 08 01 mvhi r18,0x801
RTEMS_INLINE_ROUTINE bool _Thread_queue_Is_reverse_search (
Priority_Control the_priority
)
{
return ( the_priority & TASK_QUEUE_DATA_REVERSE_SEARCH_MASK );
80071fc: 22 01 00 20 andi r1,r16,0x20
_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;
8007200: 29 b3 00 38 lw r19,(r13+56)
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
8007204: 3a 52 90 d8 ori r18,r18,0x90d8
_ISR_Disable( level );
8007208: 34 16 ff fe mvi r22,-2
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 ) )
800720c: 5c 20 00 30 bne r1,r0,80072cc <_Thread_queue_Enqueue_priority+0x140>
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
8007210: 34 14 ff fe mvi r20,-2
8007214: 90 00 78 00 rcsr r15,IE
8007218: a1 f4 90 00 and r18,r15,r20
800721c: d0 12 00 00 wcsr IE,r18
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
8007220: 34 02 00 01 mvi r2,1
8007224: b9 c0 08 00 mv r1,r14
8007228: f8 00 3f 3a calli 8016f10 <__ashlsi3>
800722c: b4 2e 08 00 add r1,r1,r14
8007230: 34 02 00 02 mvi r2,2
8007234: f8 00 3f 37 calli 8016f10 <__ashlsi3>
8007238: b5 a1 08 00 add r1,r13,r1
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
800723c: 28 2b 00 00 lw r11,(r1+0)
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
8007240: 34 11 ff ff mvi r17,-1
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
8007244: e0 00 00 0b bi 8007270 <_Thread_queue_Enqueue_priority+0xe4>
search_priority = search_thread->current_priority;
8007248: 29 71 00 14 lw r17,(r11+20)
if ( priority <= search_priority )
800724c: 52 30 00 12 bgeu r17,r16,8007294 <_Thread_queue_Enqueue_priority+0x108>
break;
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
8007250: d0 0f 00 00 wcsr IE,r15
8007254: d0 12 00 00 wcsr IE,r18
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
8007258: 29 61 00 10 lw r1,(r11+16)
800725c: a2 61 08 00 and r1,r19,r1
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
8007260: 5c 20 00 03 bne r1,r0,800726c <_Thread_queue_Enqueue_priority+0xe0><== ALWAYS TAKEN
_ISR_Enable( level );
8007264: d0 0f 00 00 wcsr IE,r15 <== NOT EXECUTED
goto restart_forward_search;
8007268: e3 ff ff eb bi 8007214 <_Thread_queue_Enqueue_priority+0x88><== NOT EXECUTED
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
800726c: 29 6b 00 00 lw r11,(r11+0)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
8007270: 34 02 00 01 mvi r2,1
8007274: b9 c0 08 00 mv r1,r14
8007278: f8 00 3f 26 calli 8016f10 <__ashlsi3>
800727c: b4 2e 08 00 add r1,r1,r14
8007280: 34 02 00 02 mvi r2,2
8007284: f8 00 3f 23 calli 8016f10 <__ashlsi3>
8007288: b5 a1 08 00 add r1,r13,r1
800728c: 34 21 00 04 addi r1,r1,4
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 ) ) {
8007290: 5d 61 ff ee bne r11,r1,8007248 <_Thread_queue_Enqueue_priority+0xbc>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
8007294: 29 a3 00 30 lw r3,(r13+48)
8007298: 34 02 00 01 mvi r2,1
800729c: b9 e0 08 00 mv r1,r15
80072a0: 5c 62 00 43 bne r3,r2,80073ac <_Thread_queue_Enqueue_priority+0x220>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
80072a4: 59 a0 00 30 sw (r13+48),r0
if ( priority == search_priority )
80072a8: 46 11 00 38 be r16,r17,8007388 <_Thread_queue_Enqueue_priority+0x1fc>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
80072ac: 29 61 00 04 lw r1,(r11+4)
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
80072b0: 59 8b 00 00 sw (r12+0),r11
the_node->previous = previous_node;
80072b4: 59 81 00 04 sw (r12+4),r1
previous_node->next = the_node;
80072b8: 58 2c 00 00 sw (r1+0),r12
search_node->previous = the_node;
80072bc: 59 6c 00 04 sw (r11+4),r12
the_thread->Wait.queue = the_thread_queue;
80072c0: 59 8d 00 44 sw (r12+68),r13
_ISR_Enable( level );
80072c4: d0 0f 00 00 wcsr IE,r15
80072c8: e0 00 00 2e bi 8007380 <_Thread_queue_Enqueue_priority+0x1f4>
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
80072cc: 42 51 00 00 lbu r17,(r18+0)
80072d0: 36 31 00 01 addi r17,r17,1
_ISR_Disable( level );
80072d4: 90 00 78 00 rcsr r15,IE
80072d8: a1 f6 a0 00 and r20,r15,r22
80072dc: d0 14 00 00 wcsr IE,r20
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
80072e0: 34 02 00 01 mvi r2,1
80072e4: b9 c0 08 00 mv r1,r14
80072e8: f8 00 3f 0a calli 8016f10 <__ashlsi3>
80072ec: b4 2e 08 00 add r1,r1,r14
80072f0: 34 02 00 02 mvi r2,2
80072f4: f8 00 3f 07 calli 8016f10 <__ashlsi3>
80072f8: b5 a1 08 00 add r1,r13,r1
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
80072fc: 28 2b 00 08 lw r11,(r1+8)
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
8007300: e0 00 00 0b bi 800732c <_Thread_queue_Enqueue_priority+0x1a0>
search_priority = search_thread->current_priority;
8007304: 29 71 00 14 lw r17,(r11+20)
if ( priority >= search_priority )
8007308: 52 11 00 11 bgeu r16,r17,800734c <_Thread_queue_Enqueue_priority+0x1c0>
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
800730c: d0 0f 00 00 wcsr IE,r15
8007310: d0 14 00 00 wcsr IE,r20
8007314: 29 61 00 10 lw r1,(r11+16)
8007318: a2 61 08 00 and r1,r19,r1
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
800731c: 5c 20 00 03 bne r1,r0,8007328 <_Thread_queue_Enqueue_priority+0x19c><== ALWAYS TAKEN
_ISR_Enable( level );
8007320: d0 0f 00 00 wcsr IE,r15 <== NOT EXECUTED
goto restart_reverse_search;
8007324: e3 ff ff ea bi 80072cc <_Thread_queue_Enqueue_priority+0x140><== NOT EXECUTED
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
8007328: 29 6b 00 04 lw r11,(r11+4)
RTEMS_INLINE_ROUTINE bool _Chain_Is_head(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Head(the_chain));
800732c: 34 02 00 01 mvi r2,1
8007330: b9 c0 08 00 mv r1,r14
8007334: f8 00 3e f7 calli 8016f10 <__ashlsi3>
8007338: b4 2e 08 00 add r1,r1,r14
800733c: 34 02 00 02 mvi r2,2
8007340: f8 00 3e f4 calli 8016f10 <__ashlsi3>
8007344: b5 a1 08 00 add r1,r13,r1
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 ) ) {
8007348: 5d 61 ff ef bne r11,r1,8007304 <_Thread_queue_Enqueue_priority+0x178>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
800734c: 29 a3 00 30 lw r3,(r13+48)
8007350: 34 02 00 01 mvi r2,1
8007354: b9 e0 08 00 mv r1,r15
8007358: 5c 62 00 15 bne r3,r2,80073ac <_Thread_queue_Enqueue_priority+0x220><== NEVER TAKEN
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
800735c: 59 a0 00 30 sw (r13+48),r0
if ( priority == search_priority )
8007360: 46 11 00 0a be r16,r17,8007388 <_Thread_queue_Enqueue_priority+0x1fc>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
8007364: 29 61 00 00 lw r1,(r11+0)
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
8007368: 59 8b 00 04 sw (r12+4),r11
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
800736c: 59 81 00 00 sw (r12+0),r1
the_node->previous = search_node;
search_node->next = the_node;
8007370: 59 6c 00 00 sw (r11+0),r12
next_node->previous = the_node;
8007374: 58 2c 00 04 sw (r1+4),r12
the_thread->Wait.queue = the_thread_queue;
8007378: 59 8d 00 44 sw (r12+68),r13
_ISR_Enable( level );
800737c: d0 0f 00 00 wcsr IE,r15
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
8007380: 34 01 00 01 mvi r1,1
8007384: e0 00 00 0c bi 80073b4 <_Thread_queue_Enqueue_priority+0x228>
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
8007388: 29 61 00 40 lw r1,(r11+64)
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 );
800738c: 35 62 00 3c addi r2,r11,60
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
8007390: 59 82 00 00 sw (r12+0),r2
the_node->previous = previous_node;
8007394: 59 81 00 04 sw (r12+4),r1
previous_node->next = the_node;
8007398: 58 2c 00 00 sw (r1+0),r12
search_node->previous = the_node;
800739c: 59 6c 00 40 sw (r11+64),r12
the_thread->Wait.queue = the_thread_queue;
80073a0: 59 8d 00 44 sw (r12+68),r13
_ISR_Enable( level );
80073a4: d0 0f 00 00 wcsr IE,r15
80073a8: e3 ff ff f6 bi 8007380 <_Thread_queue_Enqueue_priority+0x1f4>
* 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;
80073ac: 5a a1 00 00 sw (r21+0),r1
return the_thread_queue->sync_state;
80073b0: 29 a1 00 30 lw r1,(r13+48)
}
80073b4: 2b 9d 00 04 lw ra,(sp+4)
80073b8: 2b 8b 00 34 lw r11,(sp+52)
80073bc: 2b 8c 00 30 lw r12,(sp+48)
80073c0: 2b 8d 00 2c lw r13,(sp+44)
80073c4: 2b 8e 00 28 lw r14,(sp+40)
80073c8: 2b 8f 00 24 lw r15,(sp+36)
80073cc: 2b 90 00 20 lw r16,(sp+32)
80073d0: 2b 91 00 1c lw r17,(sp+28)
80073d4: 2b 92 00 18 lw r18,(sp+24)
80073d8: 2b 93 00 14 lw r19,(sp+20)
80073dc: 2b 94 00 10 lw r20,(sp+16)
80073e0: 2b 95 00 0c lw r21,(sp+12)
80073e4: 2b 96 00 08 lw r22,(sp+8)
80073e8: 37 9c 00 34 addi sp,sp,52
80073ec: c3 a0 00 00 ret
0800f3b8 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
800f3b8: 37 9c ff fc addi sp,sp,-4
800f3bc: 5b 9d 00 04 sw (sp+4),ra
800f3c0: b8 20 10 00 mv r2,r1
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
800f3c4: 28 21 00 44 lw r1,(r1+68)
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
800f3c8: 28 24 00 30 lw r4,(r1+48)
800f3cc: 44 80 00 0c be r4,r0,800f3fc <_Thread_queue_Process_timeout+0x44>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
800f3d0: 78 03 08 01 mvhi r3,0x801
800f3d4: 38 63 9e 3c ori r3,r3,0x9e3c
800f3d8: 28 63 00 0c lw r3,(r3+12)
800f3dc: 5c 43 00 08 bne r2,r3,800f3fc <_Thread_queue_Process_timeout+0x44><== NEVER TAKEN
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
800f3e0: 34 03 00 03 mvi r3,3
800f3e4: 44 83 00 09 be r4,r3,800f408 <_Thread_queue_Process_timeout+0x50><== ALWAYS TAKEN
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
800f3e8: 28 23 00 3c lw r3,(r1+60) <== NOT EXECUTED
800f3ec: 58 43 00 34 sw (r2+52),r3 <== NOT EXECUTED
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
800f3f0: 34 02 00 02 mvi r2,2 <== NOT EXECUTED
800f3f4: 58 22 00 30 sw (r1+48),r2 <== NOT EXECUTED
800f3f8: e0 00 00 04 bi 800f408 <_Thread_queue_Process_timeout+0x50><== NOT EXECUTED
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
800f3fc: 28 23 00 3c lw r3,(r1+60)
800f400: 58 43 00 34 sw (r2+52),r3
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
800f404: f8 00 07 9f calli 8011280 <_Thread_queue_Extract>
}
}
800f408: 2b 9d 00 04 lw ra,(sp+4)
800f40c: 37 9c 00 04 addi sp,sp,4
800f410: c3 a0 00 00 ret
080074dc <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
80074dc: 37 9c ff ec addi sp,sp,-20
80074e0: 5b 8b 00 10 sw (sp+16),r11
80074e4: 5b 8c 00 0c sw (sp+12),r12
80074e8: 5b 8d 00 08 sw (sp+8),r13
80074ec: 5b 9d 00 04 sw (sp+4),ra
80074f0: b8 20 58 00 mv r11,r1
80074f4: b8 40 60 00 mv r12,r2
/*
* Just in case the thread really wasn't blocked on a thread queue
* when we get here.
*/
if ( !the_thread_queue )
80074f8: 44 20 00 19 be r1,r0,800755c <_Thread_queue_Requeue+0x80> <== NEVER TAKEN
/*
* If queueing by FIFO, there is nothing to do. This only applies to
* priority blocking discipline.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
80074fc: 28 22 00 34 lw r2,(r1+52)
8007500: 34 01 00 01 mvi r1,1
8007504: 5c 41 00 16 bne r2,r1,800755c <_Thread_queue_Requeue+0x80> <== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
8007508: 90 00 68 00 rcsr r13,IE
800750c: 34 01 ff fe mvi r1,-2
8007510: a1 a1 08 00 and r1,r13,r1
8007514: d0 01 00 00 wcsr IE,r1
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
8007518: 78 03 08 01 mvhi r3,0x801
800751c: 38 63 81 6c ori r3,r3,0x816c
8007520: 29 82 00 10 lw r2,(r12+16)
8007524: 28 61 00 00 lw r1,(r3+0)
8007528: a0 41 08 00 and r1,r2,r1
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
800752c: 44 20 00 0b be r1,r0,8007558 <_Thread_queue_Requeue+0x7c> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
8007530: 34 01 00 01 mvi r1,1
8007534: 59 61 00 30 sw (r11+48),r1
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
8007538: b9 80 10 00 mv r2,r12
800753c: b9 60 08 00 mv r1,r11
8007540: 34 03 00 01 mvi r3,1
8007544: f8 00 1f 4f calli 800f280 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
8007548: b9 60 08 00 mv r1,r11
800754c: b9 80 10 00 mv r2,r12
8007550: 37 83 00 14 addi r3,sp,20
8007554: fb ff ff 0e calli 800718c <_Thread_queue_Enqueue_priority>
}
_ISR_Enable( level );
8007558: d0 0d 00 00 wcsr IE,r13
}
}
800755c: 2b 9d 00 04 lw ra,(sp+4)
8007560: 2b 8b 00 10 lw r11,(sp+16)
8007564: 2b 8c 00 0c lw r12,(sp+12)
8007568: 2b 8d 00 08 lw r13,(sp+8)
800756c: 37 9c 00 14 addi sp,sp,20
8007570: c3 a0 00 00 ret
08007574 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
8007574: 37 9c ff f8 addi sp,sp,-8
8007578: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
800757c: 37 82 00 08 addi r2,sp,8
8007580: fb ff fd 77 calli 8006b5c <_Thread_Get>
switch ( location ) {
8007584: 2b 82 00 08 lw r2,(sp+8)
8007588: 5c 40 00 07 bne r2,r0,80075a4 <_Thread_queue_Timeout+0x30> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
800758c: f8 00 1f 8b calli 800f3b8 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
8007590: 78 01 08 01 mvhi r1,0x801
8007594: 38 21 99 90 ori r1,r1,0x9990
8007598: 28 22 00 00 lw r2,(r1+0)
800759c: 34 42 ff ff addi r2,r2,-1
80075a0: 58 22 00 00 sw (r1+0),r2
_Thread_Unnest_dispatch();
break;
}
}
80075a4: 2b 9d 00 04 lw ra,(sp+4)
80075a8: 37 9c 00 08 addi sp,sp,8
80075ac: c3 a0 00 00 ret
0801478c <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
801478c: 37 9c ff a8 addi sp,sp,-88
8014790: 5b 8b 00 40 sw (sp+64),r11
8014794: 5b 8c 00 3c sw (sp+60),r12
8014798: 5b 8d 00 38 sw (sp+56),r13
801479c: 5b 8e 00 34 sw (sp+52),r14
80147a0: 5b 8f 00 30 sw (sp+48),r15
80147a4: 5b 90 00 2c sw (sp+44),r16
80147a8: 5b 91 00 28 sw (sp+40),r17
80147ac: 5b 92 00 24 sw (sp+36),r18
80147b0: 5b 93 00 20 sw (sp+32),r19
80147b4: 5b 94 00 1c sw (sp+28),r20
80147b8: 5b 95 00 18 sw (sp+24),r21
80147bc: 5b 96 00 14 sw (sp+20),r22
80147c0: 5b 97 00 10 sw (sp+16),r23
80147c4: 5b 98 00 0c sw (sp+12),r24
80147c8: 5b 99 00 08 sw (sp+8),r25
80147cc: 5b 9d 00 04 sw (sp+4),ra
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
80147d0: 78 10 08 04 mvhi r16,0x804
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
80147d4: b8 20 58 00 mv r11,r1
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
80147d8: 37 82 00 54 addi r2,sp,84
80147dc: 37 81 00 50 addi r1,sp,80
80147e0: 37 8f 00 44 addi r15,sp,68
80147e4: 37 91 00 48 addi r17,sp,72
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
80147e8: 78 0e 08 04 mvhi r14,0x804
80147ec: 5b 82 00 50 sw (sp+80),r2
head->previous = NULL;
80147f0: 5b 80 00 54 sw (sp+84),r0
tail->previous = head;
80147f4: 5b 81 00 58 sw (sp+88),r1
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
80147f8: 5b 91 00 44 sw (sp+68),r17
head->previous = NULL;
80147fc: 5b 80 00 48 sw (sp+72),r0
tail->previous = head;
8014800: 5b 8f 00 4c sw (sp+76),r15
{
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
8014804: b8 20 c8 00 mv r25,r1
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
8014808: 3a 10 0e 20 ori r16,r16,0xe20
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
801480c: 35 73 00 30 addi r19,r11,48
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
8014810: 39 ce 0d 98 ori r14,r14,0xd98
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
8014814: 35 6d 00 68 addi r13,r11,104
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
8014818: 34 18 00 03 mvi r24,3
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
801481c: 34 12 ff fe mvi r18,-2
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
8014820: b8 40 b8 00 mv r23,r2
_Thread_Set_state( ts->thread, STATES_DELAYING );
_Timer_server_Reset_interval_system_watchdog( ts );
_Timer_server_Reset_tod_system_watchdog( ts );
_Thread_Enable_dispatch();
ts->active = true;
8014824: 34 16 00 01 mvi r22,1
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
8014828: 35 75 00 08 addi r21,r11,8
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
801482c: 35 74 00 40 addi r20,r11,64
{
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
8014830: 59 79 00 78 sw (r11+120),r25
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
8014834: 2a 02 00 00 lw r2,(r16+0)
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
8014838: 29 63 00 3c lw r3,(r11+60)
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
801483c: ba 60 08 00 mv r1,r19
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
8014840: 59 62 00 3c sw (r11+60),r2
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
8014844: c8 43 10 00 sub r2,r2,r3
8014848: b9 e0 18 00 mv r3,r15
801484c: f8 00 15 aa calli 8019ef4 <_Watchdog_Adjust_to_chain>
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
8014850: 29 64 00 74 lw r4,(r11+116)
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
8014854: 29 cc 00 00 lw r12,(r14+0)
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
8014858: 50 8c 00 06 bgeu r4,r12,8014870 <_Timer_server_Body+0xe4>
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
801485c: b9 a0 08 00 mv r1,r13
8014860: c9 84 10 00 sub r2,r12,r4
8014864: b9 e0 18 00 mv r3,r15
8014868: f8 00 15 a3 calli 8019ef4 <_Watchdog_Adjust_to_chain>
801486c: e0 00 00 06 bi 8014884 <_Timer_server_Body+0xf8>
} else if ( snapshot < last_snapshot ) {
8014870: 51 84 00 05 bgeu r12,r4,8014884 <_Timer_server_Body+0xf8>
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
8014874: b9 a0 08 00 mv r1,r13
8014878: 34 02 00 01 mvi r2,1
801487c: c8 8c 18 00 sub r3,r4,r12
8014880: f8 00 15 66 calli 8019e18 <_Watchdog_Adjust>
}
watchdogs->last_snapshot = snapshot;
8014884: 59 6c 00 74 sw (r11+116),r12
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
8014888: 34 0c 00 01 mvi r12,1
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
801488c: 29 63 00 78 lw r3,(r11+120)
8014890: b8 60 08 00 mv r1,r3
8014894: f8 00 03 7e calli 801568c <_Chain_Get>
8014898: b8 20 10 00 mv r2,r1
if ( timer == NULL ) {
801489c: 44 20 00 09 be r1,r0,80148c0 <_Timer_server_Body+0x134> <== ALWAYS TAKEN
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
80148a0: 28 23 00 38 lw r3,(r1+56) <== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
80148a4: ba 60 08 00 mv r1,r19 <== NOT EXECUTED
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
80148a8: 44 6c 00 03 be r3,r12,80148b4 <_Timer_server_Body+0x128> <== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
80148ac: 5c 78 ff f8 bne r3,r24,801488c <_Timer_server_Body+0x100> <== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
80148b0: b9 a0 08 00 mv r1,r13 <== NOT EXECUTED
80148b4: 34 42 00 10 addi r2,r2,16 <== NOT EXECUTED
80148b8: f8 00 15 b4 calli 8019f88 <_Watchdog_Insert> <== NOT EXECUTED
80148bc: e3 ff ff f4 bi 801488c <_Timer_server_Body+0x100> <== NOT EXECUTED
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
80148c0: 90 00 10 00 rcsr r2,IE
80148c4: a0 52 08 00 and r1,r2,r18
80148c8: d0 01 00 00 wcsr IE,r1
if ( _Chain_Is_empty( insert_chain ) ) {
80148cc: 2b 81 00 50 lw r1,(sp+80)
80148d0: 5c 37 00 06 bne r1,r23,80148e8 <_Timer_server_Body+0x15c> <== NEVER TAKEN
ts->insert_chain = NULL;
80148d4: 59 60 00 78 sw (r11+120),r0
_ISR_Enable( level );
80148d8: d0 02 00 00 wcsr IE,r2
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
80148dc: 2b 81 00 44 lw r1,(sp+68)
80148e0: 5c 31 00 04 bne r1,r17,80148f0 <_Timer_server_Body+0x164>
80148e4: e0 00 00 15 bi 8014938 <_Timer_server_Body+0x1ac>
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
80148e8: d0 02 00 00 wcsr IE,r2 <== NOT EXECUTED
80148ec: e3 ff ff d2 bi 8014834 <_Timer_server_Body+0xa8> <== NOT EXECUTED
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
80148f0: 90 00 18 00 rcsr r3,IE
80148f4: a0 72 08 00 and r1,r3,r18
80148f8: d0 01 00 00 wcsr IE,r1
initialized = false;
}
#endif
return status;
}
80148fc: 2b 82 00 44 lw r2,(sp+68)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
8014900: 44 51 00 0c be r2,r17,8014930 <_Timer_server_Body+0x1a4>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
8014904: 28 44 00 00 lw r4,(r2+0)
head->next = new_first;
8014908: 5b 84 00 44 sw (sp+68),r4
new_first->previous = head;
801490c: 58 8f 00 04 sw (r4+4),r15
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
8014910: 44 40 00 08 be r2,r0,8014930 <_Timer_server_Body+0x1a4> <== NEVER TAKEN
watchdog->state = WATCHDOG_INACTIVE;
8014914: 58 40 00 08 sw (r2+8),r0
_ISR_Enable( level );
8014918: d0 03 00 00 wcsr IE,r3
/*
* The timer server may block here and wait for resources or time.
* The system watchdogs are inactive and will remain inactive since
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
801491c: 28 43 00 1c lw r3,(r2+28)
8014920: 28 41 00 20 lw r1,(r2+32)
8014924: 28 42 00 24 lw r2,(r2+36)
8014928: d8 60 00 00 call r3
}
801492c: e3 ff ff f1 bi 80148f0 <_Timer_server_Body+0x164>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
8014930: d0 03 00 00 wcsr IE,r3
8014934: e3 ff ff bf bi 8014830 <_Timer_server_Body+0xa4>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
8014938: 31 60 00 7c sb (r11+124),r0
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
801493c: fb ff ff 54 calli 801468c <_Thread_Disable_dispatch>
_Thread_Set_state( ts->thread, STATES_DELAYING );
8014940: 29 61 00 00 lw r1,(r11+0)
8014944: 34 02 00 08 mvi r2,8
8014948: f8 00 13 28 calli 80195e8 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
801494c: b9 60 08 00 mv r1,r11
8014950: fb ff ff 55 calli 80146a4 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
8014954: b9 60 08 00 mv r1,r11
8014958: fb ff ff 70 calli 8014718 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
801495c: f8 00 10 46 calli 8018a74 <_Thread_Enable_dispatch>
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
8014960: ba a0 08 00 mv r1,r21
_Thread_Set_state( ts->thread, STATES_DELAYING );
_Timer_server_Reset_interval_system_watchdog( ts );
_Timer_server_Reset_tod_system_watchdog( ts );
_Thread_Enable_dispatch();
ts->active = true;
8014964: 31 76 00 7c sb (r11+124),r22
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
8014968: f8 00 15 e7 calli 801a104 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
801496c: ba 80 08 00 mv r1,r20
8014970: f8 00 15 e5 calli 801a104 <_Watchdog_Remove>
8014974: e3 ff ff af bi 8014830 <_Timer_server_Body+0xa4>
08014978 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
8014978: 37 9c ff f4 addi sp,sp,-12
801497c: 5b 8b 00 0c sw (sp+12),r11
8014980: 5b 8c 00 08 sw (sp+8),r12
8014984: 5b 9d 00 04 sw (sp+4),ra
8014988: b8 20 58 00 mv r11,r1
if ( ts->insert_chain == NULL ) {
801498c: 28 21 00 78 lw r1,(r1+120)
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
8014990: b8 40 60 00 mv r12,r2
if ( ts->insert_chain == NULL ) {
8014994: 5c 20 00 43 bne r1,r0,8014aa0 <_Timer_server_Schedule_operation_method+0x128><== NEVER TAKEN
* is the reference point for the delta chain. Thus if we do not update the
* reference point we have to add DT to the initial delta of the watchdog
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
8014998: fb ff ff 3d calli 801468c <_Thread_Disable_dispatch>
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
801499c: 29 81 00 38 lw r1,(r12+56)
80149a0: 34 02 00 01 mvi r2,1
80149a4: 5c 22 00 1d bne r1,r2,8014a18 <_Timer_server_Schedule_operation_method+0xa0>
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
80149a8: 90 00 10 00 rcsr r2,IE
80149ac: 34 01 ff fe mvi r1,-2
80149b0: a0 41 08 00 and r1,r2,r1
80149b4: d0 01 00 00 wcsr IE,r1
snapshot = _Watchdog_Ticks_since_boot;
80149b8: 78 01 08 04 mvhi r1,0x804
80149bc: 38 21 0e 20 ori r1,r1,0xe20
80149c0: 28 23 00 00 lw r3,(r1+0)
initialized = false;
}
#endif
return status;
}
80149c4: 29 61 00 30 lw r1,(r11+48)
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = _Watchdog_Ticks_since_boot;
last_snapshot = ts->Interval_watchdogs.last_snapshot;
80149c8: 29 65 00 3c lw r5,(r11+60)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
80149cc: 35 64 00 34 addi r4,r11,52
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
80149d0: 44 24 00 07 be r1,r4,80149ec <_Timer_server_Schedule_operation_method+0x74>
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
80149d4: 28 26 00 10 lw r6,(r1+16)
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
80149d8: c8 65 28 00 sub r5,r3,r5
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
80149dc: 34 04 00 00 mvi r4,0
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
80149e0: 50 a6 00 02 bgeu r5,r6,80149e8 <_Timer_server_Schedule_operation_method+0x70>
delta_interval -= delta;
80149e4: c8 c5 20 00 sub r4,r6,r5
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
80149e8: 58 24 00 10 sw (r1+16),r4
}
ts->Interval_watchdogs.last_snapshot = snapshot;
80149ec: 59 63 00 3c sw (r11+60),r3
_ISR_Enable( level );
80149f0: d0 02 00 00 wcsr IE,r2
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
80149f4: 35 61 00 30 addi r1,r11,48
80149f8: 35 82 00 10 addi r2,r12,16
80149fc: f8 00 15 63 calli 8019f88 <_Watchdog_Insert>
if ( !ts->active ) {
8014a00: 41 61 00 7c lbu r1,(r11+124)
8014a04: 20 21 00 ff andi r1,r1,0xff
8014a08: 5c 20 00 24 bne r1,r0,8014a98 <_Timer_server_Schedule_operation_method+0x120>
_Timer_server_Reset_interval_system_watchdog( ts );
8014a0c: b9 60 08 00 mv r1,r11
8014a10: fb ff ff 25 calli 80146a4 <_Timer_server_Reset_interval_system_watchdog>
8014a14: e0 00 00 21 bi 8014a98 <_Timer_server_Schedule_operation_method+0x120>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
8014a18: 34 02 00 03 mvi r2,3
8014a1c: 5c 22 00 1f bne r1,r2,8014a98 <_Timer_server_Schedule_operation_method+0x120>
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
8014a20: 90 00 30 00 rcsr r6,IE
8014a24: 34 01 ff fe mvi r1,-2
8014a28: a0 c1 08 00 and r1,r6,r1
8014a2c: d0 01 00 00 wcsr IE,r1
initialized = false;
}
#endif
return status;
}
8014a30: 29 62 00 68 lw r2,(r11+104)
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
8014a34: 78 01 08 04 mvhi r1,0x804
last_snapshot = ts->TOD_watchdogs.last_snapshot;
8014a38: 29 65 00 74 lw r5,(r11+116)
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
8014a3c: 38 21 0d 98 ori r1,r1,0xd98
8014a40: 35 63 00 6c addi r3,r11,108
8014a44: 28 21 00 00 lw r1,(r1+0)
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
8014a48: 44 43 00 0a be r2,r3,8014a70 <_Timer_server_Schedule_operation_method+0xf8>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
8014a4c: 28 44 00 10 lw r4,(r2+16)
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
8014a50: b4 85 18 00 add r3,r4,r5
delta_interval += delta;
8014a54: c8 61 18 00 sub r3,r3,r1
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
if ( snapshot > last_snapshot ) {
8014a58: 50 a1 00 05 bgeu r5,r1,8014a6c <_Timer_server_Schedule_operation_method+0xf4>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
8014a5c: c8 25 28 00 sub r5,r1,r5
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
8014a60: 34 03 00 00 mvi r3,0
if ( snapshot > last_snapshot ) {
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
8014a64: 50 a4 00 02 bgeu r5,r4,8014a6c <_Timer_server_Schedule_operation_method+0xf4><== NEVER TAKEN
delta_interval -= delta;
8014a68: c8 85 18 00 sub r3,r4,r5
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
8014a6c: 58 43 00 10 sw (r2+16),r3
}
ts->TOD_watchdogs.last_snapshot = snapshot;
8014a70: 59 61 00 74 sw (r11+116),r1
_ISR_Enable( level );
8014a74: d0 06 00 00 wcsr IE,r6
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
8014a78: 35 61 00 68 addi r1,r11,104
8014a7c: 35 82 00 10 addi r2,r12,16
8014a80: f8 00 15 42 calli 8019f88 <_Watchdog_Insert>
if ( !ts->active ) {
8014a84: 41 61 00 7c lbu r1,(r11+124)
8014a88: 20 21 00 ff andi r1,r1,0xff
8014a8c: 5c 20 00 03 bne r1,r0,8014a98 <_Timer_server_Schedule_operation_method+0x120>
_Timer_server_Reset_tod_system_watchdog( ts );
8014a90: b9 60 08 00 mv r1,r11
8014a94: fb ff ff 21 calli 8014718 <_Timer_server_Reset_tod_system_watchdog>
}
}
_Thread_Enable_dispatch();
8014a98: f8 00 0f f7 calli 8018a74 <_Thread_Enable_dispatch>
8014a9c: e0 00 00 03 bi 8014aa8 <_Timer_server_Schedule_operation_method+0x130>
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
8014aa0: 29 61 00 78 lw r1,(r11+120) <== NOT EXECUTED
8014aa4: f8 00 02 e4 calli 8015634 <_Chain_Append> <== NOT EXECUTED
}
}
8014aa8: 2b 9d 00 04 lw ra,(sp+4)
8014aac: 2b 8b 00 0c lw r11,(sp+12)
8014ab0: 2b 8c 00 08 lw r12,(sp+8)
8014ab4: 37 9c 00 0c addi sp,sp,12
8014ab8: c3 a0 00 00 ret
08007888 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
8007888: 37 9c ff ec addi sp,sp,-20
800788c: 5b 8b 00 14 sw (sp+20),r11
8007890: 5b 8c 00 10 sw (sp+16),r12
8007894: 5b 8d 00 0c sw (sp+12),r13
8007898: 5b 8e 00 08 sw (sp+8),r14
800789c: 5b 9d 00 04 sw (sp+4),ra
User_extensions_Control *extension;
uint32_t i;
uint32_t number_of_extensions;
User_extensions_Table *initial_extensions;
number_of_extensions = Configuration.number_of_initial_extensions;
80078a0: 78 02 08 01 mvhi r2,0x801
80078a4: 38 42 90 dc ori r2,r2,0x90dc
80078a8: 28 4e 00 38 lw r14,(r2+56)
initial_extensions = Configuration.User_extension_table;
80078ac: 28 4b 00 3c lw r11,(r2+60)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
80078b0: 78 03 08 01 mvhi r3,0x801
80078b4: 78 02 08 01 mvhi r2,0x801
80078b8: 38 42 9a ec ori r2,r2,0x9aec
80078bc: 38 63 9a f0 ori r3,r3,0x9af0
80078c0: 58 43 00 00 sw (r2+0),r3
head->previous = NULL;
80078c4: 58 40 00 04 sw (r2+4),r0
tail->previous = head;
80078c8: 58 42 00 08 sw (r2+8),r2
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
80078cc: 78 03 08 01 mvhi r3,0x801
80078d0: 78 02 08 01 mvhi r2,0x801
80078d4: 38 42 99 94 ori r2,r2,0x9994
80078d8: 38 63 99 98 ori r3,r3,0x9998
80078dc: 58 43 00 00 sw (r2+0),r3
head->previous = NULL;
80078e0: 58 40 00 04 sw (r2+4),r0
tail->previous = head;
80078e4: 58 42 00 08 sw (r2+8),r2
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
80078e8: 45 60 00 22 be r11,r0,8007970 <_User_extensions_Handler_initialization+0xe8><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
80078ec: 34 02 00 34 mvi r2,52
80078f0: b9 c0 08 00 mv r1,r14
80078f4: f8 00 3d fc calli 80170e4 <__mulsi3>
80078f8: b8 20 68 00 mv r13,r1
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
80078fc: f8 00 01 84 calli 8007f0c <_Workspace_Allocate_or_fatal_error>
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
8007900: b9 a0 18 00 mv r3,r13
8007904: 34 02 00 00 mvi r2,0
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
8007908: b8 20 60 00 mv r12,r1
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
800790c: 34 0d 00 00 mvi r13,0
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
8007910: f8 00 29 cf calli 801204c <memset>
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
8007914: e0 00 00 16 bi 800796c <_User_extensions_Handler_initialization+0xe4>
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
8007918: 29 61 00 1c lw r1,(r11+28)
800791c: 29 68 00 00 lw r8,(r11+0)
8007920: 29 67 00 04 lw r7,(r11+4)
8007924: 29 66 00 08 lw r6,(r11+8)
8007928: 29 65 00 0c lw r5,(r11+12)
800792c: 29 64 00 10 lw r4,(r11+16)
8007930: 29 63 00 14 lw r3,(r11+20)
8007934: 29 62 00 18 lw r2,(r11+24)
8007938: 59 81 00 30 sw (r12+48),r1
800793c: 59 88 00 14 sw (r12+20),r8
8007940: 59 87 00 18 sw (r12+24),r7
8007944: 59 86 00 1c sw (r12+28),r6
8007948: 59 85 00 20 sw (r12+32),r5
800794c: 59 84 00 24 sw (r12+36),r4
8007950: 59 83 00 28 sw (r12+40),r3
8007954: 59 82 00 2c sw (r12+44),r2
_User_extensions_Add_set( extension );
8007958: b9 80 08 00 mv r1,r12
800795c: f8 00 1e dd calli 800f4d0 <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
8007960: 35 8c 00 34 addi r12,r12,52
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
8007964: 35 ad 00 01 addi r13,r13,1
8007968: 35 6b 00 20 addi r11,r11,32
800796c: 55 cd ff eb bgu r14,r13,8007918 <_User_extensions_Handler_initialization+0x90>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
8007970: 2b 9d 00 04 lw ra,(sp+4)
8007974: 2b 8b 00 14 lw r11,(sp+20)
8007978: 2b 8c 00 10 lw r12,(sp+16)
800797c: 2b 8d 00 0c lw r13,(sp+12)
8007980: 2b 8e 00 08 lw r14,(sp+8)
8007984: 37 9c 00 14 addi sp,sp,20
8007988: c3 a0 00 00 ret
080089e0 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
80089e0: 37 9c ff e4 addi sp,sp,-28
80089e4: 5b 8b 00 1c sw (sp+28),r11
80089e8: 5b 8c 00 18 sw (sp+24),r12
80089ec: 5b 8d 00 14 sw (sp+20),r13
80089f0: 5b 8e 00 10 sw (sp+16),r14
80089f4: 5b 8f 00 0c sw (sp+12),r15
80089f8: 5b 90 00 08 sw (sp+8),r16
80089fc: 5b 9d 00 04 sw (sp+4),ra
8008a00: b8 20 60 00 mv r12,r1
8008a04: b8 60 58 00 mv r11,r3
ISR_Level level;
_ISR_Disable( level );
8008a08: 90 00 08 00 rcsr r1,IE
8008a0c: 34 03 ff fe mvi r3,-2
8008a10: a0 23 18 00 and r3,r1,r3
8008a14: d0 03 00 00 wcsr IE,r3
}
}
_ISR_Enable( level );
}
8008a18: 29 83 00 00 lw r3,(r12+0)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
8008a1c: 35 8e 00 04 addi r14,r12,4
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
8008a20: 44 6e 00 1d be r3,r14,8008a94 <_Watchdog_Adjust+0xb4>
switch ( direction ) {
8008a24: 44 40 00 04 be r2,r0,8008a34 <_Watchdog_Adjust+0x54>
8008a28: 34 04 00 01 mvi r4,1
8008a2c: 5c 44 00 1a bne r2,r4,8008a94 <_Watchdog_Adjust+0xb4> <== NEVER TAKEN
8008a30: e0 00 00 04 bi 8008a40 <_Watchdog_Adjust+0x60>
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
8008a34: 34 10 00 01 mvi r16,1
_ISR_Enable( level );
_Watchdog_Tickle( header );
_ISR_Disable( level );
8008a38: 34 0f ff fe mvi r15,-2
8008a3c: e0 00 00 15 bi 8008a90 <_Watchdog_Adjust+0xb0>
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
8008a40: 28 62 00 10 lw r2,(r3+16)
8008a44: b4 4b 58 00 add r11,r2,r11
8008a48: 58 6b 00 10 sw (r3+16),r11
break;
8008a4c: e0 00 00 12 bi 8008a94 <_Watchdog_Adjust+0xb4>
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
8008a50: 29 82 00 00 lw r2,(r12+0)
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
8008a54: 28 4d 00 10 lw r13,(r2+16)
8008a58: 51 6d 00 04 bgeu r11,r13,8008a68 <_Watchdog_Adjust+0x88>
_Watchdog_First( header )->delta_interval -= units;
8008a5c: c9 ab 58 00 sub r11,r13,r11
8008a60: 58 4b 00 10 sw (r2+16),r11
break;
8008a64: e0 00 00 0c bi 8008a94 <_Watchdog_Adjust+0xb4>
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
8008a68: 58 50 00 10 sw (r2+16),r16
_ISR_Enable( level );
8008a6c: d0 01 00 00 wcsr IE,r1
_Watchdog_Tickle( header );
8008a70: b9 80 08 00 mv r1,r12
8008a74: f8 00 00 9a calli 8008cdc <_Watchdog_Tickle>
_ISR_Disable( level );
8008a78: 90 00 08 00 rcsr r1,IE
8008a7c: a0 2f 10 00 and r2,r1,r15
8008a80: d0 02 00 00 wcsr IE,r2
if ( _Chain_Is_empty( header ) )
8008a84: 29 82 00 00 lw r2,(r12+0)
8008a88: 44 4e 00 03 be r2,r14,8008a94 <_Watchdog_Adjust+0xb4>
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
8008a8c: c9 6d 58 00 sub r11,r11,r13
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
8008a90: 5d 60 ff f0 bne r11,r0,8008a50 <_Watchdog_Adjust+0x70> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
8008a94: d0 01 00 00 wcsr IE,r1
}
8008a98: 2b 9d 00 04 lw ra,(sp+4)
8008a9c: 2b 8b 00 1c lw r11,(sp+28)
8008aa0: 2b 8c 00 18 lw r12,(sp+24)
8008aa4: 2b 8d 00 14 lw r13,(sp+20)
8008aa8: 2b 8e 00 10 lw r14,(sp+16)
8008aac: 2b 8f 00 0c lw r15,(sp+12)
8008ab0: 2b 90 00 08 lw r16,(sp+8)
8008ab4: 37 9c 00 1c addi sp,sp,28
8008ab8: c3 a0 00 00 ret
08007da4 <_Watchdog_Remove>:
{
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
8007da4: 90 00 28 00 rcsr r5,IE
8007da8: 34 02 ff fe mvi r2,-2
8007dac: a0 a2 10 00 and r2,r5,r2
8007db0: d0 02 00 00 wcsr IE,r2
previous_state = the_watchdog->state;
8007db4: 28 23 00 08 lw r3,(r1+8)
switch ( previous_state ) {
8007db8: 34 02 00 01 mvi r2,1
8007dbc: 44 62 00 05 be r3,r2,8007dd0 <_Watchdog_Remove+0x2c>
8007dc0: 44 60 00 1b be r3,r0,8007e2c <_Watchdog_Remove+0x88>
8007dc4: 34 02 00 03 mvi r2,3
8007dc8: 54 62 00 19 bgu r3,r2,8007e2c <_Watchdog_Remove+0x88> <== NEVER TAKEN
8007dcc: e0 00 00 03 bi 8007dd8 <_Watchdog_Remove+0x34>
/*
* It is not actually on the chain so just change the state and
* the Insert operation we interrupted will be aborted.
*/
the_watchdog->state = WATCHDOG_INACTIVE;
8007dd0: 58 20 00 08 sw (r1+8),r0
break;
8007dd4: e0 00 00 16 bi 8007e2c <_Watchdog_Remove+0x88>
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
_ISR_Enable( level );
return( previous_state );
}
8007dd8: 28 22 00 00 lw r2,(r1+0)
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
8007ddc: 58 20 00 08 sw (r1+8),r0
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
8007de0: 28 44 00 00 lw r4,(r2+0)
8007de4: 44 80 00 05 be r4,r0,8007df8 <_Watchdog_Remove+0x54>
next_watchdog->delta_interval += the_watchdog->delta_interval;
8007de8: 28 46 00 10 lw r6,(r2+16)
8007dec: 28 24 00 10 lw r4,(r1+16)
8007df0: b4 c4 20 00 add r4,r6,r4
8007df4: 58 44 00 10 sw (r2+16),r4
if ( _Watchdog_Sync_count )
8007df8: 78 04 08 01 mvhi r4,0x801
8007dfc: 38 84 9a 9c ori r4,r4,0x9a9c
8007e00: 28 84 00 00 lw r4,(r4+0)
8007e04: 44 80 00 07 be r4,r0,8007e20 <_Watchdog_Remove+0x7c>
_Watchdog_Sync_level = _ISR_Nest_level;
8007e08: 78 04 08 01 mvhi r4,0x801
8007e0c: 38 84 9e 3c ori r4,r4,0x9e3c
8007e10: 28 86 00 08 lw r6,(r4+8)
8007e14: 78 04 08 01 mvhi r4,0x801
8007e18: 38 84 9a 34 ori r4,r4,0x9a34
8007e1c: 58 86 00 00 sw (r4+0),r6
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
8007e20: 28 24 00 04 lw r4,(r1+4)
next->previous = previous;
8007e24: 58 44 00 04 sw (r2+4),r4
previous->next = next;
8007e28: 58 82 00 00 sw (r4+0),r2
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
8007e2c: 78 02 08 01 mvhi r2,0x801
8007e30: 38 42 9a a0 ori r2,r2,0x9aa0
8007e34: 28 42 00 00 lw r2,(r2+0)
8007e38: 58 22 00 18 sw (r1+24),r2
_ISR_Enable( level );
8007e3c: d0 05 00 00 wcsr IE,r5
return( previous_state );
}
8007e40: b8 60 08 00 mv r1,r3
8007e44: c3 a0 00 00 ret
0800860c <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
800860c: 37 9c ff ec addi sp,sp,-20
8008610: 5b 8b 00 14 sw (sp+20),r11
8008614: 5b 8c 00 10 sw (sp+16),r12
8008618: 5b 8d 00 0c sw (sp+12),r13
800861c: 5b 8e 00 08 sw (sp+8),r14
8008620: 5b 9d 00 04 sw (sp+4),ra
8008624: b8 20 70 00 mv r14,r1
8008628: b8 40 60 00 mv r12,r2
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
800862c: 90 00 68 00 rcsr r13,IE
8008630: 34 01 ff fe mvi r1,-2
8008634: a1 a1 08 00 and r1,r13,r1
8008638: d0 01 00 00 wcsr IE,r1
printk( "Watchdog Chain: %s %p\n", name, header );
800863c: 78 01 08 01 mvhi r1,0x801
8008640: b9 80 18 00 mv r3,r12
8008644: 38 21 ed 0c ori r1,r1,0xed0c
8008648: b9 c0 10 00 mv r2,r14
800864c: fb ff eb 6b calli 80033f8 <printk>
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
8008650: 29 8b 00 00 lw r11,(r12+0)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
8008654: 35 8c 00 04 addi r12,r12,4
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
8008658: 45 6c 00 0b be r11,r12,8008684 <_Watchdog_Report_chain+0x78>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
800865c: b9 60 10 00 mv r2,r11
8008660: 34 01 00 00 mvi r1,0
8008664: f8 00 00 13 calli 80086b0 <_Watchdog_Report>
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
node != _Chain_Tail(header) ;
node = node->next )
8008668: 29 6b 00 00 lw r11,(r11+0)
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
800866c: 5d 6c ff fc bne r11,r12,800865c <_Watchdog_Report_chain+0x50><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
8008670: 78 01 08 01 mvhi r1,0x801
8008674: 38 21 ed 24 ori r1,r1,0xed24
8008678: b9 c0 10 00 mv r2,r14
800867c: fb ff eb 5f calli 80033f8 <printk>
8008680: e0 00 00 04 bi 8008690 <_Watchdog_Report_chain+0x84>
} else {
printk( "Chain is empty\n" );
8008684: 78 01 08 01 mvhi r1,0x801
8008688: 38 21 ed 34 ori r1,r1,0xed34
800868c: fb ff eb 5b calli 80033f8 <printk>
}
_ISR_Enable( level );
8008690: d0 0d 00 00 wcsr IE,r13
}
8008694: 2b 9d 00 04 lw ra,(sp+4)
8008698: 2b 8b 00 14 lw r11,(sp+20)
800869c: 2b 8c 00 10 lw r12,(sp+16)
80086a0: 2b 8d 00 0c lw r13,(sp+12)
80086a4: 2b 8e 00 08 lw r14,(sp+8)
80086a8: 37 9c 00 14 addi sp,sp,20
80086ac: c3 a0 00 00 ret
0800c524 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
800c524: 37 9c ff e4 addi sp,sp,-28
800c528: 5b 8b 00 1c sw (sp+28),r11
800c52c: 5b 8c 00 18 sw (sp+24),r12
800c530: 5b 8d 00 14 sw (sp+20),r13
800c534: 5b 8e 00 10 sw (sp+16),r14
800c538: 5b 8f 00 0c sw (sp+12),r15
800c53c: 5b 90 00 08 sw (sp+8),r16
800c540: 5b 9d 00 04 sw (sp+4),ra
800c544: b8 20 60 00 mv r12,r1
* See the comment in watchdoginsert.c and watchdogadjust.c
* about why it's safe not to declare header a pointer to
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
800c548: 90 00 18 00 rcsr r3,IE
800c54c: 34 01 ff fe mvi r1,-2
800c550: a0 61 08 00 and r1,r3,r1
800c554: d0 01 00 00 wcsr IE,r1
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
800c558: 29 8b 00 00 lw r11,(r12+0)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
800c55c: 35 8e 00 04 addi r14,r12,4
* See the comment in watchdoginsert.c and watchdogadjust.c
* about why it's safe not to declare header a pointer to
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
800c560: b8 60 10 00 mv r2,r3
if ( _Chain_Is_empty( header ) )
800c564: 45 6e 00 1a be r11,r14,800c5cc <_Watchdog_Tickle+0xa8>
* to be inserted has already had its delta_interval adjusted to 0, and
* so is added to the head of the chain with a delta_interval of 0.
*
* Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)
*/
if (the_watchdog->delta_interval != 0) {
800c568: 29 61 00 10 lw r1,(r11+16)
800c56c: 44 20 00 04 be r1,r0,800c57c <_Watchdog_Tickle+0x58>
the_watchdog->delta_interval--;
800c570: 34 21 ff ff addi r1,r1,-1
800c574: 59 61 00 10 sw (r11+16),r1
if ( the_watchdog->delta_interval != 0 )
800c578: 5c 20 00 15 bne r1,r0,800c5cc <_Watchdog_Tickle+0xa8>
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
800c57c: b8 60 68 00 mv r13,r3
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
_ISR_Enable( level );
switch( watchdog_state ) {
800c580: 34 10 00 02 mvi r16,2
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
800c584: 34 0f ff fe mvi r15,-2
800c588: e0 00 00 02 bi 800c590 <_Watchdog_Tickle+0x6c>
800c58c: b8 40 68 00 mv r13,r2
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
800c590: b9 60 08 00 mv r1,r11
800c594: fb ff ff bb calli 800c480 <_Watchdog_Remove>
_ISR_Enable( level );
800c598: d0 0d 00 00 wcsr IE,r13
switch( watchdog_state ) {
800c59c: 5c 30 00 05 bne r1,r16,800c5b0 <_Watchdog_Tickle+0x8c> <== NEVER TAKEN
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
800c5a0: 29 63 00 1c lw r3,(r11+28)
800c5a4: 29 61 00 20 lw r1,(r11+32)
800c5a8: 29 62 00 24 lw r2,(r11+36)
800c5ac: d8 60 00 00 call r3
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
800c5b0: 90 00 10 00 rcsr r2,IE
800c5b4: a0 4f 08 00 and r1,r2,r15
800c5b8: d0 01 00 00 wcsr IE,r1
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
800c5bc: 29 8b 00 00 lw r11,(r12+0)
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
800c5c0: 45 6e 00 03 be r11,r14,800c5cc <_Watchdog_Tickle+0xa8>
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
800c5c4: 29 61 00 10 lw r1,(r11+16)
800c5c8: 44 20 ff f1 be r1,r0,800c58c <_Watchdog_Tickle+0x68>
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
800c5cc: d0 02 00 00 wcsr IE,r2
}
800c5d0: 2b 9d 00 04 lw ra,(sp+4)
800c5d4: 2b 8b 00 1c lw r11,(sp+28)
800c5d8: 2b 8c 00 18 lw r12,(sp+24)
800c5dc: 2b 8d 00 14 lw r13,(sp+20)
800c5e0: 2b 8e 00 10 lw r14,(sp+16)
800c5e4: 2b 8f 00 0c lw r15,(sp+12)
800c5e8: 2b 90 00 08 lw r16,(sp+8)
800c5ec: 37 9c 00 1c addi sp,sp,28
800c5f0: c3 a0 00 00 ret
0800608c <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
800608c: 37 9c ff a0 addi sp,sp,-96
8006090: 5b 8b 00 1c sw (sp+28),r11
8006094: 5b 8c 00 18 sw (sp+24),r12
8006098: 5b 8d 00 14 sw (sp+20),r13
800609c: 5b 8e 00 10 sw (sp+16),r14
80060a0: 5b 8f 00 0c sw (sp+12),r15
80060a4: 5b 90 00 08 sw (sp+8),r16
80060a8: 5b 9d 00 04 sw (sp+4),ra
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
80060ac: b8 40 08 00 mv r1,r2
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
80060b0: b8 40 58 00 mv r11,r2
80060b4: b8 60 80 00 mv r16,r3
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
80060b8: fb ff f9 80 calli 80046b8 <rtems_filesystem_dirname>
80060bc: b8 20 70 00 mv r14,r1
80060c0: 37 84 00 34 addi r4,sp,52
if ( old_parent_pathlen == 0 )
80060c4: 5c 20 00 07 bne r1,r0,80060e0 <_rename_r+0x54>
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
80060c8: b9 60 08 00 mv r1,r11
80060cc: 37 82 00 60 addi r2,sp,96
80060d0: b8 80 18 00 mv r3,r4
80060d4: f8 00 00 fa calli 80064bc <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;
80060d8: 34 0d 00 00 mvi r13,0
80060dc: e0 00 00 09 bi 8006100 <_rename_r+0x74>
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,
80060e0: b9 60 08 00 mv r1,r11
80060e4: b9 c0 10 00 mv r2,r14
80060e8: 34 03 00 02 mvi r3,2
80060ec: 34 05 00 00 mvi r5,0
80060f0: fb ff f9 57 calli 800464c <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
return -1;
80060f4: 34 0c ff ff mvi r12,-1
else {
result = rtems_filesystem_evaluate_path( old, old_parent_pathlen,
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
80060f8: 5c 20 00 59 bne r1,r0,800625c <_rename_r+0x1d0> <== NEVER TAKEN
return -1;
free_old_parentloc = true;
80060fc: 34 0d 00 01 mvi r13,1
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
8006100: 2b 81 00 34 lw r1,(sp+52)
name = old + old_parent_pathlen;
8006104: b5 6e 58 00 add r11,r11,r14
8006108: 5b 8b 00 5c sw (sp+92),r11
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
800610c: 5b 81 00 48 sw (sp+72),r1
8006110: 2b 81 00 38 lw r1,(sp+56)
name = old + old_parent_pathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
8006114: 37 8c 00 48 addi r12,sp,72
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
8006118: 5b 81 00 4c sw (sp+76),r1
800611c: 2b 81 00 3c lw r1,(sp+60)
8006120: 5b 81 00 50 sw (sp+80),r1
8006124: 2b 81 00 40 lw r1,(sp+64)
8006128: 5b 81 00 54 sw (sp+84),r1
800612c: 2b 81 00 44 lw r1,(sp+68)
8006130: 5b 81 00 58 sw (sp+88),r1
name = old + old_parent_pathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
8006134: b9 60 08 00 mv r1,r11
8006138: f8 00 38 01 calli 801413c <strlen>
800613c: b8 20 10 00 mv r2,r1
8006140: b9 60 08 00 mv r1,r11
8006144: fb ff f9 71 calli 8004708 <rtems_filesystem_prefix_separators>
8006148: b5 61 58 00 add r11,r11,r1
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
800614c: b9 60 08 00 mv r1,r11
* 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 ) );
8006150: 5b 8b 00 5c sw (sp+92),r11
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
8006154: f8 00 37 fa calli 801413c <strlen>
8006158: b8 20 10 00 mv r2,r1
800615c: 34 03 00 00 mvi r3,0
8006160: b9 60 08 00 mv r1,r11
8006164: b9 80 20 00 mv r4,r12
8006168: 34 05 00 00 mvi r5,0
800616c: fb ff f9 16 calli 80045c4 <rtems_filesystem_evaluate_relative_path>
8006170: b8 20 78 00 mv r15,r1
0, &old_loc, false );
if ( result != 0 ) {
8006174: 44 20 00 05 be r1,r0,8006188 <_rename_r+0xfc>
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
return -1;
8006178: 34 0c ff ff mvi r12,-1
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 );
800617c: 37 81 00 34 addi r1,sp,52
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 )
8006180: 45 a0 00 37 be r13,r0,800625c <_rename_r+0x1d0> <== NEVER TAKEN
8006184: e0 00 00 35 bi 8006258 <_rename_r+0x1cc>
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
8006188: 37 8b 00 20 addi r11,sp,32
800618c: ba 00 08 00 mv r1,r16
8006190: 37 82 00 60 addi r2,sp,96
8006194: b9 60 18 00 mv r3,r11
8006198: f8 00 00 c9 calli 80064bc <rtems_filesystem_get_start_loc>
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
800619c: 2b 81 00 2c lw r1,(sp+44)
80061a0: b9 60 10 00 mv r2,r11
80061a4: 37 83 00 5c addi r3,sp,92
80061a8: 28 24 00 04 lw r4,(r1+4)
80061ac: 2b 81 00 60 lw r1,(sp+96)
80061b0: b6 01 08 00 add r1,r16,r1
80061b4: d8 80 00 00 call r4
80061b8: b8 20 70 00 mv r14,r1
if ( result != 0 ) {
80061bc: 44 2f 00 09 be r1,r15,80061e0 <_rename_r+0x154>
rtems_filesystem_freenode( &new_parent_loc );
80061c0: b9 60 08 00 mv r1,r11
80061c4: fb ff f9 f5 calli 8004998 <rtems_filesystem_freenode>
if ( free_old_parentloc )
80061c8: 45 a0 00 03 be r13,r0,80061d4 <_rename_r+0x148> <== NEVER TAKEN
rtems_filesystem_freenode( &old_parent_loc );
80061cc: 37 81 00 34 addi r1,sp,52
80061d0: fb ff f9 f2 calli 8004998 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &old_loc );
80061d4: 37 81 00 48 addi r1,sp,72
80061d8: fb ff f9 f0 calli 8004998 <rtems_filesystem_freenode>
80061dc: e0 00 00 0e bi 8006214 <_rename_r+0x188>
/*
* 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 ) {
80061e0: 2b 81 00 30 lw r1,(sp+48)
80061e4: 2b 82 00 44 lw r2,(sp+68)
80061e8: 44 41 00 0d be r2,r1,800621c <_rename_r+0x190>
rtems_filesystem_freenode( &new_parent_loc );
80061ec: b9 60 08 00 mv r1,r11
80061f0: fb ff f9 ea calli 8004998 <rtems_filesystem_freenode>
if ( free_old_parentloc )
80061f4: 45 ae 00 03 be r13,r14,8006200 <_rename_r+0x174>
rtems_filesystem_freenode( &old_parent_loc );
80061f8: 37 81 00 34 addi r1,sp,52
80061fc: fb ff f9 e7 calli 8004998 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &old_loc );
8006200: 37 81 00 48 addi r1,sp,72
8006204: fb ff f9 e5 calli 8004998 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
8006208: f8 00 2a 33 calli 8010ad4 <__errno>
800620c: 34 02 00 12 mvi r2,18
8006210: 58 22 00 00 sw (r1+0),r2
8006214: 34 0c ff ff mvi r12,-1
8006218: e0 00 00 11 bi 800625c <_rename_r+0x1d0>
}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
800621c: 2b 81 00 2c lw r1,(sp+44)
8006220: 2b 84 00 5c lw r4,(sp+92)
8006224: 37 8f 00 34 addi r15,sp,52
8006228: 28 25 00 40 lw r5,(r1+64)
800622c: b9 80 10 00 mv r2,r12
8006230: b9 e0 08 00 mv r1,r15
8006234: b9 60 18 00 mv r3,r11
8006238: d8 a0 00 00 call r5
800623c: b8 20 60 00 mv r12,r1
rtems_filesystem_freenode( &new_parent_loc );
8006240: b9 60 08 00 mv r1,r11
8006244: fb ff f9 d5 calli 8004998 <rtems_filesystem_freenode>
if ( free_old_parentloc )
8006248: 45 ae 00 03 be r13,r14,8006254 <_rename_r+0x1c8>
rtems_filesystem_freenode( &old_parent_loc );
800624c: b9 e0 08 00 mv r1,r15
8006250: fb ff f9 d2 calli 8004998 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &old_loc );
8006254: 37 81 00 48 addi r1,sp,72
8006258: fb ff f9 d0 calli 8004998 <rtems_filesystem_freenode>
return result;
}
800625c: b9 80 08 00 mv r1,r12
8006260: 2b 9d 00 04 lw ra,(sp+4)
8006264: 2b 8b 00 1c lw r11,(sp+28)
8006268: 2b 8c 00 18 lw r12,(sp+24)
800626c: 2b 8d 00 14 lw r13,(sp+20)
8006270: 2b 8e 00 10 lw r14,(sp+16)
8006274: 2b 8f 00 0c lw r15,(sp+12)
8006278: 2b 90 00 08 lw r16,(sp+8)
800627c: 37 9c 00 60 addi sp,sp,96
8006280: c3 a0 00 00 ret
080039a4 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
80039a4: 37 9c ff e8 addi sp,sp,-24
80039a8: 5b 8b 00 18 sw (sp+24),r11
80039ac: 5b 8c 00 14 sw (sp+20),r12
80039b0: 5b 8d 00 10 sw (sp+16),r13
80039b4: 5b 8e 00 0c sw (sp+12),r14
80039b8: 5b 8f 00 08 sw (sp+8),r15
80039bc: 5b 9d 00 04 sw (sp+4),ra
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
80039c0: 78 0b 08 01 mvhi r11,0x801
80039c4: 39 6b 78 68 ori r11,r11,0x7868
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
80039c8: b8 20 70 00 mv r14,r1
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
80039cc: b9 60 08 00 mv r1,r11
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
80039d0: b8 40 60 00 mv r12,r2
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
80039d4: f8 00 04 c9 calli 8004cf8 <pthread_mutex_lock>
if (fcntl (fildes, F_GETFD) < 0) {
80039d8: b9 c0 08 00 mv r1,r14
80039dc: 34 02 00 01 mvi r2,1
80039e0: f8 00 1e 6c calli 800b390 <fcntl>
80039e4: 4c 20 00 06 bge r1,r0,80039fc <aio_cancel+0x58>
pthread_mutex_unlock(&aio_request_queue.mutex);
80039e8: b9 60 08 00 mv r1,r11
80039ec: f8 00 04 f6 calli 8004dc4 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
80039f0: f8 00 2e c7 calli 800f50c <__errno>
80039f4: 34 02 00 09 mvi r2,9
80039f8: e0 00 00 32 bi 8003ac0 <aio_cancel+0x11c>
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
80039fc: 5d 80 00 2b bne r12,r0,8003aa8 <aio_cancel+0x104>
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
8003a00: 78 01 08 01 mvhi r1,0x801
8003a04: 38 21 78 b0 ori r1,r1,0x78b0
8003a08: b9 c0 10 00 mv r2,r14
8003a0c: 34 03 00 00 mvi r3,0
8003a10: f8 00 00 c1 calli 8003d14 <rtems_aio_search_fd>
8003a14: b8 20 68 00 mv r13,r1
if (r_chain == NULL) {
8003a18: 5c 2c 00 17 bne r1,r12,8003a74 <aio_cancel+0xd0>
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
8003a1c: 29 62 00 54 lw r2,(r11+84)
8003a20: 78 01 08 01 mvhi r1,0x801
8003a24: 38 21 78 c0 ori r1,r1,0x78c0
8003a28: 44 41 00 3f be r2,r1,8003b24 <aio_cancel+0x180> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
8003a2c: 78 01 08 01 mvhi r1,0x801
8003a30: 38 21 78 bc ori r1,r1,0x78bc
8003a34: b9 c0 10 00 mv r2,r14
8003a38: 34 03 00 00 mvi r3,0
8003a3c: f8 00 00 b6 calli 8003d14 <rtems_aio_search_fd>
8003a40: b8 20 60 00 mv r12,r1
if (r_chain == NULL) {
8003a44: 44 2d 00 38 be r1,r13,8003b24 <aio_cancel+0x180>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
8003a48: f8 00 0a 7a calli 8006430 <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
8003a4c: b9 80 08 00 mv r1,r12
8003a50: f8 00 01 b2 calli 8004118 <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
8003a54: 35 8d 00 1c addi r13,r12,28
8003a58: b9 a0 08 00 mv r1,r13
8003a5c: f8 00 03 ed calli 8004a10 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
8003a60: b9 a0 08 00 mv r1,r13
8003a64: f8 00 02 ec calli 8004614 <pthread_cond_destroy>
free (r_chain);
8003a68: b9 80 08 00 mv r1,r12
8003a6c: fb ff f9 bd calli 8002160 <free>
8003a70: e0 00 00 0a bi 8003a98 <aio_cancel+0xf4>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
8003a74: 34 2c 00 1c addi r12,r1,28
8003a78: b9 80 08 00 mv r1,r12
8003a7c: f8 00 04 9f calli 8004cf8 <pthread_mutex_lock>
8003a80: b9 a0 08 00 mv r1,r13
8003a84: f8 00 0a 6b calli 8006430 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
8003a88: b9 a0 08 00 mv r1,r13
8003a8c: f8 00 01 a3 calli 8004118 <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
8003a90: b9 80 08 00 mv r1,r12
8003a94: f8 00 04 cc calli 8004dc4 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
8003a98: b9 60 08 00 mv r1,r11
8003a9c: f8 00 04 ca calli 8004dc4 <pthread_mutex_unlock>
return AIO_CANCELED;
8003aa0: 34 0c 00 00 mvi r12,0
8003aa4: e0 00 00 2f bi 8003b60 <aio_cancel+0x1bc>
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
8003aa8: 29 8f 00 00 lw r15,(r12+0)
8003aac: 45 ee 00 08 be r15,r14,8003acc <aio_cancel+0x128>
pthread_mutex_unlock (&aio_request_queue.mutex);
8003ab0: b9 60 08 00 mv r1,r11
8003ab4: f8 00 04 c4 calli 8004dc4 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
8003ab8: f8 00 2e 95 calli 800f50c <__errno>
8003abc: 34 02 00 16 mvi r2,22
8003ac0: 58 22 00 00 sw (r1+0),r2
8003ac4: 34 0c ff ff mvi r12,-1
8003ac8: e0 00 00 26 bi 8003b60 <aio_cancel+0x1bc>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
8003acc: 78 01 08 01 mvhi r1,0x801
8003ad0: 38 21 78 b0 ori r1,r1,0x78b0
8003ad4: b9 e0 10 00 mv r2,r15
8003ad8: 34 03 00 00 mvi r3,0
8003adc: f8 00 00 8e calli 8003d14 <rtems_aio_search_fd>
8003ae0: b8 20 68 00 mv r13,r1
if (r_chain == NULL) {
8003ae4: 5c 20 00 14 bne r1,r0,8003b34 <aio_cancel+0x190>
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
8003ae8: 29 62 00 54 lw r2,(r11+84)
8003aec: 78 01 08 01 mvhi r1,0x801
8003af0: 38 21 78 c0 ori r1,r1,0x78c0
8003af4: 44 41 00 0c be r2,r1,8003b24 <aio_cancel+0x180> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
8003af8: 78 01 08 01 mvhi r1,0x801
8003afc: 38 21 78 bc ori r1,r1,0x78bc
8003b00: b9 e0 10 00 mv r2,r15
8003b04: 34 03 00 00 mvi r3,0
8003b08: f8 00 00 83 calli 8003d14 <rtems_aio_search_fd>
if (r_chain == NULL) {
8003b0c: 44 20 ff e9 be r1,r0,8003ab0 <aio_cancel+0x10c>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
8003b10: b9 80 10 00 mv r2,r12
8003b14: 34 21 00 08 addi r1,r1,8
8003b18: f8 00 01 9e calli 8004190 <rtems_aio_remove_req>
8003b1c: b8 20 60 00 mv r12,r1
8003b20: e0 00 00 0e bi 8003b58 <aio_cancel+0x1b4>
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
8003b24: b9 60 08 00 mv r1,r11
8003b28: f8 00 04 a7 calli 8004dc4 <pthread_mutex_unlock>
return AIO_ALLDONE;
8003b2c: 34 0c 00 02 mvi r12,2
8003b30: e0 00 00 0c bi 8003b60 <aio_cancel+0x1bc>
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
8003b34: 34 2e 00 1c addi r14,r1,28
8003b38: b9 c0 08 00 mv r1,r14
8003b3c: f8 00 04 6f calli 8004cf8 <pthread_mutex_lock>
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
8003b40: b9 80 10 00 mv r2,r12
8003b44: 35 a1 00 08 addi r1,r13,8
8003b48: f8 00 01 92 calli 8004190 <rtems_aio_remove_req>
8003b4c: b8 20 60 00 mv r12,r1
pthread_mutex_unlock (&r_chain->mutex);
8003b50: b9 c0 08 00 mv r1,r14
8003b54: f8 00 04 9c calli 8004dc4 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
8003b58: b9 60 08 00 mv r1,r11
8003b5c: f8 00 04 9a calli 8004dc4 <pthread_mutex_unlock>
return result;
}
return AIO_ALLDONE;
}
8003b60: b9 80 08 00 mv r1,r12
8003b64: 2b 9d 00 04 lw ra,(sp+4)
8003b68: 2b 8b 00 18 lw r11,(sp+24)
8003b6c: 2b 8c 00 14 lw r12,(sp+20)
8003b70: 2b 8d 00 10 lw r13,(sp+16)
8003b74: 2b 8e 00 0c lw r14,(sp+12)
8003b78: 2b 8f 00 08 lw r15,(sp+8)
8003b7c: 37 9c 00 18 addi sp,sp,24
8003b80: c3 a0 00 00 ret
08003b8c <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
8003b8c: 37 9c ff f4 addi sp,sp,-12
8003b90: 5b 8b 00 0c sw (sp+12),r11
8003b94: 5b 8c 00 08 sw (sp+8),r12
8003b98: 5b 9d 00 04 sw (sp+4),ra
8003b9c: b8 40 58 00 mv r11,r2
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
8003ba0: 34 02 20 00 mvi r2,8192
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
8003ba4: 34 0c 00 16 mvi r12,22
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
8003ba8: 5c 22 00 09 bne r1,r2,8003bcc <aio_fsync+0x40>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
8003bac: 29 61 00 00 lw r1,(r11+0)
8003bb0: 34 02 00 03 mvi r2,3
8003bb4: f8 00 1d f7 calli 800b390 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
8003bb8: 20 21 00 03 andi r1,r1,0x3
8003bbc: 34 21 ff ff addi r1,r1,-1
8003bc0: 34 02 00 01 mvi r2,1
8003bc4: 50 41 00 09 bgeu r2,r1,8003be8 <aio_fsync+0x5c>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
8003bc8: 34 0c 00 09 mvi r12,9
8003bcc: 34 01 ff ff mvi r1,-1
8003bd0: 59 6c 00 2c sw (r11+44),r12
8003bd4: 59 61 00 30 sw (r11+48),r1
8003bd8: f8 00 2e 4d calli 800f50c <__errno>
8003bdc: 58 2c 00 00 sw (r1+0),r12
8003be0: 34 01 ff ff mvi r1,-1
8003be4: e0 00 00 09 bi 8003c08 <aio_fsync+0x7c>
req = malloc (sizeof (rtems_aio_request));
8003be8: 34 01 00 18 mvi r1,24
8003bec: fb ff fb 15 calli 8002840 <malloc>
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
8003bf0: 34 0c 00 0b mvi r12,11
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
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)
8003bf4: 44 20 ff f6 be r1,r0,8003bcc <aio_fsync+0x40> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
8003bf8: 58 2b 00 14 sw (r1+20),r11
req->aiocbp->aio_lio_opcode = LIO_SYNC;
8003bfc: 34 02 00 03 mvi r2,3
8003c00: 59 62 00 28 sw (r11+40),r2
return rtems_aio_enqueue (req);
8003c04: f8 00 01 7f calli 8004200 <rtems_aio_enqueue>
}
8003c08: 2b 9d 00 04 lw ra,(sp+4)
8003c0c: 2b 8b 00 0c lw r11,(sp+12)
8003c10: 2b 8c 00 08 lw r12,(sp+8)
8003c14: 37 9c 00 0c addi sp,sp,12
8003c18: c3 a0 00 00 ret
08004458 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
8004458: 37 9c ff f4 addi sp,sp,-12
800445c: 5b 8b 00 0c sw (sp+12),r11
8004460: 5b 8c 00 08 sw (sp+8),r12
8004464: 5b 9d 00 04 sw (sp+4),ra
8004468: b8 20 58 00 mv r11,r1
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
800446c: 28 21 00 00 lw r1,(r1+0)
8004470: 34 02 00 03 mvi r2,3
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
8004474: 34 0c 00 09 mvi r12,9
aio_read (struct aiocb *aiocbp)
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
8004478: f8 00 1b c6 calli 800b390 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
800447c: 20 21 00 03 andi r1,r1,0x3
8004480: 7c 22 00 02 cmpnei r2,r1,2
8004484: 7c 21 00 00 cmpnei r1,r1,0
8004488: a0 41 08 00 and r1,r2,r1
800448c: 5c 20 00 04 bne r1,r0,800449c <aio_read+0x44>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
8004490: 29 6c 00 10 lw r12,(r11+16)
8004494: 45 81 00 09 be r12,r1,80044b8 <aio_read+0x60>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
8004498: 34 0c 00 16 mvi r12,22
800449c: 34 01 ff ff mvi r1,-1
80044a0: 59 6c 00 2c sw (r11+44),r12
80044a4: 59 61 00 30 sw (r11+48),r1
80044a8: f8 00 2c 19 calli 800f50c <__errno>
80044ac: 58 2c 00 00 sw (r1+0),r12
80044b0: 34 01 ff ff mvi r1,-1
80044b4: e0 00 00 0d bi 80044e8 <aio_read+0x90>
if (aiocbp->aio_offset < 0)
80044b8: 29 61 00 04 lw r1,(r11+4)
80044bc: 4c 2c 00 02 bge r1,r12,80044c4 <aio_read+0x6c>
80044c0: e3 ff ff f6 bi 8004498 <aio_read+0x40>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
80044c4: 34 01 00 18 mvi r1,24
80044c8: fb ff f8 de calli 8002840 <malloc>
if (req == NULL)
80044cc: 5c 2c 00 03 bne r1,r12,80044d8 <aio_read+0x80> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
80044d0: 34 0c 00 0b mvi r12,11 <== NOT EXECUTED
80044d4: e3 ff ff f2 bi 800449c <aio_read+0x44> <== NOT EXECUTED
req->aiocbp = aiocbp;
80044d8: 58 2b 00 14 sw (r1+20),r11
req->aiocbp->aio_lio_opcode = LIO_READ;
80044dc: 34 02 00 01 mvi r2,1
80044e0: 59 62 00 28 sw (r11+40),r2
return rtems_aio_enqueue (req);
80044e4: fb ff ff 47 calli 8004200 <rtems_aio_enqueue>
}
80044e8: 2b 9d 00 04 lw ra,(sp+4)
80044ec: 2b 8b 00 0c lw r11,(sp+12)
80044f0: 2b 8c 00 08 lw r12,(sp+8)
80044f4: 37 9c 00 0c addi sp,sp,12
80044f8: c3 a0 00 00 ret
08004504 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
8004504: 37 9c ff f4 addi sp,sp,-12
8004508: 5b 8b 00 0c sw (sp+12),r11
800450c: 5b 8c 00 08 sw (sp+8),r12
8004510: 5b 9d 00 04 sw (sp+4),ra
8004514: b8 20 58 00 mv r11,r1
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
8004518: 28 21 00 00 lw r1,(r1+0)
800451c: 34 02 00 03 mvi r2,3
8004520: f8 00 1b 9c calli 800b390 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
8004524: 20 21 00 03 andi r1,r1,0x3
8004528: 34 21 ff ff addi r1,r1,-1
800452c: 34 02 00 01 mvi r2,1
8004530: 50 41 00 03 bgeu r2,r1,800453c <aio_write+0x38>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
8004534: 34 0c 00 09 mvi r12,9
8004538: e0 00 00 04 bi 8004548 <aio_write+0x44>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
800453c: 29 61 00 10 lw r1,(r11+16)
8004540: 44 20 00 09 be r1,r0,8004564 <aio_write+0x60>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
8004544: 34 0c 00 16 mvi r12,22
8004548: 34 01 ff ff mvi r1,-1
800454c: 59 6c 00 2c sw (r11+44),r12
8004550: 59 61 00 30 sw (r11+48),r1
8004554: f8 00 2b ee calli 800f50c <__errno>
8004558: 58 2c 00 00 sw (r1+0),r12
800455c: 34 01 ff ff mvi r1,-1
8004560: e0 00 00 0c bi 8004590 <aio_write+0x8c>
if (aiocbp->aio_offset < 0)
8004564: 29 62 00 04 lw r2,(r11+4)
8004568: 4c 41 00 02 bge r2,r1,8004570 <aio_write+0x6c>
800456c: e3 ff ff f6 bi 8004544 <aio_write+0x40>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
8004570: 34 01 00 18 mvi r1,24
8004574: fb ff f8 b3 calli 8002840 <malloc>
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
8004578: 34 0c 00 0b mvi r12,11
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
800457c: 44 20 ff f3 be r1,r0,8004548 <aio_write+0x44> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
8004580: 58 2b 00 14 sw (r1+20),r11
req->aiocbp->aio_lio_opcode = LIO_WRITE;
8004584: 34 02 00 02 mvi r2,2
8004588: 59 62 00 28 sw (r11+40),r2
return rtems_aio_enqueue (req);
800458c: fb ff ff 1d calli 8004200 <rtems_aio_enqueue>
}
8004590: 2b 9d 00 04 lw ra,(sp+4)
8004594: 2b 8b 00 0c lw r11,(sp+12)
8004598: 2b 8c 00 08 lw r12,(sp+8)
800459c: 37 9c 00 0c addi sp,sp,12
80045a0: c3 a0 00 00 ret
080013f4 <chroot>:
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
80013f4: 37 9c ff dc addi sp,sp,-36
80013f8: 5b 8b 00 10 sw (sp+16),r11
80013fc: 5b 8c 00 0c sw (sp+12),r12
8001400: 5b 8d 00 08 sw (sp+8),r13
8001404: 5b 9d 00 04 sw (sp+4),ra
int result;
rtems_filesystem_location_info_t loc;
/* an automatic call to new private env the first time */
if (rtems_current_user_env == &rtems_global_user_env) {
8001408: 78 0b 08 01 mvhi r11,0x801
800140c: 39 6b 41 34 ori r11,r11,0x4134
8001410: 29 6c 00 00 lw r12,(r11+0)
8001414: 78 02 08 01 mvhi r2,0x801
8001418: 38 42 47 c0 ori r2,r2,0x47c0
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
800141c: b8 20 68 00 mv r13,r1
int result;
rtems_filesystem_location_info_t loc;
/* an automatic call to new private env the first time */
if (rtems_current_user_env == &rtems_global_user_env) {
8001420: 5d 82 00 08 bne r12,r2,8001440 <chroot+0x4c>
rtems_libio_set_private_env(); /* try to set a new private env*/
8001424: f8 00 05 a7 calli 8002ac0 <rtems_libio_set_private_env>
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
8001428: 29 61 00 00 lw r1,(r11+0)
800142c: 5c 2c 00 05 bne r1,r12,8001440 <chroot+0x4c>
rtems_set_errno_and_return_minus_one( ENOTSUP );
8001430: f8 00 2d b8 calli 800cb10 <__errno>
8001434: 34 02 00 86 mvi r2,134
8001438: 58 22 00 00 sw (r1+0),r2
800143c: e0 00 00 0a bi 8001464 <chroot+0x70>
}
result = chdir(pathname);
8001440: b9 a0 08 00 mv r1,r13
8001444: f8 00 1c d5 calli 8008798 <chdir>
8001448: b8 20 58 00 mv r11,r1
if (result) {
800144c: 44 20 00 08 be r1,r0,800146c <chroot+0x78>
rtems_set_errno_and_return_minus_one( errno );
8001450: f8 00 2d b0 calli 800cb10 <__errno>
8001454: b8 20 58 00 mv r11,r1
8001458: f8 00 2d ae calli 800cb10 <__errno>
800145c: 28 21 00 00 lw r1,(r1+0)
8001460: 59 61 00 00 sw (r11+0),r1
8001464: 34 01 ff ff mvi r1,-1
8001468: e0 00 00 1a bi 80014d0 <chroot+0xdc>
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
800146c: 78 01 08 01 mvhi r1,0x801
8001470: 38 21 32 4c ori r1,r1,0x324c
8001474: 34 02 00 01 mvi r2,1
8001478: 34 03 00 00 mvi r3,0
800147c: 37 84 00 14 addi r4,sp,20
8001480: 34 05 00 00 mvi r5,0
8001484: f8 00 00 68 calli 8001624 <rtems_filesystem_evaluate_path>
8001488: 5c 2b ff f2 bne r1,r11,8001450 <chroot+0x5c> <== NEVER TAKEN
/* our cwd has changed, though - but there is no easy way of return :-( */
rtems_set_errno_and_return_minus_one( errno );
}
rtems_filesystem_freenode(&rtems_filesystem_root);
800148c: 78 0b 08 01 mvhi r11,0x801
8001490: 39 6b 41 34 ori r11,r11,0x4134
8001494: 29 61 00 00 lw r1,(r11+0)
8001498: 34 21 00 18 addi r1,r1,24
800149c: f8 00 00 aa calli 8001744 <rtems_filesystem_freenode>
rtems_filesystem_root = loc;
80014a0: 29 61 00 00 lw r1,(r11+0)
80014a4: 2b 82 00 14 lw r2,(sp+20)
80014a8: 58 22 00 18 sw (r1+24),r2
80014ac: 2b 82 00 18 lw r2,(sp+24)
80014b0: 58 22 00 1c sw (r1+28),r2
80014b4: 2b 82 00 1c lw r2,(sp+28)
80014b8: 58 22 00 20 sw (r1+32),r2
80014bc: 2b 82 00 20 lw r2,(sp+32)
80014c0: 58 22 00 24 sw (r1+36),r2
80014c4: 2b 82 00 24 lw r2,(sp+36)
80014c8: 58 22 00 28 sw (r1+40),r2
return 0;
80014cc: 34 01 00 00 mvi r1,0
}
80014d0: 2b 9d 00 04 lw ra,(sp+4)
80014d4: 2b 8b 00 10 lw r11,(sp+16)
80014d8: 2b 8c 00 0c lw r12,(sp+12)
80014dc: 2b 8d 00 08 lw r13,(sp+8)
80014e0: 37 9c 00 24 addi sp,sp,36
80014e4: c3 a0 00 00 ret
08002ddc <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
8002ddc: 37 9c ff fc addi sp,sp,-4
8002de0: 5b 9d 00 04 sw (sp+4),ra
8002de4: b8 20 18 00 mv r3,r1
8002de8: b8 40 08 00 mv r1,r2
if ( !tp )
8002dec: 44 40 00 11 be r2,r0,8002e30 <clock_gettime+0x54>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
8002df0: 34 02 00 01 mvi r2,1
8002df4: 5c 62 00 03 bne r3,r2,8002e00 <clock_gettime+0x24>
_TOD_Get(tp);
8002df8: f8 00 06 f2 calli 80049c0 <_TOD_Get>
8002dfc: e0 00 00 06 bi 8002e14 <clock_gettime+0x38>
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
8002e00: 34 02 00 04 mvi r2,4
8002e04: 44 62 00 03 be r3,r2,8002e10 <clock_gettime+0x34> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
8002e08: 34 02 00 02 mvi r2,2
8002e0c: 5c 62 00 04 bne r3,r2,8002e1c <clock_gettime+0x40>
_TOD_Get_uptime_as_timespec( tp );
8002e10: f8 00 07 0e calli 8004a48 <_TOD_Get_uptime_as_timespec>
return 0;
8002e14: 34 01 00 00 mvi r1,0
8002e18: e0 00 00 0a bi 8002e40 <clock_gettime+0x64>
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
8002e1c: 34 01 00 03 mvi r1,3
8002e20: 5c 61 00 04 bne r3,r1,8002e30 <clock_gettime+0x54>
rtems_set_errno_and_return_minus_one( ENOSYS );
8002e24: f8 00 2a 9d calli 800d898 <__errno>
8002e28: 34 02 00 58 mvi r2,88
8002e2c: e0 00 00 03 bi 8002e38 <clock_gettime+0x5c>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
8002e30: f8 00 2a 9a calli 800d898 <__errno>
8002e34: 34 02 00 16 mvi r2,22
8002e38: 58 22 00 00 sw (r1+0),r2
8002e3c: 34 01 ff ff mvi r1,-1
return 0;
}
8002e40: 2b 9d 00 04 lw ra,(sp+4)
8002e44: 37 9c 00 04 addi sp,sp,4
8002e48: c3 a0 00 00 ret
08002e4c <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
8002e4c: 37 9c ff fc addi sp,sp,-4
8002e50: 5b 9d 00 04 sw (sp+4),ra
if ( !tp )
8002e54: 44 40 00 1a be r2,r0,8002ebc <clock_settime+0x70> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
8002e58: 34 03 00 01 mvi r3,1
8002e5c: 5c 23 00 11 bne r1,r3,8002ea0 <clock_settime+0x54>
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
8002e60: 78 04 08 01 mvhi r4,0x801
8002e64: 38 84 ea a4 ori r4,r4,0xeaa4
8002e68: 28 43 00 00 lw r3,(r2+0)
8002e6c: 28 81 00 00 lw r1,(r4+0)
8002e70: 54 61 00 02 bgu r3,r1,8002e78 <clock_settime+0x2c>
8002e74: e0 00 00 12 bi 8002ebc <clock_settime+0x70>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
8002e78: 78 01 08 02 mvhi r1,0x802
8002e7c: 38 21 09 18 ori r1,r1,0x918
8002e80: 28 23 00 00 lw r3,(r1+0)
8002e84: 34 63 00 01 addi r3,r3,1
8002e88: 58 23 00 00 sw (r1+0),r3
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
8002e8c: b8 40 08 00 mv r1,r2
8002e90: f8 00 07 0b calli 8004abc <_TOD_Set>
_Thread_Enable_dispatch();
8002e94: f8 00 0d ad calli 8006548 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
8002e98: 34 01 00 00 mvi r1,0
8002e9c: e0 00 00 0c bi 8002ecc <clock_settime+0x80>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
8002ea0: 34 02 00 02 mvi r2,2
8002ea4: 44 22 00 03 be r1,r2,8002eb0 <clock_settime+0x64>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
8002ea8: 34 02 00 03 mvi r2,3
8002eac: 5c 22 00 04 bne r1,r2,8002ebc <clock_settime+0x70>
rtems_set_errno_and_return_minus_one( ENOSYS );
8002eb0: f8 00 2a 7a calli 800d898 <__errno>
8002eb4: 34 02 00 58 mvi r2,88
8002eb8: e0 00 00 03 bi 8002ec4 <clock_settime+0x78>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
8002ebc: f8 00 2a 77 calli 800d898 <__errno>
8002ec0: 34 02 00 16 mvi r2,22
8002ec4: 58 22 00 00 sw (r1+0),r2
8002ec8: 34 01 ff ff mvi r1,-1
return 0;
}
8002ecc: 2b 9d 00 04 lw ra,(sp+4)
8002ed0: 37 9c 00 04 addi sp,sp,4
8002ed4: c3 a0 00 00 ret
080012b0 <ctermid>:
static char *ctermid_name = "/dev/console";
char *ctermid(
char *s
)
{
80012b0: 37 9c ff f8 addi sp,sp,-8 <== NOT EXECUTED
80012b4: 5b 8b 00 08 sw (sp+8),r11 <== NOT EXECUTED
80012b8: 5b 9d 00 04 sw (sp+4),ra <== NOT EXECUTED
80012bc: 78 02 08 01 mvhi r2,0x801 <== NOT EXECUTED
80012c0: b8 20 58 00 mv r11,r1 <== NOT EXECUTED
80012c4: 38 42 00 08 ori r2,r2,0x8 <== NOT EXECUTED
if ( !s )
80012c8: 44 20 00 03 be r1,r0,80012d4 <ctermid+0x24> <== NOT EXECUTED
/*
* We have no way of knowing the length of the user provided buffer.
* It may not be large enough but there is no way to know that. :(
* So this is a potential buffer owerrun that we can do nothing about.
*/
strcpy( s, ctermid_name );
80012cc: f8 00 27 f7 calli 800b2a8 <strcpy> <== NOT EXECUTED
return s;
80012d0: e0 00 00 02 bi 80012d8 <ctermid+0x28> <== NOT EXECUTED
char *ctermid(
char *s
)
{
if ( !s )
return ctermid_name;
80012d4: b8 40 58 00 mv r11,r2 <== NOT EXECUTED
* It may not be large enough but there is no way to know that. :(
* So this is a potential buffer owerrun that we can do nothing about.
*/
strcpy( s, ctermid_name );
return s;
}
80012d8: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
80012dc: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
80012e0: 2b 8b 00 08 lw r11,(sp+8) <== NOT EXECUTED
80012e4: 37 9c 00 08 addi sp,sp,8 <== NOT EXECUTED
80012e8: c3 a0 00 00 ret <== NOT EXECUTED
08009704 <devFS_evaluate_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
8009704: 37 9c ff e0 addi sp,sp,-32
8009708: 5b 8b 00 20 sw (sp+32),r11
800970c: 5b 8c 00 1c sw (sp+28),r12
8009710: 5b 8d 00 18 sw (sp+24),r13
8009714: 5b 8e 00 14 sw (sp+20),r14
8009718: 5b 8f 00 10 sw (sp+16),r15
800971c: 5b 90 00 0c sw (sp+12),r16
8009720: 5b 91 00 08 sw (sp+8),r17
8009724: 5b 9d 00 04 sw (sp+4),ra
8009728: b8 80 58 00 mv r11,r4
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
800972c: 34 04 ff f8 mvi r4,-8
8009730: a0 64 20 00 and r4,r3,r4
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
8009734: b8 20 88 00 mv r17,r1
8009738: b8 40 80 00 mv r16,r2
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
800973c: 44 80 00 04 be r4,r0,800974c <devFS_evaluate_path+0x48> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
8009740: f8 00 0d f1 calli 800cf04 <__errno> <== NOT EXECUTED
8009744: 34 02 00 01 mvi r2,1 <== NOT EXECUTED
8009748: e0 00 00 28 bi 80097e8 <devFS_evaluate_path+0xe4> <== NOT EXECUTED
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
800974c: 29 6c 00 00 lw r12,(r11+0)
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
8009750: 78 0d 08 01 mvhi r13,0x801
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
8009754: 34 0e 00 00 mvi r14,0
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
8009758: 39 ad d0 14 ori r13,r13,0xd014
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
800975c: 5d 84 00 1f bne r12,r4,80097d8 <devFS_evaluate_path+0xd4>
rtems_set_errno_and_return_minus_one( EFAULT );
8009760: f8 00 0d e9 calli 800cf04 <__errno>
8009764: 34 02 00 0e mvi r2,14
8009768: e0 00 00 20 bi 80097e8 <devFS_evaluate_path+0xe4>
for (i = 0; i < rtems_device_table_size; i++) {
if (!device_name_table[i].device_name)
800976c: 29 8f 00 00 lw r15,(r12+0)
8009770: 45 e0 00 18 be r15,r0,80097d0 <devFS_evaluate_path+0xcc>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
8009774: ba 20 08 00 mv r1,r17
8009778: b9 e0 10 00 mv r2,r15
800977c: ba 00 18 00 mv r3,r16
8009780: f8 00 14 42 calli 800e888 <strncmp>
8009784: b8 20 20 00 mv r4,r1
8009788: 5c 20 00 12 bne r1,r0,80097d0 <devFS_evaluate_path+0xcc>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
800978c: b5 f0 78 00 add r15,r15,r16
8009790: 41 e1 00 00 lbu r1,(r15+0)
8009794: 5c 24 00 0f bne r1,r4,80097d0 <devFS_evaluate_path+0xcc> <== NEVER TAKEN
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
8009798: 78 01 08 01 mvhi r1,0x801
800979c: 38 21 d1 70 ori r1,r1,0xd170
80097a0: 59 61 00 08 sw (r11+8),r1
pathloc->ops = &devFS_ops;
80097a4: 78 01 08 01 mvhi r1,0x801
80097a8: 38 21 d1 28 ori r1,r1,0xd128
80097ac: 59 61 00 0c sw (r11+12),r1
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
80097b0: 78 01 08 01 mvhi r1,0x801
80097b4: 38 21 d1 b4 ori r1,r1,0xd1b4
80097b8: 28 21 00 00 lw r1,(r1+0)
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
80097bc: 59 6c 00 00 sw (r11+0),r12
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
80097c0: 28 21 00 28 lw r1,(r1+40)
80097c4: 59 61 00 10 sw (r11+16),r1
return 0;
80097c8: 34 01 00 00 mvi r1,0
80097cc: e0 00 00 09 bi 80097f0 <devFS_evaluate_path+0xec>
/* 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++) {
80097d0: 35 ce 00 01 addi r14,r14,1
80097d4: 35 8c 00 14 addi r12,r12,20
80097d8: 29 a1 00 00 lw r1,(r13+0)
80097dc: 54 2e ff e4 bgu r1,r14,800976c <devFS_evaluate_path+0x68>
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
80097e0: f8 00 0d c9 calli 800cf04 <__errno>
80097e4: 34 02 00 02 mvi r2,2
80097e8: 58 22 00 00 sw (r1+0),r2
80097ec: 34 01 ff ff mvi r1,-1
}
80097f0: 2b 9d 00 04 lw ra,(sp+4)
80097f4: 2b 8b 00 20 lw r11,(sp+32)
80097f8: 2b 8c 00 1c lw r12,(sp+28)
80097fc: 2b 8d 00 18 lw r13,(sp+24)
8009800: 2b 8e 00 14 lw r14,(sp+20)
8009804: 2b 8f 00 10 lw r15,(sp+16)
8009808: 2b 90 00 0c lw r16,(sp+12)
800980c: 2b 91 00 08 lw r17,(sp+8)
8009810: 37 9c 00 20 addi sp,sp,32
8009814: c3 a0 00 00 ret
08003bb4 <devFS_mknod>:
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
8003bb4: 37 9c ff d8 addi sp,sp,-40
8003bb8: 5b 8b 00 28 sw (sp+40),r11
8003bbc: 5b 8c 00 24 sw (sp+36),r12
8003bc0: 5b 8d 00 20 sw (sp+32),r13
8003bc4: 5b 8e 00 1c sw (sp+28),r14
8003bc8: 5b 8f 00 18 sw (sp+24),r15
8003bcc: 5b 90 00 14 sw (sp+20),r16
8003bd0: 5b 91 00 10 sw (sp+16),r17
8003bd4: 5b 92 00 0c sw (sp+12),r18
8003bd8: 5b 93 00 08 sw (sp+8),r19
8003bdc: 5b 9d 00 04 sw (sp+4),ra
8003be0: b8 40 88 00 mv r17,r2
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
8003be4: 40 22 00 00 lbu r2,(r1+0)
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
8003be8: b8 20 58 00 mv r11,r1
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
8003bec: 34 01 00 64 mvi r1,100
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
8003bf0: b8 60 98 00 mv r19,r3
8003bf4: b8 80 90 00 mv r18,r4
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
8003bf8: 5c 41 00 0a bne r2,r1,8003c20 <devFS_mknod+0x6c>
8003bfc: 41 62 00 01 lbu r2,(r11+1)
8003c00: 34 01 00 65 mvi r1,101
8003c04: 5c 41 00 07 bne r2,r1,8003c20 <devFS_mknod+0x6c> <== NEVER TAKEN
8003c08: 41 62 00 02 lbu r2,(r11+2)
8003c0c: 34 01 00 76 mvi r1,118
8003c10: 5c 41 00 04 bne r2,r1,8003c20 <devFS_mknod+0x6c> <== NEVER TAKEN
(path[2] == 'v') && (path[3] == '\0'))
8003c14: 41 62 00 03 lbu r2,(r11+3)
return 0;
8003c18: 34 01 00 00 mvi r1,0
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
(path[2] == 'v') && (path[3] == '\0'))
8003c1c: 44 40 00 3d be r2,r0,8003d10 <devFS_mknod+0x15c>
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
8003c20: 22 22 f0 00 andi r2,r17,0xf000
8003c24: 7c 41 20 00 cmpnei r1,r2,8192
8003c28: 7c 42 60 00 cmpnei r2,r2,24576
8003c2c: a0 22 08 00 and r1,r1,r2
8003c30: 44 20 00 04 be r1,r0,8003c40 <devFS_mknod+0x8c>
rtems_set_errno_and_return_minus_one( EINVAL );
8003c34: f8 00 24 b4 calli 800cf04 <__errno>
8003c38: 34 02 00 16 mvi r2,22
8003c3c: e0 00 00 0b bi 8003c68 <devFS_mknod+0xb4>
else
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
8003c40: 28 af 00 00 lw r15,(r5+0)
if (!device_name_table)
8003c44: 45 e1 00 07 be r15,r1,8003c60 <devFS_mknod+0xac>
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
8003c48: 78 0d 08 01 mvhi r13,0x801
else
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
8003c4c: b9 e0 80 00 mv r16,r15
8003c50: 34 0c ff ff mvi r12,-1
8003c54: 34 0e 00 00 mvi r14,0
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
8003c58: 39 ad d0 14 ori r13,r13,0xd014
8003c5c: e0 00 00 11 bi 8003ca0 <devFS_mknod+0xec>
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
8003c60: f8 00 24 a9 calli 800cf04 <__errno>
8003c64: 34 02 00 0e mvi r2,14
8003c68: 58 22 00 00 sw (r1+0),r2
8003c6c: 34 01 ff ff mvi r1,-1
8003c70: e0 00 00 28 bi 8003d10 <devFS_mknod+0x15c>
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
8003c74: 2a 02 00 00 lw r2,(r16+0)
8003c78: 44 40 00 07 be r2,r0,8003c94 <devFS_mknod+0xe0>
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
8003c7c: b9 60 08 00 mv r1,r11
8003c80: f8 00 2a a3 calli 800e70c <strcmp>
8003c84: 5c 20 00 05 bne r1,r0,8003c98 <devFS_mknod+0xe4>
rtems_set_errno_and_return_minus_one( EEXIST );
8003c88: f8 00 24 9f calli 800cf04 <__errno>
8003c8c: 34 02 00 11 mvi r2,17
8003c90: e3 ff ff f6 bi 8003c68 <devFS_mknod+0xb4>
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
slot = i;
8003c94: b9 c0 60 00 mv r12,r14
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
8003c98: 35 ce 00 01 addi r14,r14,1
8003c9c: 36 10 00 14 addi r16,r16,20
8003ca0: 29 a1 00 00 lw r1,(r13+0)
8003ca4: 54 2e ff f4 bgu r1,r14,8003c74 <devFS_mknod+0xc0>
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
8003ca8: 34 01 ff ff mvi r1,-1
8003cac: 5d 81 00 04 bne r12,r1,8003cbc <devFS_mknod+0x108>
rtems_set_errno_and_return_minus_one( ENOMEM );
8003cb0: f8 00 24 95 calli 800cf04 <__errno>
8003cb4: 34 02 00 0c mvi r2,12
8003cb8: e3 ff ff ec bi 8003c68 <devFS_mknod+0xb4>
_ISR_Disable(level);
8003cbc: 90 00 68 00 rcsr r13,IE
8003cc0: 34 01 ff fe mvi r1,-2
8003cc4: a1 a1 08 00 and r1,r13,r1
8003cc8: d0 01 00 00 wcsr IE,r1
device_name_table[slot].device_name = (char *)path;
8003ccc: 34 02 00 02 mvi r2,2
8003cd0: b9 80 08 00 mv r1,r12
8003cd4: fb ff fd af calli 8003390 <__ashlsi3>
8003cd8: 34 02 00 02 mvi r2,2
8003cdc: b8 20 60 00 mv r12,r1
8003ce0: fb ff fd ac calli 8003390 <__ashlsi3>
8003ce4: b5 81 08 00 add r1,r12,r1
8003ce8: b5 e1 60 00 add r12,r15,r1
8003cec: 59 8b 00 00 sw (r12+0),r11
device_name_table[slot].device_name_length = strlen(path);
8003cf0: b9 60 08 00 mv r1,r11
8003cf4: f8 00 2a b6 calli 800e7cc <strlen>
8003cf8: 59 81 00 04 sw (r12+4),r1
device_name_table[slot].major = major;
8003cfc: 59 93 00 08 sw (r12+8),r19
device_name_table[slot].minor = minor;
8003d00: 59 92 00 0c sw (r12+12),r18
device_name_table[slot].mode = mode;
8003d04: 59 91 00 10 sw (r12+16),r17
_ISR_Enable(level);
8003d08: d0 0d 00 00 wcsr IE,r13
return 0;
8003d0c: 34 01 00 00 mvi r1,0
}
8003d10: 2b 9d 00 04 lw ra,(sp+4)
8003d14: 2b 8b 00 28 lw r11,(sp+40)
8003d18: 2b 8c 00 24 lw r12,(sp+36)
8003d1c: 2b 8d 00 20 lw r13,(sp+32)
8003d20: 2b 8e 00 1c lw r14,(sp+28)
8003d24: 2b 8f 00 18 lw r15,(sp+24)
8003d28: 2b 90 00 14 lw r16,(sp+20)
8003d2c: 2b 91 00 10 lw r17,(sp+16)
8003d30: 2b 92 00 0c lw r18,(sp+12)
8003d34: 2b 93 00 08 lw r19,(sp+8)
8003d38: 37 9c 00 28 addi sp,sp,40
8003d3c: c3 a0 00 00 ret
08003208 <drainOutput>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
8003208: 37 9c ff f0 addi sp,sp,-16
800320c: 5b 8b 00 10 sw (sp+16),r11
8003210: 5b 8c 00 0c sw (sp+12),r12
8003214: 5b 8d 00 08 sw (sp+8),r13
8003218: 5b 9d 00 04 sw (sp+4),ra
800321c: b8 20 58 00 mv r11,r1
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
8003220: 28 21 00 b4 lw r1,(r1+180)
8003224: 44 20 00 17 be r1,r0,8003280 <drainOutput+0x78>
rtems_interrupt_disable (level);
8003228: 90 00 08 00 rcsr r1,IE
800322c: 34 02 ff fe mvi r2,-2
8003230: a0 22 10 00 and r2,r1,r2
8003234: d0 02 00 00 wcsr IE,r2
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
8003238: 34 0d 00 02 mvi r13,2
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);
rtems_interrupt_disable (level);
800323c: 34 0c ff fe mvi r12,-2
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) {
8003240: e0 00 00 0c bi 8003270 <drainOutput+0x68>
tty->rawOutBufState = rob_wait;
8003244: 59 6d 00 94 sw (r11+148),r13 <== NOT EXECUTED
rtems_interrupt_enable (level);
8003248: d0 01 00 00 wcsr IE,r1 <== NOT EXECUTED
sc = rtems_semaphore_obtain(
800324c: 29 61 00 8c lw r1,(r11+140) <== NOT EXECUTED
8003250: 34 02 00 00 mvi r2,0 <== NOT EXECUTED
8003254: 34 03 00 00 mvi r3,0 <== NOT EXECUTED
8003258: f8 00 09 fb calli 8005a44 <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
800325c: 44 20 00 02 be r1,r0,8003264 <drainOutput+0x5c> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
8003260: f8 00 0c 3b calli 800634c <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_interrupt_disable (level);
8003264: 90 00 08 00 rcsr r1,IE <== NOT EXECUTED
8003268: a0 2c 10 00 and r2,r1,r12 <== NOT EXECUTED
800326c: d0 02 00 00 wcsr IE,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) {
8003270: 29 63 00 84 lw r3,(r11+132)
8003274: 29 62 00 80 lw r2,(r11+128)
8003278: 5c 62 ff f3 bne r3,r2,8003244 <drainOutput+0x3c> <== NEVER TAKEN
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
800327c: d0 01 00 00 wcsr IE,r1
}
}
8003280: 2b 9d 00 04 lw ra,(sp+4)
8003284: 2b 8b 00 10 lw r11,(sp+16)
8003288: 2b 8c 00 0c lw r12,(sp+12)
800328c: 2b 8d 00 08 lw r13,(sp+8)
8003290: 37 9c 00 10 addi sp,sp,16
8003294: c3 a0 00 00 ret
08003fd8 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
8003fd8: 37 9c ff f4 addi sp,sp,-12
8003fdc: 5b 8b 00 08 sw (sp+8),r11
8003fe0: 5b 9d 00 04 sw (sp+4),ra
8003fe4: b8 40 58 00 mv r11,r2
if ((tty->termios.c_lflag & ECHOCTL) &&
8003fe8: 28 42 00 3c lw r2,(r2+60)
8003fec: 20 42 02 00 andi r2,r2,0x200
8003ff0: 44 40 00 19 be r2,r0,8004054 <echo+0x7c> <== NEVER TAKEN
iscntrl(c) && (c != '\t') && (c != '\n')) {
8003ff4: 78 02 08 02 mvhi r2,0x802
8003ff8: 38 42 52 58 ori r2,r2,0x5258
8003ffc: 28 42 00 00 lw r2,(r2+0)
8004000: 7c 23 00 09 cmpnei r3,r1,9
8004004: b4 41 10 00 add r2,r2,r1
8004008: 40 42 00 01 lbu r2,(r2+1)
800400c: 20 42 00 20 andi r2,r2,0x20
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
8004010: 7c 42 00 00 cmpnei r2,r2,0
iscntrl(c) && (c != '\t') && (c != '\n')) {
8004014: a0 43 10 00 and r2,r2,r3
8004018: 44 40 00 0f be r2,r0,8004054 <echo+0x7c>
800401c: 34 02 00 0a mvi r2,10
8004020: 44 22 00 0d be r1,r2,8004054 <echo+0x7c>
char echobuf[2];
echobuf[0] = '^';
8004024: 34 02 00 5e mvi r2,94
echobuf[1] = c ^ 0x40;
8004028: 18 21 00 40 xori r1,r1,0x40
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
800402c: 33 82 00 0c sb (sp+12),r2
echobuf[1] = c ^ 0x40;
8004030: 33 81 00 0d sb (sp+13),r1
rtems_termios_puts (echobuf, 2, tty);
8004034: 34 02 00 02 mvi r2,2
8004038: 37 81 00 0c addi r1,sp,12
800403c: b9 60 18 00 mv r3,r11
8004040: fb ff ff 34 calli 8003d10 <rtems_termios_puts>
tty->column += 2;
8004044: 29 61 00 28 lw r1,(r11+40)
8004048: 34 21 00 02 addi r1,r1,2
800404c: 59 61 00 28 sw (r11+40),r1
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
8004050: e0 00 00 03 bi 800405c <echo+0x84>
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
8004054: b9 60 10 00 mv r2,r11
8004058: fb ff ff 84 calli 8003e68 <oproc>
}
}
800405c: 2b 9d 00 04 lw ra,(sp+4)
8004060: 2b 8b 00 08 lw r11,(sp+8)
8004064: 37 9c 00 0c addi sp,sp,12
8004068: c3 a0 00 00 ret
08002690 <endgrent>:
void endgrent(void)
{
8002690: 37 9c ff fc addi sp,sp,-4
8002694: 5b 9d 00 04 sw (sp+4),ra
if (group_fp != NULL)
8002698: 78 01 08 01 mvhi r1,0x801
800269c: 38 21 67 24 ori r1,r1,0x6724
80026a0: 28 21 00 00 lw r1,(r1+0)
80026a4: 44 20 00 02 be r1,r0,80026ac <endgrent+0x1c> <== NEVER TAKEN
fclose(group_fp);
80026a8: f8 00 2c 9a calli 800d910 <fclose>
}
80026ac: 2b 9d 00 04 lw ra,(sp+4)
80026b0: 37 9c 00 04 addi sp,sp,4
80026b4: c3 a0 00 00 ret
080024c8 <endpwent>:
void endpwent(void)
{
80024c8: 37 9c ff fc addi sp,sp,-4
80024cc: 5b 9d 00 04 sw (sp+4),ra
if (passwd_fp != NULL)
80024d0: 78 01 08 01 mvhi r1,0x801
80024d4: 38 21 68 00 ori r1,r1,0x6800
80024d8: 28 21 00 00 lw r1,(r1+0)
80024dc: 44 20 00 02 be r1,r0,80024e4 <endpwent+0x1c> <== NEVER TAKEN
fclose(passwd_fp);
80024e0: f8 00 2d 0c calli 800d910 <fclose>
}
80024e4: 2b 9d 00 04 lw ra,(sp+4)
80024e8: 37 9c 00 04 addi sp,sp,4
80024ec: c3 a0 00 00 ret
0800406c <erase>:
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
800406c: 37 9c ff e0 addi sp,sp,-32
8004070: 5b 8b 00 20 sw (sp+32),r11
8004074: 5b 8c 00 1c sw (sp+28),r12
8004078: 5b 8d 00 18 sw (sp+24),r13
800407c: 5b 8e 00 14 sw (sp+20),r14
8004080: 5b 8f 00 10 sw (sp+16),r15
8004084: 5b 90 00 0c sw (sp+12),r16
8004088: 5b 91 00 08 sw (sp+8),r17
800408c: 5b 9d 00 04 sw (sp+4),ra
8004090: b8 20 58 00 mv r11,r1
if (tty->ccount == 0)
8004094: 28 21 00 20 lw r1,(r1+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)
{
8004098: b8 40 78 00 mv r15,r2
if (tty->ccount == 0)
800409c: 44 20 00 6c be r1,r0,800424c <erase+0x1e0>
return;
if (lineFlag) {
80040a0: 44 40 00 62 be r2,r0,8004228 <erase+0x1bc>
if (!(tty->termios.c_lflag & ECHO)) {
80040a4: 29 6c 00 3c lw r12,(r11+60)
80040a8: 21 81 00 08 andi r1,r12,0x8
80040ac: 5c 20 00 03 bne r1,r0,80040b8 <erase+0x4c> <== ALWAYS TAKEN
tty->ccount = 0;
80040b0: 59 60 00 20 sw (r11+32),r0 <== NOT EXECUTED
return;
80040b4: e0 00 00 66 bi 800424c <erase+0x1e0> <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
80040b8: 21 8c 00 10 andi r12,r12,0x10
80040bc: 5d 80 00 5b bne r12,r0,8004228 <erase+0x1bc> <== ALWAYS TAKEN
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
80040c0: 41 61 00 44 lbu r1,(r11+68) <== NOT EXECUTED
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
80040c4: 59 60 00 20 sw (r11+32),r0 <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
80040c8: b9 60 10 00 mv r2,r11 <== NOT EXECUTED
80040cc: fb ff ff c3 calli 8003fd8 <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
80040d0: 29 61 00 3c lw r1,(r11+60) <== NOT EXECUTED
80040d4: 20 21 00 20 andi r1,r1,0x20 <== NOT EXECUTED
80040d8: 44 2c 00 5d be r1,r12,800424c <erase+0x1e0> <== NOT EXECUTED
echo ('\n', tty);
80040dc: 34 01 00 0a mvi r1,10 <== NOT EXECUTED
80040e0: e0 00 00 0d bi 8004114 <erase+0xa8> <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
80040e4: 29 64 00 1c lw r4,(r11+28)
80040e8: 34 21 ff ff addi r1,r1,-1
80040ec: 59 61 00 20 sw (r11+32),r1
80040f0: b4 81 10 00 add r2,r4,r1
80040f4: 40 4c 00 00 lbu r12,(r2+0)
if (tty->termios.c_lflag & ECHO) {
80040f8: 29 62 00 3c lw r2,(r11+60)
80040fc: 20 43 00 08 andi r3,r2,0x8
8004100: 44 60 00 48 be r3,r0,8004220 <erase+0x1b4> <== NEVER TAKEN
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
8004104: 5d e0 00 07 bne r15,r0,8004120 <erase+0xb4>
8004108: 20 43 00 10 andi r3,r2,0x10
800410c: 5c 6f 00 05 bne r3,r15,8004120 <erase+0xb4> <== ALWAYS TAKEN
echo (tty->termios.c_cc[VERASE], tty);
8004110: 41 61 00 43 lbu r1,(r11+67) <== NOT EXECUTED
8004114: b9 60 10 00 mv r2,r11 <== NOT EXECUTED
8004118: fb ff ff b0 calli 8003fd8 <echo> <== NOT EXECUTED
800411c: e0 00 00 4c bi 800424c <erase+0x1e0> <== NOT EXECUTED
} else if (c == '\t') {
8004120: 5d 91 00 20 bne r12,r17,80041a0 <erase+0x134>
int col = tty->read_start_column;
8004124: 29 6c 00 2c lw r12,(r11+44)
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
8004128: 29 a6 00 00 lw r6,(r13+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;
int i = 0;
800412c: 34 03 00 00 mvi r3,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)
8004130: 20 42 02 00 andi r2,r2,0x200
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
8004134: e0 00 00 0f bi 8004170 <erase+0x104>
* Erase a character or line
* 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)
8004138: b4 83 28 00 add r5,r4,r3
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
800413c: 40 a5 00 00 lbu r5,(r5+0)
8004140: 34 63 00 01 addi r3,r3,1
if (c == '\t') {
8004144: 5c b1 00 03 bne r5,r17,8004150 <erase+0xe4>
col = (col | 7) + 1;
8004148: 39 8c 00 07 ori r12,r12,0x7
800414c: e0 00 00 08 bi 800416c <erase+0x100>
} else if (iscntrl (c)) {
8004150: b4 c5 28 00 add r5,r6,r5
8004154: 40 a5 00 01 lbu r5,(r5+1)
8004158: 20 a5 00 20 andi r5,r5,0x20
800415c: 44 a0 00 04 be r5,r0,800416c <erase+0x100> <== ALWAYS TAKEN
if (tty->termios.c_lflag & ECHOCTL)
8004160: 44 40 00 04 be r2,r0,8004170 <erase+0x104> <== NOT EXECUTED
col += 2;
8004164: 35 8c 00 02 addi r12,r12,2 <== NOT EXECUTED
8004168: e0 00 00 02 bi 8004170 <erase+0x104> <== NOT EXECUTED
} else {
col++;
800416c: 35 8c 00 01 addi r12,r12,1
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
8004170: 5c 61 ff f2 bne r3,r1,8004138 <erase+0xcc>
8004174: e0 00 00 08 bi 8004194 <erase+0x128>
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
8004178: ba 00 08 00 mv r1,r16
800417c: 34 02 00 01 mvi r2,1
8004180: b9 60 18 00 mv r3,r11
8004184: fb ff fe e3 calli 8003d10 <rtems_termios_puts>
tty->column--;
8004188: 29 61 00 28 lw r1,(r11+40)
800418c: 34 21 ff ff addi r1,r1,-1
8004190: 59 61 00 28 sw (r11+40),r1
}
/*
* Back up over the tab
*/
while (tty->column > col) {
8004194: 29 61 00 28 lw r1,(r11+40)
8004198: 48 2c ff f8 bg r1,r12,8004178 <erase+0x10c>
800419c: e0 00 00 21 bi 8004220 <erase+0x1b4>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
80041a0: 29 a1 00 00 lw r1,(r13+0)
80041a4: 35 8c 00 01 addi r12,r12,1
80041a8: b4 2c 08 00 add r1,r1,r12
80041ac: 40 21 00 00 lbu r1,(r1+0)
80041b0: 20 21 00 20 andi r1,r1,0x20
80041b4: 44 20 00 0b be r1,r0,80041e0 <erase+0x174> <== ALWAYS TAKEN
80041b8: 20 42 02 00 andi r2,r2,0x200 <== NOT EXECUTED
80041bc: 44 40 00 09 be r2,r0,80041e0 <erase+0x174> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
80041c0: b9 c0 08 00 mv r1,r14 <== NOT EXECUTED
80041c4: 34 02 00 03 mvi r2,3 <== NOT EXECUTED
80041c8: b9 60 18 00 mv r3,r11 <== NOT EXECUTED
80041cc: fb ff fe d1 calli 8003d10 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
80041d0: 29 61 00 28 lw r1,(r11+40) <== NOT EXECUTED
80041d4: 44 20 00 03 be r1,r0,80041e0 <erase+0x174> <== NOT EXECUTED
tty->column--;
80041d8: 34 21 ff ff addi r1,r1,-1 <== NOT EXECUTED
80041dc: 59 61 00 28 sw (r11+40),r1 <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
80041e0: 29 a1 00 00 lw r1,(r13+0)
80041e4: b4 2c 60 00 add r12,r1,r12
80041e8: 41 81 00 00 lbu r1,(r12+0)
80041ec: 20 21 00 20 andi r1,r1,0x20
80041f0: 44 20 00 04 be r1,r0,8004200 <erase+0x194> <== ALWAYS TAKEN
80041f4: 29 61 00 3c lw r1,(r11+60) <== NOT EXECUTED
80041f8: 20 21 02 00 andi r1,r1,0x200 <== NOT EXECUTED
80041fc: 44 20 00 09 be r1,r0,8004220 <erase+0x1b4> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
8004200: b9 c0 08 00 mv r1,r14
8004204: 34 02 00 03 mvi r2,3
8004208: b9 60 18 00 mv r3,r11
800420c: fb ff fe c1 calli 8003d10 <rtems_termios_puts>
if (tty->column)
8004210: 29 61 00 28 lw r1,(r11+40)
8004214: 44 20 00 03 be r1,r0,8004220 <erase+0x1b4> <== NEVER TAKEN
tty->column--;
8004218: 34 21 ff ff addi r1,r1,-1
800421c: 59 61 00 28 sw (r11+40),r1
}
}
}
if (!lineFlag)
8004220: 5d e0 00 09 bne r15,r0,8004244 <erase+0x1d8>
8004224: e0 00 00 0a bi 800424c <erase+0x1e0>
8004228: 78 0d 08 02 mvhi r13,0x802
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);
800422c: 78 0e 08 02 mvhi r14,0x802
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
8004230: 78 10 08 02 mvhi r16,0x802
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);
} else if (c == '\t') {
8004234: 34 11 00 09 mvi r17,9
8004238: 39 ad 52 58 ori r13,r13,0x5258
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);
800423c: 39 ce 39 04 ori r14,r14,0x3904
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
8004240: 3a 10 39 00 ori r16,r16,0x3900
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
8004244: 29 61 00 20 lw r1,(r11+32)
8004248: 5c 20 ff a7 bne r1,r0,80040e4 <erase+0x78>
}
}
if (!lineFlag)
break;
}
}
800424c: 2b 9d 00 04 lw ra,(sp+4)
8004250: 2b 8b 00 20 lw r11,(sp+32)
8004254: 2b 8c 00 1c lw r12,(sp+28)
8004258: 2b 8d 00 18 lw r13,(sp+24)
800425c: 2b 8e 00 14 lw r14,(sp+20)
8004260: 2b 8f 00 10 lw r15,(sp+16)
8004264: 2b 90 00 0c lw r16,(sp+12)
8004268: 2b 91 00 08 lw r17,(sp+8)
800426c: 37 9c 00 20 addi sp,sp,32
8004270: c3 a0 00 00 ret
08001e44 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
8001e44: 37 9c ff c4 addi sp,sp,-60
8001e48: 5b 8b 00 20 sw (sp+32),r11
8001e4c: 5b 8c 00 1c sw (sp+28),r12
8001e50: 5b 8d 00 18 sw (sp+24),r13
8001e54: 5b 8e 00 14 sw (sp+20),r14
8001e58: 5b 8f 00 10 sw (sp+16),r15
8001e5c: 5b 90 00 0c sw (sp+12),r16
8001e60: 5b 91 00 08 sw (sp+8),r17
8001e64: 5b 9d 00 04 sw (sp+4),ra
8001e68: 5b 82 00 24 sw (sp+36),r2
8001e6c: b8 40 68 00 mv r13,r2
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
8001e70: 78 02 08 01 mvhi r2,0x801
int fcntl(
int fd,
int cmd,
...
)
{
8001e74: 5b 83 00 28 sw (sp+40),r3
8001e78: 5b 84 00 2c sw (sp+44),r4
8001e7c: 5b 85 00 30 sw (sp+48),r5
8001e80: 5b 86 00 34 sw (sp+52),r6
8001e84: 5b 87 00 38 sw (sp+56),r7
8001e88: 5b 88 00 3c sw (sp+60),r8
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
8001e8c: 38 42 60 10 ori r2,r2,0x6010
8001e90: 28 51 00 00 lw r17,(r2+0)
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
8001e94: 37 8e 00 28 addi r14,sp,40
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
8001e98: 56 21 00 02 bgu r17,r1,8001ea0 <fcntl+0x5c>
8001e9c: e0 00 00 0a bi 8001ec4 <fcntl+0x80>
iop = rtems_libio_iop( fd );
8001ea0: 78 02 08 01 mvhi r2,0x801
8001ea4: 38 42 67 8c ori r2,r2,0x678c
8001ea8: 28 50 00 00 lw r16,(r2+0)
8001eac: 34 02 00 06 mvi r2,6
8001eb0: f8 00 46 ac calli 8013960 <__ashlsi3>
8001eb4: b6 01 58 00 add r11,r16,r1
rtems_libio_check_is_open(iop);
8001eb8: 29 6c 00 18 lw r12,(r11+24)
8001ebc: 21 81 01 00 andi r1,r12,0x100
8001ec0: 5c 20 00 04 bne r1,r0,8001ed0 <fcntl+0x8c>
8001ec4: f8 00 2e 88 calli 800d8e4 <__errno>
8001ec8: 34 02 00 09 mvi r2,9
8001ecc: e0 00 00 49 bi 8001ff0 <fcntl+0x1ac>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
8001ed0: 34 01 00 09 mvi r1,9
8001ed4: 55 a1 00 45 bgu r13,r1,8001fe8 <fcntl+0x1a4>
8001ed8: 78 0f 08 01 mvhi r15,0x801
8001edc: b9 a0 08 00 mv r1,r13
8001ee0: 34 02 00 02 mvi r2,2
8001ee4: f8 00 46 9f calli 8013960 <__ashlsi3>
8001ee8: 39 ef 4b b0 ori r15,r15,0x4bb0
8001eec: b5 e1 08 00 add r1,r15,r1
8001ef0: 28 21 00 00 lw r1,(r1+0)
8001ef4: c0 20 00 00 b r1
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
8001ef8: 29 cc 00 00 lw r12,(r14+0)
if ( fd2 )
8001efc: 45 80 00 08 be r12,r0,8001f1c <fcntl+0xd8>
diop = rtems_libio_iop( fd2 );
8001f00: 34 03 00 00 mvi r3,0
8001f04: 51 91 00 09 bgeu r12,r17,8001f28 <fcntl+0xe4> <== NEVER TAKEN
8001f08: b9 80 08 00 mv r1,r12
8001f0c: 34 02 00 06 mvi r2,6
8001f10: f8 00 46 94 calli 8013960 <__ashlsi3>
8001f14: b6 01 18 00 add r3,r16,r1
8001f18: e0 00 00 04 bi 8001f28 <fcntl+0xe4>
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
8001f1c: f8 00 01 e6 calli 80026b4 <rtems_libio_allocate>
8001f20: b8 20 18 00 mv r3,r1
if ( diop == 0 ) {
8001f24: 44 2c 00 3e be r1,r12,800201c <fcntl+0x1d8> <== NEVER TAKEN
ret = -1;
break;
}
}
diop->flags = iop->flags;
8001f28: 29 61 00 18 lw r1,(r11+24)
diop->pathinfo = iop->pathinfo;
8001f2c: 29 62 00 28 lw r2,(r11+40)
8001f30: 29 66 00 1c lw r6,(r11+28)
ret = -1;
break;
}
}
diop->flags = iop->flags;
8001f34: 58 61 00 18 sw (r3+24),r1
diop->pathinfo = iop->pathinfo;
8001f38: 29 61 00 2c lw r1,(r11+44)
8001f3c: 29 65 00 20 lw r5,(r11+32)
8001f40: 29 64 00 24 lw r4,(r11+36)
8001f44: 58 61 00 2c sw (r3+44),r1
ret = (int) (diop - rtems_libio_iops);
8001f48: 78 01 08 01 mvhi r1,0x801
8001f4c: 38 21 67 8c ori r1,r1,0x678c
8001f50: 28 21 00 00 lw r1,(r1+0)
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
8001f54: 58 62 00 28 sw (r3+40),r2
8001f58: 58 66 00 1c sw (r3+28),r6
8001f5c: 58 65 00 20 sw (r3+32),r5
8001f60: 58 64 00 24 sw (r3+36),r4
ret = (int) (diop - rtems_libio_iops);
8001f64: c8 61 08 00 sub r1,r3,r1
8001f68: 34 02 00 06 mvi r2,6
8001f6c: f8 00 46 a4 calli 80139fc <__ashrsi3>
8001f70: e0 00 00 0e bi 8001fa8 <fcntl+0x164>
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
8001f74: 21 8c 08 00 andi r12,r12,0x800
8001f78: 7d 8c 00 00 cmpnei r12,r12,0
8001f7c: e0 00 00 1f bi 8001ff8 <fcntl+0x1b4>
* 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 ) )
8001f80: 29 c1 00 00 lw r1,(r14+0)
8001f84: 44 20 00 03 be r1,r0,8001f90 <fcntl+0x14c>
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
8001f88: 39 8c 08 00 ori r12,r12,0x800
8001f8c: e0 00 00 03 bi 8001f98 <fcntl+0x154>
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
8001f90: 34 01 f7 ff mvi r1,-2049
8001f94: a1 81 60 00 and r12,r12,r1
8001f98: 59 6c 00 18 sw (r11+24),r12
8001f9c: e0 00 00 0e bi 8001fd4 <fcntl+0x190>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
8001fa0: b9 80 08 00 mv r1,r12
8001fa4: f8 00 01 b0 calli 8002664 <rtems_libio_to_fcntl_flags>
8001fa8: b8 20 60 00 mv r12,r1
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
8001fac: 48 01 00 1d bg r0,r1,8002020 <fcntl+0x1dc> <== NEVER TAKEN
8001fb0: e0 00 00 12 bi 8001ff8 <fcntl+0x1b4>
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 ) );
8001fb4: 29 c1 00 00 lw r1,(r14+0)
8001fb8: f8 00 01 95 calli 800260c <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
8001fbc: 29 63 00 18 lw r3,(r11+24)
8001fc0: 34 02 fd fe mvi r2,-514
8001fc4: 20 21 02 01 andi r1,r1,0x201
8001fc8: a0 43 10 00 and r2,r2,r3
8001fcc: b8 22 08 00 or r1,r1,r2
8001fd0: 59 61 00 18 sw (r11+24),r1
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
8001fd4: 34 0c 00 00 mvi r12,0
8001fd8: e0 00 00 08 bi 8001ff8 <fcntl+0x1b4>
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
8001fdc: f8 00 2e 42 calli 800d8e4 <__errno>
8001fe0: 34 02 00 86 mvi r2,134
8001fe4: e0 00 00 03 bi 8001ff0 <fcntl+0x1ac>
ret = -1;
break;
default:
errno = EINVAL;
8001fe8: f8 00 2e 3f calli 800d8e4 <__errno>
8001fec: 34 02 00 16 mvi r2,22
8001ff0: 58 22 00 00 sw (r1+0),r2
8001ff4: e0 00 00 0a bi 800201c <fcntl+0x1d8>
* 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 );
8001ff8: 29 61 00 24 lw r1,(r11+36)
8001ffc: b9 60 10 00 mv r2,r11
8002000: 28 23 00 30 lw r3,(r1+48)
8002004: b9 a0 08 00 mv r1,r13
8002008: d8 60 00 00 call r3
800200c: b8 20 58 00 mv r11,r1
if (err) {
8002010: 44 20 00 04 be r1,r0,8002020 <fcntl+0x1dc> <== ALWAYS TAKEN
errno = err;
8002014: f8 00 2e 34 calli 800d8e4 <__errno> <== NOT EXECUTED
8002018: 58 2b 00 00 sw (r1+0),r11 <== NOT EXECUTED
ret = -1;
800201c: 34 0c ff ff mvi r12,-1
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
8002020: b9 80 08 00 mv r1,r12
8002024: 2b 9d 00 04 lw ra,(sp+4)
8002028: 2b 8b 00 20 lw r11,(sp+32)
800202c: 2b 8c 00 1c lw r12,(sp+28)
8002030: 2b 8d 00 18 lw r13,(sp+24)
8002034: 2b 8e 00 14 lw r14,(sp+20)
8002038: 2b 8f 00 10 lw r15,(sp+16)
800203c: 2b 90 00 0c lw r16,(sp+12)
8002040: 2b 91 00 08 lw r17,(sp+8)
8002044: 37 9c 00 3c addi sp,sp,60
8002048: c3 a0 00 00 ret
0800a42c <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
800a42c: 37 9c ff d4 addi sp,sp,-44
800a430: 5b 8b 00 24 sw (sp+36),r11
800a434: 5b 8c 00 20 sw (sp+32),r12
800a438: 5b 8d 00 1c sw (sp+28),r13
800a43c: 5b 8e 00 18 sw (sp+24),r14
800a440: 5b 8f 00 14 sw (sp+20),r15
800a444: 5b 90 00 10 sw (sp+16),r16
800a448: 5b 91 00 0c sw (sp+12),r17
800a44c: 5b 92 00 08 sw (sp+8),r18
800a450: 5b 9d 00 04 sw (sp+4),ra
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
800a454: 78 0b 08 02 mvhi r11,0x802
800a458: 39 6b 37 3c ori r11,r11,0x373c
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
800a45c: b8 20 78 00 mv r15,r1
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
800a460: 29 61 00 00 lw r1,(r11+0)
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
800a464: b8 40 70 00 mv r14,r2
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
800a468: 5c 20 00 18 bne r1,r0,800a4c8 <fifo_open+0x9c>
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 );
800a46c: 78 01 08 02 mvhi r1,0x802
800a470: 38 21 37 b8 ori r1,r1,0x37b8
800a474: 28 21 00 00 lw r1,(r1+0)
800a478: 34 02 00 00 mvi r2,0
800a47c: 34 03 00 00 mvi r3,0
800a480: fb ff eb 2e calli 8005138 <rtems_semaphore_obtain>
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
800a484: 29 61 00 00 lw r1,(r11+0)
free(pipe);
}
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
800a488: 34 0c 00 00 mvi r12,0
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
800a48c: 5c 2c 00 0a bne r1,r12,800a4b4 <fifo_open+0x88> <== NEVER TAKEN
sc = rtems_semaphore_create(
800a490: 78 02 08 02 mvhi r2,0x802
800a494: 38 42 21 18 ori r2,r2,0x2118
800a498: 28 41 00 00 lw r1,(r2+0)
800a49c: 34 03 00 54 mvi r3,84
800a4a0: 34 02 00 01 mvi r2,1
800a4a4: 34 04 00 00 mvi r4,0
800a4a8: b9 60 28 00 mv r5,r11
800a4ac: fb ff ea 77 calli 8004e88 <rtems_semaphore_create>
800a4b0: b8 20 60 00 mv r12,r1
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
800a4b4: 78 01 08 02 mvhi r1,0x802
800a4b8: 38 21 37 b8 ori r1,r1,0x37b8
800a4bc: 28 21 00 00 lw r1,(r1+0)
800a4c0: fb ff eb 6e calli 8005278 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
800a4c4: 5d 80 00 08 bne r12,r0,800a4e4 <fifo_open+0xb8>
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
800a4c8: 78 01 08 02 mvhi r1,0x802
800a4cc: 38 21 37 3c ori r1,r1,0x373c
800a4d0: 28 21 00 00 lw r1,(r1+0)
800a4d4: 34 02 00 00 mvi r2,0
800a4d8: 34 03 00 00 mvi r3,0
800a4dc: fb ff eb 17 calli 8005138 <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
800a4e0: 44 20 00 03 be r1,r0,800a4ec <fifo_open+0xc0> <== ALWAYS TAKEN
800a4e4: 34 0c ff f4 mvi r12,-12
800a4e8: e0 00 00 cd bi 800a81c <fifo_open+0x3f0>
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
800a4ec: 29 eb 00 00 lw r11,(r15+0)
800a4f0: 34 0c 00 00 mvi r12,0
if (pipe == NULL) {
800a4f4: 5d 60 00 55 bne r11,r0,800a648 <fifo_open+0x21c>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
800a4f8: 34 01 00 34 mvi r1,52
800a4fc: fb ff e5 dd calli 8003c70 <malloc>
800a500: b8 20 58 00 mv r11,r1
800a504: b8 20 80 00 mv r16,r1
if (pipe == NULL)
800a508: 44 20 00 4e be r1,r0,800a640 <fifo_open+0x214>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
800a50c: 34 02 00 00 mvi r2,0
800a510: 34 03 00 34 mvi r3,52
800a514: f8 00 17 45 calli 8010228 <memset>
pipe->Size = PIPE_BUF;
800a518: 34 01 02 00 mvi r1,512
800a51c: 59 61 00 04 sw (r11+4),r1
pipe->Buffer = malloc(pipe->Size);
800a520: fb ff e5 d4 calli 8003c70 <malloc>
800a524: 59 61 00 00 sw (r11+0),r1
if (! pipe->Buffer)
800a528: 44 20 00 44 be r1,r0,800a638 <fifo_open+0x20c> <== NEVER TAKEN
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
800a52c: 78 0d 08 02 mvhi r13,0x802
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
800a530: 78 03 08 02 mvhi r3,0x802
800a534: 38 63 21 1c ori r3,r3,0x211c
rtems_build_name ('P', 'I', 'r', c),
800a538: 39 ad 31 54 ori r13,r13,0x3154
800a53c: 41 a2 00 00 lbu r2,(r13+0)
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
800a540: 28 61 00 00 lw r1,(r3+0)
800a544: 35 64 00 2c addi r4,r11,44
800a548: 34 03 00 00 mvi r3,0
800a54c: b8 41 08 00 or r1,r2,r1
800a550: 34 02 00 00 mvi r2,0
800a554: f8 00 07 22 calli 800c1dc <rtems_barrier_create>
800a558: 5c 20 00 36 bne r1,r0,800a630 <fifo_open+0x204>
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
800a55c: 78 03 08 02 mvhi r3,0x802
800a560: 38 63 21 20 ori r3,r3,0x2120
rtems_build_name ('P', 'I', 'w', c),
800a564: 41 a2 00 00 lbu r2,(r13+0)
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(
800a568: 28 61 00 00 lw r1,(r3+0)
800a56c: 35 64 00 30 addi r4,r11,48
800a570: 34 03 00 00 mvi r3,0
800a574: b8 41 08 00 or r1,r2,r1
800a578: 34 02 00 00 mvi r2,0
800a57c: f8 00 07 18 calli 800c1dc <rtems_barrier_create>
800a580: 5c 20 00 2a bne r1,r0,800a628 <fifo_open+0x1fc>
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
800a584: 78 03 08 02 mvhi r3,0x802
800a588: 38 63 21 24 ori r3,r3,0x2124
rtems_build_name ('P', 'I', 's', c), 1,
800a58c: 41 a2 00 00 lbu r2,(r13+0)
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(
800a590: 28 61 00 00 lw r1,(r3+0)
800a594: 34 04 00 00 mvi r4,0
800a598: 34 03 00 10 mvi r3,16
800a59c: b8 41 08 00 or r1,r2,r1
800a5a0: 35 65 00 28 addi r5,r11,40
800a5a4: 34 02 00 01 mvi r2,1
800a5a8: fb ff ea 38 calli 8004e88 <rtems_semaphore_create>
800a5ac: 5c 20 00 1d bne r1,r0,800a620 <fifo_open+0x1f4>
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
800a5b0: 29 62 00 2c lw r2,(r11+44)
800a5b4: 78 10 08 02 mvhi r16,0x802
800a5b8: 3a 10 41 80 ori r16,r16,0x4180
/* 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
800a5bc: 37 92 00 28 addi r18,sp,40
800a5c0: ba 40 18 00 mv r3,r18
800a5c4: ba 00 08 00 mv r1,r16
800a5c8: fb ff f1 58 calli 8006b28 <_Objects_Get>
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
800a5cc: 28 22 00 4c lw r2,(r1+76)
800a5d0: 78 11 10 00 mvhi r17,0x1000
800a5d4: b8 51 10 00 or r2,r2,r17
800a5d8: 58 22 00 4c sw (r1+76),r2
_Thread_Enable_dispatch();
800a5dc: fb ff f4 fd calli 80079d0 <_Thread_Enable_dispatch>
800a5e0: 29 62 00 30 lw r2,(r11+48)
800a5e4: ba 40 18 00 mv r3,r18
800a5e8: ba 00 08 00 mv r1,r16
800a5ec: fb ff f1 4f calli 8006b28 <_Objects_Get>
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
800a5f0: 28 22 00 4c lw r2,(r1+76)
800a5f4: b8 51 88 00 or r17,r2,r17
800a5f8: 58 31 00 4c sw (r1+76),r17
_Thread_Enable_dispatch();
800a5fc: fb ff f4 f5 calli 80079d0 <_Thread_Enable_dispatch>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
800a600: 41 a1 00 00 lbu r1,(r13+0)
800a604: 34 22 00 01 addi r2,r1,1
800a608: 31 a2 00 00 sb (r13+0),r2
800a60c: 34 02 00 7a mvi r2,122
800a610: 5c 22 00 0e bne r1,r2,800a648 <fifo_open+0x21c>
c = 'a';
800a614: 34 01 00 61 mvi r1,97
800a618: 31 a1 00 00 sb (r13+0),r1
800a61c: e0 00 00 0b bi 800a648 <fifo_open+0x21c>
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
800a620: 29 61 00 30 lw r1,(r11+48)
800a624: f8 00 07 2a calli 800c2cc <rtems_barrier_delete>
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
800a628: 2a 01 00 2c lw r1,(r16+44)
800a62c: f8 00 07 28 calli 800c2cc <rtems_barrier_delete>
err_rbar:
free(pipe->Buffer);
800a630: 2a 01 00 00 lw r1,(r16+0)
800a634: fb ff e3 46 calli 800334c <free>
err_buf:
free(pipe);
800a638: ba 00 08 00 mv r1,r16
800a63c: fb ff e3 44 calli 800334c <free>
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
800a640: 34 0c ff f4 mvi r12,-12
800a644: e0 00 00 0e bi 800a67c <fifo_open+0x250>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
800a648: 29 61 00 28 lw r1,(r11+40)
800a64c: 34 02 00 00 mvi r2,0
800a650: 34 03 00 00 mvi r3,0
800a654: fb ff ea b9 calli 8005138 <rtems_semaphore_obtain>
800a658: 44 20 00 02 be r1,r0,800a660 <fifo_open+0x234> <== ALWAYS TAKEN
err = -EINTR;
800a65c: 34 0c ff fc mvi r12,-4 <== NOT EXECUTED
if (*pipep == NULL) {
800a660: 29 e1 00 00 lw r1,(r15+0)
800a664: 5c 20 00 06 bne r1,r0,800a67c <fifo_open+0x250>
if (err)
800a668: 45 81 00 04 be r12,r1,800a678 <fifo_open+0x24c> <== ALWAYS TAKEN
pipe_free(pipe);
800a66c: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
800a670: fb ff ff 2b calli 800a31c <pipe_free> <== NOT EXECUTED
800a674: e0 00 00 02 bi 800a67c <fifo_open+0x250> <== NOT EXECUTED
else
*pipep = pipe;
800a678: 59 eb 00 00 sw (r15+0),r11
}
out:
pipe_unlock();
800a67c: fb ff ff 1f calli 800a2f8 <pipe_unlock>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
800a680: 5d 80 00 67 bne r12,r0,800a81c <fifo_open+0x3f0>
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
800a684: 29 c1 00 18 lw r1,(r14+24)
800a688: 34 02 00 04 mvi r2,4
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
800a68c: 29 eb 00 00 lw r11,(r15+0)
switch (LIBIO_ACCMODE(iop)) {
800a690: 20 21 00 06 andi r1,r1,0x6
800a694: 44 22 00 24 be r1,r2,800a724 <fifo_open+0x2f8>
800a698: 34 02 00 06 mvi r2,6
800a69c: 44 22 00 45 be r1,r2,800a7b0 <fifo_open+0x384>
800a6a0: 34 02 00 02 mvi r2,2
800a6a4: 5c 22 00 57 bne r1,r2,800a800 <fifo_open+0x3d4> <== NEVER TAKEN
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
800a6a8: 29 61 00 20 lw r1,(r11+32)
800a6ac: 34 21 00 01 addi r1,r1,1
800a6b0: 59 61 00 20 sw (r11+32),r1
if (pipe->Readers ++ == 0)
800a6b4: 29 61 00 10 lw r1,(r11+16)
800a6b8: 34 22 00 01 addi r2,r1,1
800a6bc: 59 62 00 10 sw (r11+16),r2
800a6c0: 5c 20 00 04 bne r1,r0,800a6d0 <fifo_open+0x2a4> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
800a6c4: 29 61 00 30 lw r1,(r11+48)
800a6c8: 37 82 00 2c addi r2,sp,44
800a6cc: f8 00 07 30 calli 800c38c <rtems_barrier_release>
if (pipe->Writers == 0) {
800a6d0: 29 61 00 14 lw r1,(r11+20)
800a6d4: 5c 20 00 4b bne r1,r0,800a800 <fifo_open+0x3d4>
/* Not an error */
if (LIBIO_NODELAY(iop))
800a6d8: 29 c2 00 18 lw r2,(r14+24)
800a6dc: 20 42 00 01 andi r2,r2,0x1
800a6e0: 5c 41 00 48 bne r2,r1,800a800 <fifo_open+0x3d4>
break;
prevCounter = pipe->writerCounter;
800a6e4: 29 70 00 24 lw r16,(r11+36)
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
800a6e8: 29 61 00 28 lw r1,(r11+40)
800a6ec: fb ff ea e3 calli 8005278 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
800a6f0: 29 61 00 2c lw r1,(r11+44)
800a6f4: 34 02 00 00 mvi r2,0
800a6f8: f8 00 07 42 calli 800c400 <rtems_barrier_wait>
800a6fc: b8 20 68 00 mv r13,r1
800a700: 5c 20 00 43 bne r1,r0,800a80c <fifo_open+0x3e0> <== NEVER TAKEN
goto out_error;
if (! PIPE_LOCK(pipe))
800a704: 29 61 00 28 lw r1,(r11+40)
800a708: 34 02 00 00 mvi r2,0
800a70c: 34 03 00 00 mvi r3,0
800a710: fb ff ea 8a calli 8005138 <rtems_semaphore_obtain>
800a714: 5c 2d 00 3e bne r1,r13,800a80c <fifo_open+0x3e0> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->writerCounter);
800a718: 29 61 00 24 lw r1,(r11+36)
800a71c: 46 01 ff f3 be r16,r1,800a6e8 <fifo_open+0x2bc> <== NEVER TAKEN
800a720: e0 00 00 38 bi 800a800 <fifo_open+0x3d4>
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
800a724: 29 61 00 24 lw r1,(r11+36)
800a728: 34 21 00 01 addi r1,r1,1
800a72c: 59 61 00 24 sw (r11+36),r1
if (pipe->Writers ++ == 0)
800a730: 29 61 00 14 lw r1,(r11+20)
800a734: 34 22 00 01 addi r2,r1,1
800a738: 59 62 00 14 sw (r11+20),r2
800a73c: 5c 20 00 04 bne r1,r0,800a74c <fifo_open+0x320> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
800a740: 29 61 00 2c lw r1,(r11+44)
800a744: 37 82 00 2c addi r2,sp,44
800a748: f8 00 07 11 calli 800c38c <rtems_barrier_release>
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
800a74c: 29 61 00 10 lw r1,(r11+16)
800a750: 5c 20 00 2c bne r1,r0,800a800 <fifo_open+0x3d4>
800a754: 29 c2 00 18 lw r2,(r14+24)
800a758: 20 42 00 01 andi r2,r2,0x1
800a75c: 44 41 00 05 be r2,r1,800a770 <fifo_open+0x344>
PIPE_UNLOCK(pipe);
800a760: 29 61 00 28 lw r1,(r11+40)
err = -ENXIO;
800a764: 34 0c ff fa mvi r12,-6
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
800a768: fb ff ea c4 calli 8005278 <rtems_semaphore_release>
err = -ENXIO;
goto out_error;
800a76c: e0 00 00 29 bi 800a810 <fifo_open+0x3e4>
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
800a770: 29 70 00 20 lw r16,(r11+32)
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
800a774: 29 61 00 28 lw r1,(r11+40)
800a778: fb ff ea c0 calli 8005278 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
800a77c: 29 61 00 30 lw r1,(r11+48)
800a780: 34 02 00 00 mvi r2,0
800a784: f8 00 07 1f calli 800c400 <rtems_barrier_wait>
800a788: b8 20 68 00 mv r13,r1
800a78c: 5c 20 00 20 bne r1,r0,800a80c <fifo_open+0x3e0> <== NEVER TAKEN
goto out_error;
if (! PIPE_LOCK(pipe))
800a790: 29 61 00 28 lw r1,(r11+40)
800a794: 34 02 00 00 mvi r2,0
800a798: 34 03 00 00 mvi r3,0
800a79c: fb ff ea 67 calli 8005138 <rtems_semaphore_obtain>
800a7a0: 5c 2d 00 1b bne r1,r13,800a80c <fifo_open+0x3e0> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->readerCounter);
800a7a4: 29 61 00 20 lw r1,(r11+32)
800a7a8: 46 01 ff f3 be r16,r1,800a774 <fifo_open+0x348> <== NEVER TAKEN
800a7ac: e0 00 00 15 bi 800a800 <fifo_open+0x3d4>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
800a7b0: 29 61 00 20 lw r1,(r11+32)
800a7b4: 34 21 00 01 addi r1,r1,1
800a7b8: 59 61 00 20 sw (r11+32),r1
if (pipe->Readers ++ == 0)
800a7bc: 29 61 00 10 lw r1,(r11+16)
800a7c0: 34 22 00 01 addi r2,r1,1
800a7c4: 59 62 00 10 sw (r11+16),r2
800a7c8: 5c 20 00 04 bne r1,r0,800a7d8 <fifo_open+0x3ac> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
800a7cc: 29 61 00 30 lw r1,(r11+48)
800a7d0: 37 82 00 2c addi r2,sp,44
800a7d4: f8 00 06 ee calli 800c38c <rtems_barrier_release>
pipe->writerCounter ++;
800a7d8: 29 61 00 24 lw r1,(r11+36)
800a7dc: 34 21 00 01 addi r1,r1,1
800a7e0: 59 61 00 24 sw (r11+36),r1
if (pipe->Writers ++ == 0)
800a7e4: 29 61 00 14 lw r1,(r11+20)
800a7e8: 34 22 00 01 addi r2,r1,1
800a7ec: 59 62 00 14 sw (r11+20),r2
800a7f0: 5c 20 00 04 bne r1,r0,800a800 <fifo_open+0x3d4> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
800a7f4: 29 61 00 2c lw r1,(r11+44)
800a7f8: 37 82 00 2c addi r2,sp,44
800a7fc: f8 00 06 e4 calli 800c38c <rtems_barrier_release>
break;
}
PIPE_UNLOCK(pipe);
800a800: 29 61 00 28 lw r1,(r11+40)
800a804: fb ff ea 9d calli 8005278 <rtems_semaphore_release>
return 0;
800a808: e0 00 00 05 bi 800a81c <fifo_open+0x3f0>
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
800a80c: 34 0c ff fc mvi r12,-4 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
800a810: b9 e0 08 00 mv r1,r15
800a814: b9 c0 10 00 mv r2,r14
800a818: fb ff fe d3 calli 800a364 <pipe_release>
return err;
}
800a81c: b9 80 08 00 mv r1,r12
800a820: 2b 9d 00 04 lw ra,(sp+4)
800a824: 2b 8b 00 24 lw r11,(sp+36)
800a828: 2b 8c 00 20 lw r12,(sp+32)
800a82c: 2b 8d 00 1c lw r13,(sp+28)
800a830: 2b 8e 00 18 lw r14,(sp+24)
800a834: 2b 8f 00 14 lw r15,(sp+20)
800a838: 2b 90 00 10 lw r16,(sp+16)
800a83c: 2b 91 00 0c lw r17,(sp+12)
800a840: 2b 92 00 08 lw r18,(sp+8)
800a844: 37 9c 00 2c addi sp,sp,44
800a848: c3 a0 00 00 ret
080020f8 <fpathconf>:
long fpathconf(
int fd,
int name
)
{
80020f8: 37 9c ff f0 addi sp,sp,-16
80020fc: 5b 8b 00 10 sw (sp+16),r11
8002100: 5b 8c 00 0c sw (sp+12),r12
8002104: 5b 8d 00 08 sw (sp+8),r13
8002108: 5b 9d 00 04 sw (sp+4),ra
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
800210c: 78 03 08 01 mvhi r3,0x801
8002110: 38 63 60 10 ori r3,r3,0x6010
long fpathconf(
int fd,
int name
)
{
8002114: b8 40 68 00 mv r13,r2
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
8002118: 28 62 00 00 lw r2,(r3+0)
800211c: 54 41 00 02 bgu r2,r1,8002124 <fpathconf+0x2c>
8002120: e0 00 00 0a bi 8002148 <fpathconf+0x50>
iop = rtems_libio_iop(fd);
8002124: 34 02 00 06 mvi r2,6
8002128: 78 0b 08 01 mvhi r11,0x801
800212c: f8 00 46 0d calli 8013960 <__ashlsi3>
8002130: 39 6b 67 8c ori r11,r11,0x678c
8002134: 29 63 00 00 lw r3,(r11+0)
8002138: b4 61 18 00 add r3,r3,r1
rtems_libio_check_is_open(iop);
800213c: 28 61 00 18 lw r1,(r3+24)
8002140: 20 22 01 00 andi r2,r1,0x100
8002144: 5c 40 00 04 bne r2,r0,8002154 <fpathconf+0x5c> <== ALWAYS TAKEN
8002148: f8 00 2d e7 calli 800d8e4 <__errno>
800214c: 34 02 00 09 mvi r2,9
8002150: e0 00 00 28 bi 80021f0 <fpathconf+0xf8>
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
8002154: 20 21 00 02 andi r1,r1,0x2
8002158: 44 20 00 24 be r1,r0,80021e8 <fpathconf+0xf0>
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
800215c: 34 01 00 0b mvi r1,11
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
8002160: 28 6b 00 2c lw r11,(r3+44)
switch ( name ) {
8002164: 55 a1 00 21 bgu r13,r1,80021e8 <fpathconf+0xf0>
8002168: 78 0c 08 01 mvhi r12,0x801
800216c: b9 a0 08 00 mv r1,r13
8002170: 34 02 00 02 mvi r2,2
8002174: f8 00 45 fb calli 8013960 <__ashlsi3>
8002178: 39 8c 4b d8 ori r12,r12,0x4bd8
800217c: b5 81 08 00 add r1,r12,r1
8002180: 28 21 00 00 lw r1,(r1+0)
8002184: c0 20 00 00 b r1
case _PC_LINK_MAX:
return_value = the_limits->link_max;
8002188: 29 61 00 38 lw r1,(r11+56)
break;
800218c: e0 00 00 1b bi 80021f8 <fpathconf+0x100>
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
8002190: 29 61 00 3c lw r1,(r11+60)
break;
8002194: e0 00 00 19 bi 80021f8 <fpathconf+0x100>
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
8002198: 29 61 00 40 lw r1,(r11+64)
break;
800219c: e0 00 00 17 bi 80021f8 <fpathconf+0x100>
case _PC_NAME_MAX:
return_value = the_limits->name_max;
80021a0: 29 61 00 44 lw r1,(r11+68)
break;
80021a4: e0 00 00 15 bi 80021f8 <fpathconf+0x100>
case _PC_PATH_MAX:
return_value = the_limits->path_max;
80021a8: 29 61 00 48 lw r1,(r11+72)
break;
80021ac: e0 00 00 13 bi 80021f8 <fpathconf+0x100>
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
80021b0: 29 61 00 4c lw r1,(r11+76)
break;
80021b4: e0 00 00 11 bi 80021f8 <fpathconf+0x100>
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
80021b8: 29 61 00 54 lw r1,(r11+84)
break;
80021bc: e0 00 00 0f bi 80021f8 <fpathconf+0x100>
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
80021c0: 29 61 00 58 lw r1,(r11+88)
break;
80021c4: e0 00 00 0d bi 80021f8 <fpathconf+0x100>
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
80021c8: 29 61 00 64 lw r1,(r11+100)
break;
80021cc: e0 00 00 0b bi 80021f8 <fpathconf+0x100>
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
80021d0: 29 61 00 50 lw r1,(r11+80)
break;
80021d4: e0 00 00 09 bi 80021f8 <fpathconf+0x100>
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
80021d8: 29 61 00 5c lw r1,(r11+92)
break;
80021dc: e0 00 00 07 bi 80021f8 <fpathconf+0x100>
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
80021e0: 29 61 00 60 lw r1,(r11+96)
break;
80021e4: e0 00 00 05 bi 80021f8 <fpathconf+0x100>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
80021e8: f8 00 2d bf calli 800d8e4 <__errno>
80021ec: 34 02 00 16 mvi r2,22
80021f0: 58 22 00 00 sw (r1+0),r2
80021f4: 34 01 ff ff mvi r1,-1
break;
}
return return_value;
}
80021f8: 2b 9d 00 04 lw ra,(sp+4)
80021fc: 2b 8b 00 10 lw r11,(sp+16)
8002200: 2b 8c 00 0c lw r12,(sp+12)
8002204: 2b 8d 00 08 lw r13,(sp+8)
8002208: 37 9c 00 10 addi sp,sp,16
800220c: c3 a0 00 00 ret
080026c4 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
80026c4: 37 9c ff f4 addi sp,sp,-12
80026c8: 5b 8b 00 0c sw (sp+12),r11
80026cc: 5b 8c 00 08 sw (sp+8),r12
80026d0: 5b 9d 00 04 sw (sp+4),ra
80026d4: b8 20 58 00 mv r11,r1
MSBUMP(free_calls, 1);
80026d8: 78 01 08 01 mvhi r1,0x801
80026dc: 38 21 98 70 ori r1,r1,0x9870
80026e0: 28 22 00 0c lw r2,(r1+12)
80026e4: 34 42 00 01 addi r2,r2,1
80026e8: 58 22 00 0c sw (r1+12),r2
if ( !ptr )
80026ec: 45 60 00 1f be r11,r0,8002768 <free+0xa4>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
80026f0: 78 01 08 01 mvhi r1,0x801
80026f4: 38 21 9a e8 ori r1,r1,0x9ae8
80026f8: 28 22 00 00 lw r2,(r1+0)
80026fc: 34 01 00 03 mvi r1,3
8002700: 5c 41 00 06 bne r2,r1,8002718 <free+0x54> <== NEVER TAKEN
!malloc_is_system_state_OK() ) {
8002704: f8 00 00 80 calli 8002904 <malloc_is_system_state_OK>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
8002708: 5c 20 00 04 bne r1,r0,8002718 <free+0x54>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
800270c: b9 60 08 00 mv r1,r11
8002710: f8 00 00 9d calli 8002984 <malloc_deferred_free>
return;
8002714: e0 00 00 15 bi 8002768 <free+0xa4>
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
8002718: 78 01 08 01 mvhi r1,0x801
800271c: 38 21 96 f0 ori r1,r1,0x96f0
8002720: 28 21 00 00 lw r1,(r1+0)
8002724: 44 20 00 04 be r1,r0,8002734 <free+0x70>
(*rtems_malloc_statistics_helpers->at_free)(ptr);
8002728: 28 22 00 08 lw r2,(r1+8)
800272c: b9 60 08 00 mv r1,r11
8002730: d8 40 00 00 call r2
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
8002734: 78 0c 08 01 mvhi r12,0x801
8002738: 39 8c 90 4c ori r12,r12,0x904c
800273c: 29 81 00 00 lw r1,(r12+0)
8002740: b9 60 10 00 mv r2,r11
8002744: f8 00 0e 13 calli 8005f90 <_Protected_heap_Free>
8002748: 5c 20 00 08 bne r1,r0,8002768 <free+0xa4>
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
ptr,
RTEMS_Malloc_Heap->area_begin,
800274c: 29 84 00 00 lw r4,(r12+0)
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_free)(ptr);
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
8002750: 78 01 08 01 mvhi r1,0x801
8002754: 38 21 7f 48 ori r1,r1,0x7f48
8002758: 28 83 00 18 lw r3,(r4+24)
800275c: 28 84 00 1c lw r4,(r4+28)
8002760: b9 60 10 00 mv r2,r11
8002764: f8 00 03 c6 calli 800367c <printk>
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
8002768: 2b 9d 00 04 lw ra,(sp+4)
800276c: 2b 8b 00 0c lw r11,(sp+12)
8002770: 2b 8c 00 08 lw r12,(sp+8)
8002774: 37 9c 00 0c addi sp,sp,12
8002778: c3 a0 00 00 ret
08002a7c <free_user_env>:
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
8002a7c: 37 9c ff f8 addi sp,sp,-8
8002a80: 5b 8b 00 08 sw (sp+8),r11
8002a84: 5b 9d 00 04 sw (sp+4),ra
8002a88: b8 20 58 00 mv r11,r1
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
8002a8c: 78 01 08 01 mvhi r1,0x801
8002a90: 38 21 47 c0 ori r1,r1,0x47c0
8002a94: 45 61 00 07 be r11,r1,8002ab0 <free_user_env+0x34> <== NEVER TAKEN
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
8002a98: 35 61 00 04 addi r1,r11,4
8002a9c: fb ff fb 2a calli 8001744 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &env->root_directory);
8002aa0: 35 61 00 18 addi r1,r11,24
8002aa4: fb ff fb 28 calli 8001744 <rtems_filesystem_freenode>
free(env);
8002aa8: b9 60 08 00 mv r1,r11
8002aac: fb ff fb 2e calli 8001764 <free>
}
}
8002ab0: 2b 9d 00 04 lw ra,(sp+4)
8002ab4: 2b 8b 00 08 lw r11,(sp+8)
8002ab8: 37 9c 00 08 addi sp,sp,8
8002abc: c3 a0 00 00 ret
08013984 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
8013984: 37 9c ff dc addi sp,sp,-36
8013988: 5b 8b 00 10 sw (sp+16),r11
801398c: 5b 8c 00 0c sw (sp+12),r12
8013990: 5b 8d 00 08 sw (sp+8),r13
8013994: 5b 9d 00 04 sw (sp+4),ra
rtems_filesystem_location_info_t loc;
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
8013998: 78 04 08 01 mvhi r4,0x801
801399c: 38 84 70 10 ori r4,r4,0x7010
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
80139a0: b8 40 68 00 mv r13,r2
rtems_filesystem_location_info_t loc;
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
80139a4: 28 82 00 00 lw r2,(r4+0)
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
80139a8: b8 60 60 00 mv r12,r3
rtems_filesystem_location_info_t loc;
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
80139ac: 34 0b 00 00 mvi r11,0
80139b0: 50 22 00 07 bgeu r1,r2,80139cc <getdents+0x48> <== NEVER TAKEN
80139b4: 78 0b 08 01 mvhi r11,0x801
80139b8: 39 6b 78 a8 ori r11,r11,0x78a8
80139bc: 34 02 00 06 mvi r2,6
80139c0: fb ff b5 d5 calli 8001114 <__ashlsi3>
80139c4: 29 6b 00 00 lw r11,(r11+0)
80139c8: b5 61 58 00 add r11,r11,r1
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
80139cc: 29 64 00 20 lw r4,(r11+32)
80139d0: 29 61 00 28 lw r1,(r11+40)
80139d4: 29 65 00 1c lw r5,(r11+28)
80139d8: 29 62 00 2c lw r2,(r11+44)
80139dc: 29 63 00 24 lw r3,(r11+36)
80139e0: 5b 84 00 18 sw (sp+24),r4
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
80139e4: 28 24 00 10 lw r4,(r1+16)
iop = rtems_libio_iop( dd_fd );
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
80139e8: 5b 81 00 20 sw (sp+32),r1
80139ec: 5b 82 00 24 sw (sp+36),r2
80139f0: 5b 85 00 14 sw (sp+20),r5
80139f4: 5b 83 00 1c sw (sp+28),r3
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
80139f8: 37 81 00 14 addi r1,sp,20
80139fc: d8 80 00 00 call r4
8013a00: 34 02 00 01 mvi r2,1
8013a04: 44 22 00 06 be r1,r2,8013a1c <getdents+0x98>
rtems_set_errno_and_return_minus_one( ENOTDIR );
8013a08: fb ff e6 bc calli 800d4f8 <__errno>
8013a0c: 34 02 00 14 mvi r2,20
8013a10: 58 22 00 00 sw (r1+0),r2
8013a14: 34 01 ff ff mvi r1,-1
8013a18: e0 00 00 07 bi 8013a34 <getdents+0xb0>
/*
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len );
8013a1c: 29 61 00 24 lw r1,(r11+36)
8013a20: b9 a0 10 00 mv r2,r13
8013a24: b9 80 18 00 mv r3,r12
8013a28: 28 24 00 08 lw r4,(r1+8)
8013a2c: b9 60 08 00 mv r1,r11
8013a30: d8 80 00 00 call r4
}
8013a34: 2b 9d 00 04 lw ra,(sp+4)
8013a38: 2b 8b 00 10 lw r11,(sp+16)
8013a3c: 2b 8c 00 0c lw r12,(sp+12)
8013a40: 2b 8d 00 08 lw r13,(sp+8)
8013a44: 37 9c 00 24 addi sp,sp,36
8013a48: c3 a0 00 00 ret
0801052c <imfs_dir_open>:
IMFS_jnode_t *the_jnode;
/* Is the node a directory ? */
the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access;
if ( the_jnode->type != IMFS_DIRECTORY )
801052c: 28 22 00 1c lw r2,(r1+28)
8010530: 34 03 00 01 mvi r3,1
8010534: 28 44 00 4c lw r4,(r2+76)
return -1; /* It wasn't a directory --> return error */
8010538: 34 02 ff ff mvi r2,-1
IMFS_jnode_t *the_jnode;
/* Is the node a directory ? */
the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access;
if ( the_jnode->type != IMFS_DIRECTORY )
801053c: 5c 83 00 04 bne r4,r3,801054c <imfs_dir_open+0x20> <== NEVER TAKEN
return -1; /* It wasn't a directory --> return error */
iop->offset = 0;
8010540: 58 20 00 10 sw (r1+16),r0
8010544: 58 20 00 14 sw (r1+20),r0
return 0;
8010548: 34 02 00 00 mvi r2,0
}
801054c: b8 40 08 00 mv r1,r2
8010550: c3 a0 00 00 ret
08010788 <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
8010788: 37 9c ff f8 addi sp,sp,-8
801078c: 5b 8b 00 08 sw (sp+8),r11
8010790: 5b 9d 00 04 sw (sp+4),ra
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
8010794: 28 4b 00 00 lw r11,(r2+0)
/*
* You cannot remove a node that still has children
*/
if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) )
8010798: 29 63 00 50 lw r3,(r11+80)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
801079c: 35 61 00 54 addi r1,r11,84
80107a0: 44 61 00 04 be r3,r1,80107b0 <imfs_dir_rmnod+0x28>
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
80107a4: f8 00 03 33 calli 8011470 <__errno>
80107a8: 34 02 00 5a mvi r2,90
80107ac: e0 00 00 06 bi 80107c4 <imfs_dir_rmnod+0x3c>
/*
* You cannot remove the file system root node.
*/
if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
80107b0: 28 41 00 10 lw r1,(r2+16)
80107b4: 28 21 00 1c lw r1,(r1+28)
80107b8: 5c 2b 00 06 bne r1,r11,80107d0 <imfs_dir_rmnod+0x48>
rtems_set_errno_and_return_minus_one( EBUSY );
80107bc: f8 00 03 2d calli 8011470 <__errno>
80107c0: 34 02 00 10 mvi r2,16
80107c4: 58 22 00 00 sw (r1+0),r2
80107c8: 34 01 ff ff mvi r1,-1
80107cc: e0 00 00 08 bi 80107ec <imfs_dir_rmnod+0x64>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
80107d0: 29 61 00 5c lw r1,(r11+92)
80107d4: 5c 20 ff fa bne r1,r0,80107bc <imfs_dir_rmnod+0x34> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBUSY );
IMFS_create_orphan( the_jnode );
80107d8: b9 60 08 00 mv r1,r11
80107dc: fb ff ee e9 calli 800c380 <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
80107e0: b9 60 08 00 mv r1,r11
80107e4: fb ff ee fb calli 800c3d0 <IMFS_check_node_remove>
return 0;
80107e8: 34 01 00 00 mvi r1,0
}
80107ec: 2b 9d 00 04 lw ra,(sp+4)
80107f0: 2b 8b 00 08 lw r11,(sp+8)
80107f4: 37 9c 00 08 addi sp,sp,8
80107f8: c3 a0 00 00 ret
08002054 <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
8002054: 37 9c ff f0 addi sp,sp,-16
8002058: 5b 8b 00 10 sw (sp+16),r11
800205c: 5b 8c 00 0c sw (sp+12),r12
8002060: 5b 8d 00 08 sw (sp+8),r13
8002064: 5b 9d 00 04 sw (sp+4),ra
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
8002068: 78 01 08 01 mvhi r1,0x801
800206c: 38 21 68 e8 ori r1,r1,0x68e8
8002070: 40 2d 00 00 lbu r13,(r1+0)
8002074: 5d a0 00 2f bne r13,r0,8002130 <init_etc_passwd_group+0xdc>
return;
etc_passwd_initted = 1;
8002078: 34 02 00 01 mvi r2,1
800207c: 30 22 00 00 sb (r1+0),r2
mkdir("/etc", 0777);
8002080: 78 01 08 01 mvhi r1,0x801
8002084: 34 02 01 ff mvi r2,511
8002088: 38 21 4b 08 ori r1,r1,0x4b08
800208c: f8 00 02 9d calli 8002b00 <mkdir>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
8002090: 78 0b 08 01 mvhi r11,0x801
8002094: 39 6b 4b 10 ori r11,r11,0x4b10
8002098: 78 02 08 01 mvhi r2,0x801
800209c: b9 60 08 00 mv r1,r11
80020a0: 38 42 4b 1c ori r2,r2,0x4b1c
80020a4: f8 00 30 4a calli 800e1cc <fopen>
80020a8: b8 20 60 00 mv r12,r1
80020ac: 5c 2d 00 0c bne r1,r13,80020dc <init_etc_passwd_group+0x88>
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
80020b0: 78 02 08 01 mvhi r2,0x801
80020b4: b9 60 08 00 mv r1,r11
80020b8: 38 42 4b 20 ori r2,r2,0x4b20
80020bc: f8 00 30 44 calli 800e1cc <fopen>
80020c0: b8 20 58 00 mv r11,r1
80020c4: 44 2c 00 07 be r1,r12,80020e0 <init_etc_passwd_group+0x8c> <== NEVER TAKEN
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
80020c8: 78 01 08 01 mvhi r1,0x801
80020cc: 38 21 4b 24 ori r1,r1,0x4b24
80020d0: b9 60 10 00 mv r2,r11
80020d4: f8 00 30 75 calli 800e2a8 <fputs>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
80020d8: b9 60 08 00 mv r1,r11
80020dc: f8 00 2e 0d calli 800d910 <fclose>
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
80020e0: 78 0b 08 01 mvhi r11,0x801
80020e4: 39 6b 4b 8c ori r11,r11,0x4b8c
80020e8: 78 02 08 01 mvhi r2,0x801
80020ec: b9 60 08 00 mv r1,r11
80020f0: 38 42 4b 1c ori r2,r2,0x4b1c
80020f4: f8 00 30 36 calli 800e1cc <fopen>
80020f8: b8 20 60 00 mv r12,r1
80020fc: 5c 20 00 0c bne r1,r0,800212c <init_etc_passwd_group+0xd8>
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
8002100: 78 02 08 01 mvhi r2,0x801
8002104: b9 60 08 00 mv r1,r11
8002108: 38 42 4b 20 ori r2,r2,0x4b20
800210c: f8 00 30 30 calli 800e1cc <fopen>
8002110: b8 20 58 00 mv r11,r1
8002114: 44 2c 00 07 be r1,r12,8002130 <init_etc_passwd_group+0xdc> <== NEVER TAKEN
fprintf( fp, "root:x:0:root\n"
8002118: 78 01 08 01 mvhi r1,0x801
800211c: 38 21 4b 98 ori r1,r1,0x4b98
8002120: b9 60 10 00 mv r2,r11
8002124: f8 00 30 61 calli 800e2a8 <fputs>
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
8002128: b9 60 08 00 mv r1,r11
800212c: f8 00 2d f9 calli 800d910 <fclose>
}
}
8002130: 2b 9d 00 04 lw ra,(sp+4)
8002134: 2b 8b 00 10 lw r11,(sp+16)
8002138: 2b 8c 00 0c lw r12,(sp+12)
800213c: 2b 8d 00 08 lw r13,(sp+8)
8002140: 37 9c 00 10 addi sp,sp,16
8002144: c3 a0 00 00 ret
08004274 <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
8004274: 37 9c ff f4 addi sp,sp,-12
8004278: 5b 8b 00 0c sw (sp+12),r11
800427c: 5b 8c 00 08 sw (sp+8),r12
8004280: 5b 9d 00 04 sw (sp+4),ra
8004284: b8 40 58 00 mv r11,r2
if (tty->termios.c_iflag & ISTRIP)
8004288: 28 42 00 30 lw r2,(r2+48)
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
800428c: b8 20 60 00 mv r12,r1
if (tty->termios.c_iflag & ISTRIP)
8004290: 20 41 00 20 andi r1,r2,0x20
8004294: 44 20 00 02 be r1,r0,800429c <iproc+0x28> <== ALWAYS TAKEN
c &= 0x7f;
8004298: 21 8c 00 7f andi r12,r12,0x7f <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
800429c: 20 41 02 00 andi r1,r2,0x200
80042a0: 44 20 00 0b be r1,r0,80042cc <iproc+0x58>
c = tolower (c);
80042a4: 78 01 08 02 mvhi r1,0x802
80042a8: 38 21 52 58 ori r1,r1,0x5258
80042ac: 28 21 00 00 lw r1,(r1+0)
80042b0: b4 2c 08 00 add r1,r1,r12
80042b4: 40 23 00 01 lbu r3,(r1+1)
80042b8: 34 01 00 01 mvi r1,1
80042bc: 20 63 00 03 andi r3,r3,0x3
80042c0: 5c 61 00 02 bne r3,r1,80042c8 <iproc+0x54>
80042c4: 35 8c 00 20 addi r12,r12,32
80042c8: 21 8c 00 ff andi r12,r12,0xff
if (c == '\r') {
80042cc: 34 01 00 0d mvi r1,13
80042d0: 5d 81 00 08 bne r12,r1,80042f0 <iproc+0x7c>
if (tty->termios.c_iflag & IGNCR)
80042d4: 20 43 00 80 andi r3,r2,0x80
return 0;
80042d8: 34 01 00 00 mvi r1,0
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
80042dc: 5c 60 00 4e bne r3,r0,8004414 <iproc+0x1a0> <== NEVER TAKEN
return 0;
if (tty->termios.c_iflag & ICRNL)
80042e0: 20 42 01 00 andi r2,r2,0x100
80042e4: 44 43 00 0a be r2,r3,800430c <iproc+0x98> <== NEVER TAKEN
c = '\n';
80042e8: 34 0c 00 0a mvi r12,10
80042ec: e0 00 00 08 bi 800430c <iproc+0x98>
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
80042f0: 34 01 00 0a mvi r1,10
80042f4: 5d 81 00 05 bne r12,r1,8004308 <iproc+0x94>
80042f8: 20 42 00 40 andi r2,r2,0x40
80042fc: 44 40 00 04 be r2,r0,800430c <iproc+0x98> <== ALWAYS TAKEN
c = '\r';
8004300: 34 0c 00 0d mvi r12,13 <== NOT EXECUTED
8004304: e0 00 00 02 bi 800430c <iproc+0x98> <== NOT EXECUTED
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
8004308: 45 80 00 2f be r12,r0,80043c4 <iproc+0x150> <== NEVER TAKEN
800430c: 29 62 00 3c lw r2,(r11+60)
8004310: 20 41 00 02 andi r1,r2,0x2
8004314: 44 20 00 2c be r1,r0,80043c4 <iproc+0x150>
if (c == tty->termios.c_cc[VERASE]) {
8004318: 41 61 00 43 lbu r1,(r11+67)
800431c: 5c 2c 00 04 bne r1,r12,800432c <iproc+0xb8>
erase (tty, 0);
8004320: b9 60 08 00 mv r1,r11
8004324: 34 02 00 00 mvi r2,0
8004328: e0 00 00 05 bi 800433c <iproc+0xc8>
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
800432c: 41 61 00 44 lbu r1,(r11+68)
8004330: 5c 2c 00 05 bne r1,r12,8004344 <iproc+0xd0>
erase (tty, 1);
8004334: b9 60 08 00 mv r1,r11
8004338: 34 02 00 01 mvi r2,1
800433c: fb ff ff 4c calli 800406c <erase>
8004340: e0 00 00 34 bi 8004410 <iproc+0x19c>
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
8004344: 41 63 00 45 lbu r3,(r11+69)
return 1;
8004348: 34 01 00 01 mvi r1,1
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
800434c: 44 6c 00 32 be r3,r12,8004414 <iproc+0x1a0> <== NEVER TAKEN
return 1;
} else if (c == '\n') {
8004350: 34 01 00 0a mvi r1,10
8004354: 5d 81 00 0b bne r12,r1,8004380 <iproc+0x10c>
if (tty->termios.c_lflag & (ECHO | ECHONL))
8004358: 20 42 00 48 andi r2,r2,0x48
800435c: 44 40 00 03 be r2,r0,8004368 <iproc+0xf4> <== NEVER TAKEN
echo (c, tty);
8004360: b9 60 10 00 mv r2,r11
8004364: fb ff ff 1d calli 8003fd8 <echo>
tty->cbuf[tty->ccount++] = c;
8004368: 29 61 00 20 lw r1,(r11+32)
800436c: 29 62 00 1c lw r2,(r11+28)
8004370: 34 03 00 0a mvi r3,10
8004374: b4 41 10 00 add r2,r2,r1
8004378: 30 43 00 00 sb (r2+0),r3
800437c: e0 00 00 0e bi 80043b4 <iproc+0x140>
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
8004380: 41 61 00 4c lbu r1,(r11+76)
8004384: 44 2c 00 03 be r1,r12,8004390 <iproc+0x11c> <== NEVER TAKEN
8004388: 41 61 00 51 lbu r1,(r11+81)
800438c: 5c 2c 00 0e bne r1,r12,80043c4 <iproc+0x150> <== ALWAYS TAKEN
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
8004390: 20 42 00 08 andi r2,r2,0x8 <== NOT EXECUTED
8004394: 44 40 00 04 be r2,r0,80043a4 <iproc+0x130> <== NOT EXECUTED
echo (c, tty);
8004398: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
800439c: b9 60 10 00 mv r2,r11 <== NOT EXECUTED
80043a0: fb ff ff 0e calli 8003fd8 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
80043a4: 29 61 00 20 lw r1,(r11+32) <== NOT EXECUTED
80043a8: 29 62 00 1c lw r2,(r11+28) <== NOT EXECUTED
80043ac: b4 41 10 00 add r2,r2,r1 <== NOT EXECUTED
80043b0: 30 4c 00 00 sb (r2+0),r12 <== NOT EXECUTED
80043b4: 34 21 00 01 addi r1,r1,1
80043b8: 59 61 00 20 sw (r11+32),r1
return 1;
80043bc: 34 01 00 01 mvi r1,1
80043c0: e0 00 00 15 bi 8004414 <iproc+0x1a0>
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
80043c4: 78 01 08 02 mvhi r1,0x802
80043c8: 38 21 51 8c ori r1,r1,0x518c
80043cc: 28 22 00 00 lw r2,(r1+0)
80043d0: 29 63 00 20 lw r3,(r11+32)
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
80043d4: 34 01 00 00 mvi r1,0
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
80043d8: 34 42 ff ff addi r2,r2,-1
80043dc: 4c 62 00 0e bge r3,r2,8004414 <iproc+0x1a0> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHO)
80043e0: 29 61 00 3c lw r1,(r11+60)
80043e4: 20 21 00 08 andi r1,r1,0x8
80043e8: 44 20 00 04 be r1,r0,80043f8 <iproc+0x184> <== NEVER TAKEN
echo (c, tty);
80043ec: b9 80 08 00 mv r1,r12
80043f0: b9 60 10 00 mv r2,r11
80043f4: fb ff fe f9 calli 8003fd8 <echo>
tty->cbuf[tty->ccount++] = c;
80043f8: 29 61 00 20 lw r1,(r11+32)
80043fc: 29 62 00 1c lw r2,(r11+28)
8004400: b4 41 10 00 add r2,r2,r1
8004404: 30 4c 00 00 sb (r2+0),r12
8004408: 34 21 00 01 addi r1,r1,1
800440c: 59 61 00 20 sw (r11+32),r1
}
return 0;
8004410: 34 01 00 00 mvi r1,0
}
8004414: 2b 9d 00 04 lw ra,(sp+4)
8004418: 2b 8b 00 0c lw r11,(sp+12)
800441c: 2b 8c 00 08 lw r12,(sp+8)
8004420: 37 9c 00 0c addi sp,sp,12
8004424: c3 a0 00 00 ret
08025c34 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
8025c34: 37 9c ff dc addi sp,sp,-36
8025c38: 5b 8b 00 18 sw (sp+24),r11
8025c3c: 5b 8c 00 14 sw (sp+20),r12
8025c40: 5b 8d 00 10 sw (sp+16),r13
8025c44: 5b 8e 00 0c sw (sp+12),r14
8025c48: 5b 8f 00 08 sw (sp+8),r15
8025c4c: 5b 9d 00 04 sw (sp+4),ra
8025c50: b8 20 60 00 mv r12,r1
8025c54: b8 40 58 00 mv r11,r2
8025c58: b8 60 68 00 mv r13,r3
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
8025c5c: fb ff fe e8 calli 80257fc <getpid>
8025c60: 45 81 00 04 be r12,r1,8025c70 <killinfo+0x3c>
rtems_set_errno_and_return_minus_one( ESRCH );
8025c64: fb ff b4 ea calli 801300c <__errno>
8025c68: 34 02 00 03 mvi r2,3
8025c6c: e0 00 00 04 bi 8025c7c <killinfo+0x48>
/*
* Validate the signal passed.
*/
if ( !sig )
8025c70: 5d 60 00 06 bne r11,r0,8025c88 <killinfo+0x54>
rtems_set_errno_and_return_minus_one( EINVAL );
8025c74: fb ff b4 e6 calli 801300c <__errno>
8025c78: 34 02 00 16 mvi r2,22
8025c7c: 58 22 00 00 sw (r1+0),r2
8025c80: 34 01 ff ff mvi r1,-1
8025c84: e0 00 00 9f bi 8025f00 <killinfo+0x2cc>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
8025c88: 35 6f ff ff addi r15,r11,-1
if ( !is_valid_signo(sig) )
8025c8c: 34 01 00 1f mvi r1,31
8025c90: 50 2f 00 02 bgeu r1,r15,8025c98 <killinfo+0x64>
8025c94: e3 ff ff f8 bi 8025c74 <killinfo+0x40>
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 )
8025c98: 34 02 00 01 mvi r2,1
8025c9c: b9 60 08 00 mv r1,r11
8025ca0: fb ff 70 81 calli 8001ea4 <__ashlsi3>
8025ca4: 34 02 00 02 mvi r2,2
8025ca8: 78 0c 08 02 mvhi r12,0x802
8025cac: b4 2b 08 00 add r1,r1,r11
8025cb0: fb ff 70 7d calli 8001ea4 <__ashlsi3>
8025cb4: 39 8c 9f 78 ori r12,r12,0x9f78
8025cb8: b5 81 08 00 add r1,r12,r1
8025cbc: 28 22 00 08 lw r2,(r1+8)
8025cc0: 34 0e 00 01 mvi r14,1
return 0;
8025cc4: 34 01 00 00 mvi r1,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 )
8025cc8: 44 4e 00 8e be r2,r14,8025f00 <killinfo+0x2cc>
/*
* 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 ) )
8025ccc: 65 62 00 04 cmpei r2,r11,4
8025cd0: 65 61 00 08 cmpei r1,r11,8
8025cd4: b8 41 08 00 or r1,r2,r1
8025cd8: 5c 20 00 03 bne r1,r0,8025ce4 <killinfo+0xb0>
8025cdc: 34 01 00 0b mvi r1,11
8025ce0: 5d 61 00 05 bne r11,r1,8025cf4 <killinfo+0xc0>
return pthread_kill( pthread_self(), sig );
8025ce4: f8 00 01 36 calli 80261bc <pthread_self>
8025ce8: b9 60 10 00 mv r2,r11
8025cec: f8 00 00 f3 calli 80260b8 <pthread_kill>
8025cf0: e0 00 00 84 bi 8025f00 <killinfo+0x2cc>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
8025cf4: 34 01 00 01 mvi r1,1
8025cf8: b9 e0 10 00 mv r2,r15
8025cfc: fb ff 70 6a calli 8001ea4 <__ashlsi3>
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
8025d00: 5b 8b 00 1c sw (sp+28),r11
siginfo->si_code = SI_USER;
8025d04: 5b 8e 00 20 sw (sp+32),r14
8025d08: b8 20 60 00 mv r12,r1
if ( !value ) {
8025d0c: 5d a0 00 03 bne r13,r0,8025d18 <killinfo+0xe4>
siginfo->si_value.sival_int = 0;
8025d10: 5b 80 00 24 sw (sp+36),r0
8025d14: e0 00 00 03 bi 8025d20 <killinfo+0xec>
} else {
siginfo->si_value = *value;
8025d18: 29 a1 00 00 lw r1,(r13+0)
8025d1c: 5b 81 00 24 sw (sp+36),r1
8025d20: 78 01 08 02 mvhi r1,0x802
8025d24: 38 21 9a 80 ori r1,r1,0x9a80
8025d28: 28 22 00 00 lw r2,(r1+0)
8025d2c: 34 42 00 01 addi r2,r2,1
8025d30: 58 22 00 00 sw (r1+0),r2
/*
* 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;
8025d34: 78 01 08 02 mvhi r1,0x802
8025d38: 38 21 9f 2c ori r1,r1,0x9f2c
8025d3c: 28 23 00 0c lw r3,(r1+12)
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
8025d40: 28 61 01 20 lw r1,(r3+288)
8025d44: 28 21 00 d0 lw r1,(r1+208)
8025d48: a4 20 08 00 not r1,r1
8025d4c: a1 81 08 00 and r1,r12,r1
8025d50: 5c 20 00 3f bne r1,r0,8025e4c <killinfo+0x218>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
8025d54: 78 01 08 02 mvhi r1,0x802
8025d58: 38 21 a1 04 ori r1,r1,0xa104
8025d5c: 28 22 00 00 lw r2,(r1+0)
/* 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 );
8025d60: 78 01 08 02 mvhi r1,0x802
8025d64: 38 21 a1 08 ori r1,r1,0xa108
8025d68: e0 00 00 0b bi 8025d94 <killinfo+0x160>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
8025d6c: 28 44 00 30 lw r4,(r2+48)
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;
8025d70: b8 40 18 00 mv r3,r2
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
8025d74: 28 45 01 20 lw r5,(r2+288)
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
8025d78: a1 84 20 00 and r4,r12,r4
8025d7c: 5c 80 00 34 bne r4,r0,8025e4c <killinfo+0x218>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
8025d80: 28 a5 00 d0 lw r5,(r5+208)
8025d84: a4 a0 28 00 not r5,r5
8025d88: a1 85 28 00 and r5,r12,r5
8025d8c: 5c a4 00 30 bne r5,r4,8025e4c <killinfo+0x218>
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 ) {
8025d90: 28 42 00 00 lw r2,(r2+0)
/* 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 );
8025d94: 5c 41 ff f6 bne r2,r1,8025d6c <killinfo+0x138>
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
8025d98: 78 01 08 02 mvhi r1,0x802
8025d9c: 38 21 90 f0 ori r1,r1,0x90f0
8025da0: 40 21 00 00 lbu r1,(r1+0)
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
8025da4: 78 02 08 02 mvhi r2,0x802
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
8025da8: 78 04 08 02 mvhi r4,0x802
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
8025dac: 38 42 9a 1c ori r2,r2,0x9a1c
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
8025db0: 34 21 00 01 addi r1,r1,1
8025db4: 38 84 9a 24 ori r4,r4,0x9a24
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
8025db8: 34 4d 00 10 addi r13,r2,16
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
8025dbc: 34 03 00 00 mvi r3,0
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
8025dc0: 78 08 10 00 mvhi r8,0x1000
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 ] )
8025dc4: 28 85 00 00 lw r5,(r4+0)
8025dc8: 44 a0 00 1e be r5,r0,8025e40 <killinfo+0x20c> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
8025dcc: 28 a5 00 04 lw r5,(r5+4)
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
8025dd0: 34 06 00 01 mvi r6,1
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
8025dd4: 2c ae 00 10 lhu r14,(r5+16)
8025dd8: 28 a7 00 1c lw r7,(r5+28)
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
8025ddc: e0 00 00 18 bi 8025e3c <killinfo+0x208>
the_thread = (Thread_Control *) object_table[ index ];
8025de0: 28 e2 00 04 lw r2,(r7+4)
if ( !the_thread )
8025de4: 44 40 00 14 be r2,r0,8025e34 <killinfo+0x200>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
8025de8: 28 45 00 14 lw r5,(r2+20)
8025dec: 54 a1 00 12 bgu r5,r1,8025e34 <killinfo+0x200>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
8025df0: 28 49 01 20 lw r9,(r2+288)
8025df4: 29 29 00 d0 lw r9,(r9+208)
8025df8: a5 20 48 00 not r9,r9
8025dfc: a1 89 48 00 and r9,r12,r9
8025e00: 45 20 00 0d be r9,r0,8025e34 <killinfo+0x200>
*
* 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 ) {
8025e04: 54 25 00 0a bgu r1,r5,8025e2c <killinfo+0x1f8>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
8025e08: 44 60 00 0b be r3,r0,8025e34 <killinfo+0x200> <== NEVER TAKEN
8025e0c: 28 69 00 10 lw r9,(r3+16)
8025e10: 45 20 00 09 be r9,r0,8025e34 <killinfo+0x200> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
8025e14: 28 4a 00 10 lw r10,(r2+16)
8025e18: 45 40 00 05 be r10,r0,8025e2c <killinfo+0x1f8>
8025e1c: a1 28 48 00 and r9,r9,r8
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
8025e20: 5d 20 00 05 bne r9,r0,8025e34 <killinfo+0x200>
8025e24: a1 48 50 00 and r10,r10,r8
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
8025e28: 45 49 00 03 be r10,r9,8025e34 <killinfo+0x200>
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
8025e2c: b8 a0 08 00 mv r1,r5
8025e30: b8 40 18 00 mv r3,r2
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
8025e34: 34 c6 00 01 addi r6,r6,1
8025e38: 34 e7 00 04 addi r7,r7,4
8025e3c: 51 c6 ff e9 bgeu r14,r6,8025de0 <killinfo+0x1ac>
8025e40: 34 84 00 04 addi r4,r4,4
* + 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++) {
8025e44: 5c 8d ff e0 bne r4,r13,8025dc4 <killinfo+0x190>
}
}
}
}
if ( interested ) {
8025e48: 44 60 00 06 be r3,r0,8025e60 <killinfo+0x22c>
/*
* 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 ) ) {
8025e4c: b8 60 08 00 mv r1,r3
8025e50: b9 60 10 00 mv r2,r11
8025e54: 37 83 00 1c addi r3,sp,28
8025e58: f8 00 00 3d calli 8025f4c <_POSIX_signals_Unblock_thread>
8025e5c: 5c 20 00 27 bne r1,r0,8025ef8 <killinfo+0x2c4>
/*
* 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 );
8025e60: b9 80 08 00 mv r1,r12
8025e64: f8 00 00 2f calli 8025f20 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
8025e68: b9 60 08 00 mv r1,r11
8025e6c: 34 02 00 01 mvi r2,1
8025e70: fb ff 70 0d calli 8001ea4 <__ashlsi3>
8025e74: b4 2b 58 00 add r11,r1,r11
8025e78: 34 02 00 02 mvi r2,2
8025e7c: 78 0c 08 02 mvhi r12,0x802
8025e80: b9 60 08 00 mv r1,r11
8025e84: fb ff 70 08 calli 8001ea4 <__ashlsi3>
8025e88: 39 8c 9f 78 ori r12,r12,0x9f78
8025e8c: b5 81 08 00 add r1,r12,r1
8025e90: 28 22 00 00 lw r2,(r1+0)
8025e94: 34 01 00 02 mvi r1,2
8025e98: 5c 41 00 18 bne r2,r1,8025ef8 <killinfo+0x2c4>
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
8025e9c: 78 01 08 02 mvhi r1,0x802
8025ea0: 38 21 a0 f8 ori r1,r1,0xa0f8
8025ea4: fb ff 8f f1 calli 8009e68 <_Chain_Get>
8025ea8: b8 20 60 00 mv r12,r1
if ( !psiginfo ) {
8025eac: 5c 20 00 05 bne r1,r0,8025ec0 <killinfo+0x28c>
_Thread_Enable_dispatch();
8025eb0: fb ff 98 bb calli 800c19c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
8025eb4: fb ff b4 56 calli 801300c <__errno>
8025eb8: 34 02 00 0b mvi r2,11
8025ebc: e3 ff ff 70 bi 8025c7c <killinfo+0x48>
}
psiginfo->Info = *siginfo;
8025ec0: 2b 81 00 1c lw r1,(sp+28)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
8025ec4: 34 02 00 02 mvi r2,2
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
8025ec8: 59 81 00 08 sw (r12+8),r1
8025ecc: 2b 81 00 20 lw r1,(sp+32)
8025ed0: 59 81 00 0c sw (r12+12),r1
8025ed4: 2b 81 00 24 lw r1,(sp+36)
8025ed8: 59 81 00 10 sw (r12+16),r1
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
8025edc: b9 60 08 00 mv r1,r11
8025ee0: fb ff 6f f1 calli 8001ea4 <__ashlsi3>
8025ee4: 78 02 08 02 mvhi r2,0x802
8025ee8: 38 42 a1 70 ori r2,r2,0xa170
8025eec: b4 22 08 00 add r1,r1,r2
8025ef0: b9 80 10 00 mv r2,r12
8025ef4: fb ff 8f c7 calli 8009e10 <_Chain_Append>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
8025ef8: fb ff 98 a9 calli 800c19c <_Thread_Enable_dispatch>
return 0;
8025efc: 34 01 00 00 mvi r1,0
}
8025f00: 2b 9d 00 04 lw ra,(sp+4)
8025f04: 2b 8b 00 18 lw r11,(sp+24)
8025f08: 2b 8c 00 14 lw r12,(sp+20)
8025f0c: 2b 8d 00 10 lw r13,(sp+16)
8025f10: 2b 8e 00 0c lw r14,(sp+12)
8025f14: 2b 8f 00 08 lw r15,(sp+8)
8025f18: 37 9c 00 24 addi sp,sp,36
8025f1c: c3 a0 00 00 ret
0801760c <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
801760c: 37 9c ff f4 addi sp,sp,-12
8017610: 5b 8b 00 0c sw (sp+12),r11
8017614: 5b 8c 00 08 sw (sp+8),r12
8017618: 5b 9d 00 04 sw (sp+4),ra
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
801761c: 78 01 08 01 mvhi r1,0x801
8017620: 38 21 9a e8 ori r1,r1,0x9ae8
8017624: 28 22 00 00 lw r2,(r1+0)
8017628: 34 01 00 03 mvi r1,3
801762c: 5c 41 00 16 bne r2,r1,8017684 <libc_wrapup+0x78> <== NEVER TAKEN
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
8017630: 78 01 08 01 mvhi r1,0x801
8017634: 78 0b 08 01 mvhi r11,0x801
8017638: 38 21 87 40 ori r1,r1,0x8740
801763c: 39 6b 92 10 ori r11,r11,0x9210
8017640: 28 2c 00 00 lw r12,(r1+0)
8017644: 29 61 00 00 lw r1,(r11+0)
8017648: 44 2c 00 04 be r1,r12,8017658 <libc_wrapup+0x4c>
_wrapup_reent(_global_impure_ptr);
801764c: b9 80 08 00 mv r1,r12
8017650: f8 00 01 1c calli 8017ac0 <_wrapup_reent>
/* Don't reclaim this one, just in case we do printfs
* on the way out to ROM.
*/
_reclaim_reent(&libc_global_reent);
#endif
_REENT = _global_impure_ptr;
8017654: 59 6c 00 00 sw (r11+0),r12
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
8017658: 78 0b 08 01 mvhi r11,0x801
801765c: 39 6b 92 10 ori r11,r11,0x9210
8017660: 29 61 00 00 lw r1,(r11+0)
8017664: 28 21 00 04 lw r1,(r1+4)
8017668: fb ff e7 e2 calli 80115f0 <fclose>
fclose (stdout);
801766c: 29 61 00 00 lw r1,(r11+0)
8017670: 28 21 00 08 lw r1,(r1+8)
8017674: fb ff e7 df calli 80115f0 <fclose>
fclose (stderr);
8017678: 29 61 00 00 lw r1,(r11+0)
801767c: 28 21 00 0c lw r1,(r1+12)
8017680: fb ff e7 dc calli 80115f0 <fclose>
}
8017684: 2b 9d 00 04 lw ra,(sp+4)
8017688: 2b 8b 00 0c lw r11,(sp+12)
801768c: 2b 8c 00 08 lw r12,(sp+8)
8017690: 37 9c 00 0c addi sp,sp,12
8017694: c3 a0 00 00 ret
08002aac <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
8002aac: 37 9c ff f4 addi sp,sp,-12
8002ab0: 5b 8b 00 0c sw (sp+12),r11
8002ab4: 5b 8c 00 08 sw (sp+8),r12
8002ab8: 5b 9d 00 04 sw (sp+4),ra
void *return_this;
MSBUMP(malloc_calls, 1);
8002abc: 78 03 08 01 mvhi r3,0x801
8002ac0: 38 63 98 70 ori r3,r3,0x9870
#include "malloc_p.h"
void *malloc(
size_t size
)
{
8002ac4: b8 20 60 00 mv r12,r1
void *return_this;
MSBUMP(malloc_calls, 1);
8002ac8: 28 61 00 04 lw r1,(r3+4)
/*
* Validate the parameters
*/
if ( !size )
return (void *) 0;
8002acc: 34 0b 00 00 mvi r11,0
size_t size
)
{
void *return_this;
MSBUMP(malloc_calls, 1);
8002ad0: 34 21 00 01 addi r1,r1,1
8002ad4: 58 61 00 04 sw (r3+4),r1
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
8002ad8: fb ff ff 9d calli 800294c <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
8002adc: 45 80 00 2d be r12,r0,8002b90 <malloc+0xe4>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
8002ae0: 78 01 08 01 mvhi r1,0x801
8002ae4: 38 21 9a e8 ori r1,r1,0x9ae8
8002ae8: 28 22 00 00 lw r2,(r1+0)
8002aec: 34 01 00 03 mvi r1,3
8002af0: 5c 41 00 03 bne r2,r1,8002afc <malloc+0x50>
!malloc_is_system_state_OK() )
8002af4: fb ff ff 84 calli 8002904 <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()) &&
8002af8: 44 20 00 26 be r1,r0,8002b90 <malloc+0xe4> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
8002afc: 78 01 08 01 mvhi r1,0x801
8002b00: 38 21 90 4c ori r1,r1,0x904c
8002b04: 28 21 00 00 lw r1,(r1+0)
8002b08: b9 80 10 00 mv r2,r12
8002b0c: 34 03 00 00 mvi r3,0
8002b10: 34 04 00 00 mvi r4,0
8002b14: f8 00 0d 05 calli 8005f28 <_Protected_heap_Allocate_aligned_with_boundary>
8002b18: b8 20 58 00 mv r11,r1
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
8002b1c: 5c 20 00 0f bne r1,r0,8002b58 <malloc+0xac>
if (rtems_malloc_sbrk_helpers)
8002b20: 78 01 08 01 mvhi r1,0x801
8002b24: 38 21 96 f4 ori r1,r1,0x96f4
8002b28: 28 21 00 00 lw r1,(r1+0)
8002b2c: 44 2b 00 06 be r1,r11,8002b44 <malloc+0x98>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
8002b30: 28 22 00 04 lw r2,(r1+4)
8002b34: b9 80 08 00 mv r1,r12
8002b38: d8 40 00 00 call r2
8002b3c: b8 20 58 00 mv r11,r1
if ( !return_this ) {
8002b40: 5c 20 00 06 bne r1,r0,8002b58 <malloc+0xac>
errno = ENOMEM;
8002b44: f8 00 3a 4b calli 8011470 <__errno>
8002b48: 34 02 00 0c mvi r2,12
8002b4c: 58 22 00 00 sw (r1+0),r2
return (void *) 0;
8002b50: 34 0b 00 00 mvi r11,0
8002b54: e0 00 00 0f bi 8002b90 <malloc+0xe4>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
8002b58: 78 01 08 01 mvhi r1,0x801
8002b5c: 38 21 96 f8 ori r1,r1,0x96f8
8002b60: 28 23 00 00 lw r3,(r1+0)
8002b64: 44 60 00 04 be r3,r0,8002b74 <malloc+0xc8>
(*rtems_malloc_dirty_helper)( return_this, size );
8002b68: b9 60 08 00 mv r1,r11
8002b6c: b9 80 10 00 mv r2,r12
8002b70: d8 60 00 00 call r3
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
8002b74: 78 01 08 01 mvhi r1,0x801
8002b78: 38 21 96 f0 ori r1,r1,0x96f0
8002b7c: 28 21 00 00 lw r1,(r1+0)
8002b80: 44 20 00 04 be r1,r0,8002b90 <malloc+0xe4>
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
8002b84: 28 22 00 04 lw r2,(r1+4)
8002b88: b9 60 08 00 mv r1,r11
8002b8c: d8 40 00 00 call r2
return return_this;
}
8002b90: b9 60 08 00 mv r1,r11
8002b94: 2b 9d 00 04 lw ra,(sp+4)
8002b98: 2b 8b 00 0c lw r11,(sp+12)
8002b9c: 2b 8c 00 08 lw r12,(sp+8)
8002ba0: 37 9c 00 0c addi sp,sp,12
8002ba4: c3 a0 00 00 ret
08001afc <malloc_sbrk_extend_and_allocate>:
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
8001afc: 37 9c ff ec addi sp,sp,-20
8001b00: 5b 8b 00 14 sw (sp+20),r11
8001b04: 5b 8c 00 10 sw (sp+16),r12
8001b08: 5b 8d 00 0c sw (sp+12),r13
8001b0c: 5b 8e 00 08 sw (sp+8),r14
8001b10: 5b 9d 00 04 sw (sp+4),ra
* Round to the "requested sbrk amount" so hopefully we won't have
* to grow again for a while. This effectively does sbrk() calls
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
8001b14: 78 03 08 01 mvhi r3,0x801
8001b18: 38 63 49 20 ori r3,r3,0x4920
8001b1c: 28 6b 00 00 lw r11,(r3+0)
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
8001b20: b8 20 70 00 mv r14,r1
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
return (void *) 0;
8001b24: 34 0d 00 00 mvi r13,0
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
8001b28: 45 60 00 22 be r11,r0,8001bb0 <malloc_sbrk_extend_and_allocate+0xb4><== NEVER TAKEN
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
8001b2c: b9 60 10 00 mv r2,r11
8001b30: b4 2b 08 00 add r1,r1,r11
8001b34: f8 00 42 0b calli 8012360 <__udivsi3>
8001b38: b9 60 10 00 mv r2,r11
8001b3c: f8 00 41 a4 calli 80121cc <__mulsi3>
8001b40: b8 20 60 00 mv r12,r1
starting_address = (void *) sbrk(the_size);
8001b44: fb ff fa 34 calli 8000414 <sbrk>
8001b48: b8 20 10 00 mv r2,r1
if ( starting_address == (void*) -1 )
8001b4c: 34 01 ff ff mvi r1,-1
8001b50: 44 41 00 18 be r2,r1,8001bb0 <malloc_sbrk_extend_and_allocate+0xb4>
return (void *) 0;
if ( !_Protected_heap_Extend(
8001b54: 78 0b 08 01 mvhi r11,0x801
8001b58: 39 6b 40 4c ori r11,r11,0x404c
8001b5c: 29 61 00 00 lw r1,(r11+0)
8001b60: b9 80 18 00 mv r3,r12
8001b64: f8 00 0c 82 calli 8004d6c <_Protected_heap_Extend>
8001b68: 5c 20 00 07 bne r1,r0,8001b84 <malloc_sbrk_extend_and_allocate+0x88>
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
8001b6c: c8 0c 08 00 sub r1,r0,r12
8001b70: fb ff fa 29 calli 8000414 <sbrk>
errno = ENOMEM;
8001b74: f8 00 2c 23 calli 800cc00 <__errno>
8001b78: 34 02 00 0c mvi r2,12
8001b7c: 58 22 00 00 sw (r1+0),r2
return (void *) 0;
8001b80: e0 00 00 0c bi 8001bb0 <malloc_sbrk_extend_and_allocate+0xb4>
}
MSBUMP(space_available, the_size);
8001b84: 78 04 08 01 mvhi r4,0x801
8001b88: 38 84 48 f0 ori r4,r4,0x48f0
8001b8c: 28 81 00 00 lw r1,(r4+0)
8001b90: b9 c0 10 00 mv r2,r14
8001b94: 34 03 00 00 mvi r3,0
8001b98: b5 81 60 00 add r12,r12,r1
8001b9c: 29 61 00 00 lw r1,(r11+0)
8001ba0: 58 8c 00 00 sw (r4+0),r12
8001ba4: 34 04 00 00 mvi r4,0
8001ba8: f8 00 0c 57 calli 8004d04 <_Protected_heap_Allocate_aligned_with_boundary>
8001bac: b8 20 68 00 mv r13,r1
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
8001bb0: b9 a0 08 00 mv r1,r13
8001bb4: 2b 9d 00 04 lw ra,(sp+4)
8001bb8: 2b 8b 00 14 lw r11,(sp+20)
8001bbc: 2b 8c 00 10 lw r12,(sp+16)
8001bc0: 2b 8d 00 0c lw r13,(sp+12)
8001bc4: 2b 8e 00 08 lw r14,(sp+8)
8001bc8: 37 9c 00 14 addi sp,sp,20
8001bcc: c3 a0 00 00 ret
08010184 <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
8010184: 37 9c ff f0 addi sp,sp,-16
8010188: 5b 8b 00 08 sw (sp+8),r11
801018c: 5b 9d 00 04 sw (sp+4),ra
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
8010190: 28 2b 00 1c lw r11,(r1+28)
* POSIX 1003.1b does not specify what happens if you truncate a file
* and the new length is greater than the current size. We treat this
* as an extend operation.
*/
if ( length > the_jnode->info.file.size )
8010194: 29 64 00 50 lw r4,(r11+80)
8010198: 48 44 00 05 bg r2,r4,80101ac <memfile_ftruncate+0x28> <== NEVER TAKEN
801019c: 5c 82 00 08 bne r4,r2,80101bc <memfile_ftruncate+0x38> <== NEVER TAKEN
80101a0: 29 64 00 54 lw r4,(r11+84)
80101a4: 54 64 00 02 bgu r3,r4,80101ac <memfile_ftruncate+0x28>
80101a8: e0 00 00 05 bi 80101bc <memfile_ftruncate+0x38>
return IMFS_memfile_extend( the_jnode, length );
80101ac: b9 60 08 00 mv r1,r11
80101b0: b8 60 10 00 mv r2,r3
80101b4: fb ff fe ea calli 800fd5c <IMFS_memfile_extend>
80101b8: e0 00 00 0b bi 80101e4 <memfile_ftruncate+0x60>
/*
* The in-memory files do not currently reclaim memory until the file is
* deleted. So we leave the previously allocated blocks in place for
* future use and just set the length.
*/
the_jnode->info.file.size = length;
80101bc: 59 62 00 50 sw (r11+80),r2
80101c0: 59 63 00 54 sw (r11+84),r3
iop->size = the_jnode->info.file.size;
80101c4: 58 22 00 08 sw (r1+8),r2
80101c8: 58 23 00 0c sw (r1+12),r3
IMFS_update_atime( the_jnode );
80101cc: 34 02 00 00 mvi r2,0
80101d0: 37 81 00 0c addi r1,sp,12
80101d4: fb ff c9 6a calli 800277c <gettimeofday>
80101d8: 2b 81 00 0c lw r1,(sp+12)
80101dc: 59 61 00 40 sw (r11+64),r1
return 0;
80101e0: 34 01 00 00 mvi r1,0
}
80101e4: 2b 9d 00 04 lw ra,(sp+4)
80101e8: 2b 8b 00 08 lw r11,(sp+8)
80101ec: 37 9c 00 10 addi sp,sp,16
80101f0: c3 a0 00 00 ret
080101f4 <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
80101f4: 37 9c ff f4 addi sp,sp,-12
80101f8: 5b 8b 00 0c sw (sp+12),r11
80101fc: 5b 8c 00 08 sw (sp+8),r12
8010200: 5b 9d 00 04 sw (sp+4),ra
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
8010204: 28 2c 00 1c lw r12,(r1+28)
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
8010208: b8 20 58 00 mv r11,r1
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
801020c: 34 01 00 06 mvi r1,6
8010210: 29 82 00 4c lw r2,(r12+76)
8010214: 5c 41 00 0c bne r2,r1,8010244 <memfile_lseek+0x50>
if (iop->offset > the_jnode->info.linearfile.size)
8010218: 29 81 00 50 lw r1,(r12+80)
801021c: 29 63 00 10 lw r3,(r11+16)
8010220: 29 82 00 54 lw r2,(r12+84)
8010224: 48 61 00 05 bg r3,r1,8010238 <memfile_lseek+0x44> <== NEVER TAKEN
8010228: 5c 61 00 15 bne r3,r1,801027c <memfile_lseek+0x88> <== NEVER TAKEN
801022c: 29 63 00 14 lw r3,(r11+20)
8010230: 54 62 00 02 bgu r3,r2,8010238 <memfile_lseek+0x44> <== NEVER TAKEN
8010234: e0 00 00 12 bi 801027c <memfile_lseek+0x88>
iop->offset = the_jnode->info.linearfile.size;
8010238: 59 61 00 10 sw (r11+16),r1 <== NOT EXECUTED
801023c: 59 62 00 14 sw (r11+20),r2 <== NOT EXECUTED
8010240: e0 00 00 0f bi 801027c <memfile_lseek+0x88> <== NOT EXECUTED
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
8010244: 29 62 00 14 lw r2,(r11+20)
8010248: b9 80 08 00 mv r1,r12
801024c: fb ff fe c4 calli 800fd5c <IMFS_memfile_extend>
8010250: 44 20 00 07 be r1,r0,801026c <memfile_lseek+0x78>
rtems_set_errno_and_return_minus_one( ENOSPC );
8010254: f8 00 04 87 calli 8011470 <__errno>
8010258: 34 02 00 1c mvi r2,28
801025c: 58 22 00 00 sw (r1+0),r2
8010260: 34 01 ff ff mvi r1,-1
8010264: 34 02 ff ff mvi r2,-1
8010268: e0 00 00 07 bi 8010284 <memfile_lseek+0x90>
iop->size = the_jnode->info.file.size;
801026c: 29 81 00 50 lw r1,(r12+80)
8010270: 59 61 00 08 sw (r11+8),r1
8010274: 29 81 00 54 lw r1,(r12+84)
8010278: 59 61 00 0c sw (r11+12),r1
}
return iop->offset;
801027c: 29 61 00 10 lw r1,(r11+16)
8010280: 29 62 00 14 lw r2,(r11+20)
}
8010284: 2b 9d 00 04 lw ra,(sp+4)
8010288: 2b 8b 00 0c lw r11,(sp+12)
801028c: 2b 8c 00 08 lw r12,(sp+8)
8010290: 37 9c 00 0c addi sp,sp,12
8010294: c3 a0 00 00 ret
080100d0 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
80100d0: 37 9c ff f4 addi sp,sp,-12
80100d4: 5b 8b 00 0c sw (sp+12),r11
80100d8: 5b 8c 00 08 sw (sp+8),r12
80100dc: 5b 9d 00 04 sw (sp+4),ra
80100e0: b8 20 60 00 mv r12,r1
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
80100e4: 28 2b 00 1c lw r11,(r1+28)
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
80100e8: 28 21 00 18 lw r1,(r1+24)
80100ec: 20 21 02 04 andi r1,r1,0x204
80100f0: 44 20 00 13 be r1,r0,801013c <memfile_open+0x6c>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
80100f4: 29 62 00 4c lw r2,(r11+76)
80100f8: 34 01 00 06 mvi r1,6
80100fc: 5c 41 00 10 bne r2,r1,801013c <memfile_open+0x6c> <== ALWAYS TAKEN
uint32_t count = the_jnode->info.linearfile.size;
8010100: 29 64 00 54 lw r4,(r11+84) <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
8010104: 34 01 00 05 mvi r1,5 <== 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;
8010108: 29 63 00 58 lw r3,(r11+88) <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
801010c: 59 61 00 4c sw (r11+76),r1 <== NOT EXECUTED
the_jnode->info.file.size = 0;
8010110: 59 60 00 50 sw (r11+80),r0 <== NOT EXECUTED
8010114: 59 60 00 54 sw (r11+84),r0 <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
8010118: 59 60 00 58 sw (r11+88),r0 <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
801011c: 59 60 00 5c sw (r11+92),r0 <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
8010120: 59 60 00 60 sw (r11+96),r0 <== NOT EXECUTED
if ((count != 0)
8010124: 44 80 00 06 be r4,r0,801013c <memfile_open+0x6c> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
8010128: 34 02 00 00 mvi r2,0 <== NOT EXECUTED
801012c: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
8010130: fb ff ff 61 calli 800feb4 <IMFS_memfile_write> <== NOT EXECUTED
return -1;
8010134: 34 02 ff ff mvi r2,-1 <== NOT EXECUTED
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
8010138: 44 22 00 0d be r1,r2,801016c <memfile_open+0x9c> <== NOT EXECUTED
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
801013c: 29 81 00 18 lw r1,(r12+24)
8010140: 20 21 02 00 andi r1,r1,0x200
8010144: 44 20 00 05 be r1,r0,8010158 <memfile_open+0x88>
iop->offset = the_jnode->info.file.size;
8010148: 29 61 00 50 lw r1,(r11+80)
801014c: 59 81 00 10 sw (r12+16),r1
8010150: 29 61 00 54 lw r1,(r11+84)
8010154: 59 81 00 14 sw (r12+20),r1
iop->size = the_jnode->info.file.size;
8010158: 29 61 00 50 lw r1,(r11+80)
return 0;
801015c: 34 02 00 00 mvi r2,0
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
iop->offset = the_jnode->info.file.size;
iop->size = the_jnode->info.file.size;
8010160: 59 81 00 08 sw (r12+8),r1
8010164: 29 61 00 54 lw r1,(r11+84)
8010168: 59 81 00 0c sw (r12+12),r1
return 0;
}
801016c: b8 40 08 00 mv r1,r2
8010170: 2b 9d 00 04 lw ra,(sp+4)
8010174: 2b 8b 00 0c lw r11,(sp+12)
8010178: 2b 8c 00 08 lw r12,(sp+8)
801017c: 37 9c 00 0c addi sp,sp,12
8010180: c3 a0 00 00 ret
08002da0 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
8002da0: 37 9c ff b0 addi sp,sp,-80
8002da4: 5b 8b 00 3c sw (sp+60),r11
8002da8: 5b 8c 00 38 sw (sp+56),r12
8002dac: 5b 8d 00 34 sw (sp+52),r13
8002db0: 5b 8e 00 30 sw (sp+48),r14
8002db4: 5b 8f 00 2c sw (sp+44),r15
8002db8: 5b 90 00 28 sw (sp+40),r16
8002dbc: 5b 91 00 24 sw (sp+36),r17
8002dc0: 5b 92 00 20 sw (sp+32),r18
8002dc4: 5b 93 00 1c sw (sp+28),r19
8002dc8: 5b 94 00 18 sw (sp+24),r20
8002dcc: 5b 95 00 14 sw (sp+20),r21
8002dd0: 5b 96 00 10 sw (sp+16),r22
8002dd4: 5b 97 00 0c sw (sp+12),r23
8002dd8: 5b 98 00 08 sw (sp+8),r24
8002ddc: 5b 9d 00 04 sw (sp+4),ra
8002de0: b8 20 88 00 mv r17,r1
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
8002de4: 34 01 00 01 mvi r1,1
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
8002de8: b8 40 78 00 mv r15,r2
8002dec: b8 60 98 00 mv r19,r3
8002df0: b8 80 b0 00 mv r22,r4
8002df4: b8 a0 c0 00 mv r24,r5
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
8002df8: 50 24 00 02 bgeu r1,r4,8002e00 <mount+0x60>
8002dfc: e0 00 00 05 bi 8002e10 <mount+0x70>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
8002e00: b8 60 08 00 mv r1,r3
8002e04: f8 00 27 6d calli 800cbb8 <rtems_filesystem_get_mount_handler>
8002e08: b8 20 a0 00 mv r20,r1
if ( !mount_h )
8002e0c: 5c 20 00 04 bne r1,r0,8002e1c <mount+0x7c>
rtems_set_errno_and_return_minus_one( EINVAL );
8002e10: f8 00 39 98 calli 8011470 <__errno>
8002e14: 34 02 00 16 mvi r2,22
8002e18: e0 00 00 37 bi 8002ef4 <mount+0x154>
{
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;
8002e1c: 7d ee 00 00 cmpnei r14,r15,0
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
8002e20: b9 e0 60 00 mv r12,r15
8002e24: 5d c0 00 03 bne r14,r0,8002e30 <mount+0x90>
8002e28: 78 0c 08 01 mvhi r12,0x801
8002e2c: 39 8c 7f 30 ori r12,r12,0x7f30
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
8002e30: ba 60 08 00 mv r1,r19
8002e34: f8 00 3d f0 calli 80125f4 <strlen>
8002e38: 34 30 00 01 addi r16,r1,1
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
8002e3c: 34 0d 00 00 mvi r13,0
8002e40: 46 20 00 04 be r17,r0,8002e50 <mount+0xb0>
8002e44: ba 20 08 00 mv r1,r17
8002e48: f8 00 3d eb calli 80125f4 <strlen>
8002e4c: 34 2d 00 01 addi r13,r1,1
size_t target_size = strlen( target ) + 1;
8002e50: b9 80 08 00 mv r1,r12
8002e54: f8 00 3d e8 calli 80125f4 <strlen>
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
8002e58: 36 03 00 74 addi r3,r16,116
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
8002e5c: 34 37 00 01 addi r23,r1,1
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
8002e60: b4 6d 18 00 add r3,r3,r13
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
8002e64: b8 20 a8 00 mv r21,r1
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
8002e68: b4 77 10 00 add r2,r3,r23
8002e6c: 34 01 00 01 mvi r1,1
8002e70: fb ff fd 84 calli 8002480 <calloc>
8002e74: b8 20 58 00 mv r11,r1
if ( mt_entry != NULL ) {
8002e78: 44 20 00 1d be r1,r0,8002eec <mount+0x14c> <== NEVER TAKEN
char *str = (char *) mt_entry + sizeof( *mt_entry );
8002e7c: 34 32 00 74 addi r18,r1,116
memcpy( str, filesystemtype, filesystemtype_size );
8002e80: ba 00 18 00 mv r3,r16
8002e84: ba 60 10 00 mv r2,r19
8002e88: ba 40 08 00 mv r1,r18
8002e8c: f8 00 3c 2f calli 8011f48 <memcpy>
mt_entry->type = str;
str += filesystemtype_size;
8002e90: b6 50 80 00 add r16,r18,r16
memcpy( str, source_or_null, source_size );
8002e94: b9 a0 18 00 mv r3,r13
8002e98: ba 20 10 00 mv r2,r17
8002e9c: ba 00 08 00 mv r1,r16
mt_entry->dev = str;
str += source_size;
8002ea0: b6 0d 68 00 add r13,r16,r13
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
8002ea4: 59 72 00 6c sw (r11+108),r18
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
8002ea8: f8 00 3c 28 calli 8011f48 <memcpy>
mt_entry->dev = str;
str += source_size;
memcpy( str, target, target_size );
8002eac: b9 80 10 00 mv r2,r12
8002eb0: ba e0 18 00 mv r3,r23
8002eb4: b9 a0 08 00 mv r1,r13
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
8002eb8: 59 70 00 70 sw (r11+112),r16
str += source_size;
memcpy( str, target, target_size );
8002ebc: f8 00 3c 23 calli 8011f48 <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;
8002ec0: 78 03 08 01 mvhi r3,0x801
8002ec4: b8 60 10 00 mv r2,r3
8002ec8: 35 61 00 38 addi r1,r11,56
8002ecc: 38 42 7f 84 ori r2,r2,0x7f84
8002ed0: 34 03 00 30 mvi r3,48
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
memcpy( str, target, target_size );
mt_entry->target = str;
8002ed4: 59 6d 00 68 sw (r11+104),r13
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
8002ed8: 59 6b 00 2c sw (r11+44),r11
mt_entry->options = options;
8002edc: 59 76 00 30 sw (r11+48),r22
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
8002ee0: f8 00 3c 1a calli 8011f48 <memcpy>
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
8002ee4: 45 c0 00 2f be r14,r0,8002fa0 <mount+0x200>
8002ee8: e0 00 00 06 bi 8002f00 <mount+0x160>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
8002eec: f8 00 39 61 calli 8011470 <__errno> <== NOT EXECUTED
8002ef0: 34 02 00 0c mvi r2,12 <== NOT EXECUTED
8002ef4: 58 22 00 00 sw (r1+0),r2
8002ef8: 34 0d ff ff mvi r13,-1
8002efc: e0 00 00 5a bi 8003064 <mount+0x2c4>
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
8002f00: 37 8c 00 40 addi r12,sp,64
8002f04: ba a0 10 00 mv r2,r21
8002f08: b9 e0 08 00 mv r1,r15
8002f0c: 34 03 00 07 mvi r3,7
8002f10: b9 80 20 00 mv r4,r12
8002f14: 34 05 00 01 mvi r5,1
8002f18: fb ff fd 9b calli 8002584 <rtems_filesystem_evaluate_path>
8002f1c: 34 02 ff ff mvi r2,-1
8002f20: 44 22 00 4a be r1,r2,8003048 <mount+0x2a8> <== NEVER TAKEN
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
8002f24: 2b 81 00 4c lw r1,(sp+76)
8002f28: 28 23 00 10 lw r3,(r1+16)
8002f2c: b9 80 08 00 mv r1,r12
8002f30: d8 60 00 00 call r3
8002f34: 34 02 00 01 mvi r2,1
8002f38: 44 22 00 04 be r1,r2,8002f48 <mount+0x1a8>
errno = ENOTDIR;
8002f3c: f8 00 39 4d calli 8011470 <__errno>
8002f40: 34 02 00 14 mvi r2,20
8002f44: e0 00 00 20 bi 8002fc4 <mount+0x224>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
8002f48: 2b 82 00 40 lw r2,(sp+64)
8002f4c: 78 01 08 00 mvhi r1,0x800
8002f50: 38 21 2c bc ori r1,r1,0x2cbc
8002f54: fb ff ff 71 calli 8002d18 <rtems_filesystem_mount_iterate>
8002f58: b8 20 68 00 mv r13,r1
8002f5c: 44 20 00 04 be r1,r0,8002f6c <mount+0x1cc>
errno = EBUSY;
8002f60: f8 00 39 44 calli 8011470 <__errno>
8002f64: 34 02 00 10 mvi r2,16
8002f68: e0 00 00 17 bi 8002fc4 <mount+0x224>
* 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;
8002f6c: 2b 81 00 40 lw r1,(sp+64)
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;
8002f70: 2b 82 00 50 lw r2,(sp+80)
* 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;
8002f74: 59 61 00 08 sw (r11+8),r1
mt_entry->mt_point_node.handlers = loc.handlers;
8002f78: 2b 81 00 48 lw r1,(sp+72)
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
8002f7c: 59 62 00 18 sw (r11+24),r2
* 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;
8002f80: 59 61 00 10 sw (r11+16),r1
mt_entry->mt_point_node.ops = loc.ops;
8002f84: 2b 81 00 4c lw r1,(sp+76)
/*
* 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 ) ) {
8002f88: 28 23 00 20 lw r3,(r1+32)
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
8002f8c: 59 61 00 14 sw (r11+20),r1
/*
* 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 ) ) {
8002f90: b9 60 08 00 mv r1,r11
8002f94: d8 60 00 00 call r3
8002f98: 44 2d 00 0d be r1,r13,8002fcc <mount+0x22c> <== ALWAYS TAKEN
8002f9c: e0 00 00 2c bi 800304c <mount+0x2ac> <== NOT EXECUTED
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
8002fa0: 78 04 08 01 mvhi r4,0x801
8002fa4: 38 84 91 28 ori r4,r4,0x9128
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
8002fa8: 28 81 00 00 lw r1,(r4+0)
8002fac: 78 03 08 01 mvhi r3,0x801
8002fb0: 38 63 91 2c ori r3,r3,0x912c
)
{
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;
8002fb4: 34 0c 00 00 mvi r12,0
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
8002fb8: 44 23 00 05 be r1,r3,8002fcc <mount+0x22c> <== ALWAYS TAKEN
errno = EINVAL;
8002fbc: f8 00 39 2d calli 8011470 <__errno> <== NOT EXECUTED
8002fc0: 34 02 00 16 mvi r2,22 <== NOT EXECUTED
8002fc4: 58 22 00 00 sw (r1+0),r2
goto cleanup_and_bail;
8002fc8: e0 00 00 21 bi 800304c <mount+0x2ac>
* 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 ) ) {
8002fcc: b9 60 08 00 mv r1,r11
8002fd0: bb 00 10 00 mv r2,r24
8002fd4: da 80 00 00 call r20
8002fd8: 44 20 00 06 be r1,r0,8002ff0 <mount+0x250>
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
8002fdc: 2b 81 00 4c lw r1,(sp+76)
8002fe0: 28 22 00 28 lw r2,(r1+40)
8002fe4: b9 60 08 00 mv r1,r11
8002fe8: d8 40 00 00 call r2
goto cleanup_and_bail;
8002fec: e0 00 00 18 bi 800304c <mount+0x2ac>
}
/*
* Add the mount table entry to the mount table chain
*/
rtems_libio_lock();
8002ff0: fb ff ff 36 calli 8002cc8 <rtems_libio_lock>
8002ff4: 78 01 08 01 mvhi r1,0x801
8002ff8: 38 21 91 28 ori r1,r1,0x9128
8002ffc: b9 60 10 00 mv r2,r11
rtems_libio_unlock();
if ( !has_target )
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
8003000: 34 0d 00 00 mvi r13,0
8003004: f8 00 06 d1 calli 8004b48 <_Chain_Append>
/*
* Add the mount table entry to the mount table chain
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
8003008: fb ff ff 3b calli 8002cf4 <rtems_libio_unlock>
if ( !has_target )
800300c: 5d cd 00 16 bne r14,r13,8003064 <mount+0x2c4>
rtems_filesystem_root = mt_entry->mt_fs_root;
8003010: 78 01 08 01 mvhi r1,0x801
8003014: 38 21 91 34 ori r1,r1,0x9134
8003018: 28 21 00 00 lw r1,(r1+0)
800301c: 29 66 00 1c lw r6,(r11+28)
8003020: 29 65 00 20 lw r5,(r11+32)
8003024: 29 64 00 24 lw r4,(r11+36)
8003028: 29 63 00 28 lw r3,(r11+40)
800302c: 29 62 00 2c lw r2,(r11+44)
8003030: 58 26 00 18 sw (r1+24),r6
8003034: 58 25 00 1c sw (r1+28),r5
8003038: 58 24 00 20 sw (r1+32),r4
800303c: 58 23 00 24 sw (r1+36),r3
8003040: 58 22 00 28 sw (r1+40),r2
8003044: e0 00 00 08 bi 8003064 <mount+0x2c4>
)
{
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;
8003048: 34 0c 00 00 mvi r12,0 <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
800304c: b9 60 08 00 mv r1,r11
8003050: fb ff fd 9d calli 80026c4 <free>
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
8003054: 34 0d ff ff mvi r13,-1
cleanup_and_bail:
free( mt_entry );
if ( loc_to_free )
8003058: 45 80 00 03 be r12,r0,8003064 <mount+0x2c4> <== NEVER TAKEN
rtems_filesystem_freenode( loc_to_free );
800305c: b9 80 08 00 mv r1,r12
8003060: fb ff fd 91 calli 80026a4 <rtems_filesystem_freenode>
return -1;
}
8003064: b9 a0 08 00 mv r1,r13
8003068: 2b 9d 00 04 lw ra,(sp+4)
800306c: 2b 8b 00 3c lw r11,(sp+60)
8003070: 2b 8c 00 38 lw r12,(sp+56)
8003074: 2b 8d 00 34 lw r13,(sp+52)
8003078: 2b 8e 00 30 lw r14,(sp+48)
800307c: 2b 8f 00 2c lw r15,(sp+44)
8003080: 2b 90 00 28 lw r16,(sp+40)
8003084: 2b 91 00 24 lw r17,(sp+36)
8003088: 2b 92 00 20 lw r18,(sp+32)
800308c: 2b 93 00 1c lw r19,(sp+28)
8003090: 2b 94 00 18 lw r20,(sp+24)
8003094: 2b 95 00 14 lw r21,(sp+20)
8003098: 2b 96 00 10 lw r22,(sp+16)
800309c: 2b 97 00 0c lw r23,(sp+12)
80030a0: 2b 98 00 08 lw r24,(sp+8)
80030a4: 37 9c 00 50 addi sp,sp,80
80030a8: c3 a0 00 00 ret
0800204c <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
800204c: 37 9c ff e8 addi sp,sp,-24
8002050: 5b 8b 00 0c sw (sp+12),r11
8002054: 5b 8c 00 08 sw (sp+8),r12
8002058: 5b 9d 00 04 sw (sp+4),ra
800205c: b8 20 60 00 mv r12,r1
8002060: b8 40 58 00 mv r11,r2
int rv = -1;
if (target != NULL) {
8002064: 44 40 00 0f be r2,r0,80020a0 <mount_and_make_target_path+0x54>
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
8002068: b8 40 08 00 mv r1,r2
800206c: 34 02 01 ff mvi r2,511
8002070: 5b 83 00 18 sw (sp+24),r3
8002074: 5b 84 00 14 sw (sp+20),r4
8002078: 5b 85 00 10 sw (sp+16),r5
800207c: f8 00 02 91 calli 8002ac0 <rtems_mkdir>
if (rv == 0) {
8002080: 2b 83 00 18 lw r3,(sp+24)
8002084: 2b 84 00 14 lw r4,(sp+20)
8002088: 2b 85 00 10 lw r5,(sp+16)
800208c: 5c 20 00 09 bne r1,r0,80020b0 <mount_and_make_target_path+0x64><== NEVER TAKEN
rv = mount(
8002090: b9 80 08 00 mv r1,r12
8002094: b9 60 10 00 mv r2,r11
8002098: f8 00 00 44 calli 80021a8 <mount>
800209c: e0 00 00 05 bi 80020b0 <mount_and_make_target_path+0x64>
options,
data
);
}
} else {
errno = EINVAL;
80020a0: f8 00 2a 33 calli 800c96c <__errno>
80020a4: 34 02 00 16 mvi r2,22
80020a8: 58 22 00 00 sw (r1+0),r2
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
80020ac: 34 01 ff ff mvi r1,-1
} else {
errno = EINVAL;
}
return rv;
}
80020b0: 2b 9d 00 04 lw ra,(sp+4)
80020b4: 2b 8b 00 0c lw r11,(sp+12)
80020b8: 2b 8c 00 08 lw r12,(sp+8)
80020bc: 37 9c 00 18 addi sp,sp,24
80020c0: c3 a0 00 00 ret
080032d4 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
80032d4: 37 9c ff f0 addi sp,sp,-16
80032d8: 5b 8b 00 10 sw (sp+16),r11
80032dc: 5b 8c 00 0c sw (sp+12),r12
80032e0: 5b 8d 00 08 sw (sp+8),r13
80032e4: 5b 9d 00 04 sw (sp+4),ra
80032e8: b8 20 68 00 mv r13,r1
80032ec: b8 40 60 00 mv r12,r2
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
80032f0: 5c 22 00 05 bne r1,r2,8003304 <newlib_delete_hook+0x30>
ptr = _REENT;
80032f4: 78 02 08 01 mvhi r2,0x801
80032f8: 38 42 92 10 ori r2,r2,0x9210
80032fc: 28 4b 00 00 lw r11,(r2+0)
8003300: e0 00 00 02 bi 8003308 <newlib_delete_hook+0x34>
} else {
ptr = deleted_task->libc_reent;
8003304: 28 4b 01 18 lw r11,(r2+280)
}
if (ptr && ptr != _global_impure_ptr) {
8003308: 45 60 00 0b be r11,r0,8003334 <newlib_delete_hook+0x60> <== NEVER TAKEN
800330c: 78 02 08 01 mvhi r2,0x801
8003310: 38 42 87 40 ori r2,r2,0x8740
8003314: 28 41 00 00 lw r1,(r2+0)
8003318: 45 61 00 07 be r11,r1,8003334 <newlib_delete_hook+0x60>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
800331c: 78 02 08 00 mvhi r2,0x800
8003320: b9 60 08 00 mv r1,r11
8003324: 38 42 30 b0 ori r2,r2,0x30b0
8003328: f8 00 3a a0 calli 8011da8 <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
800332c: b9 60 08 00 mv r1,r11
8003330: f8 00 12 ee calli 8007ee8 <_Workspace_Free>
#endif
}
deleted_task->libc_reent = NULL;
8003334: 59 80 01 18 sw (r12+280),r0
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
8003338: 5d ac 00 04 bne r13,r12,8003348 <newlib_delete_hook+0x74>
_REENT = 0;
800333c: 78 01 08 01 mvhi r1,0x801
8003340: 38 21 92 10 ori r1,r1,0x9210
8003344: 58 20 00 00 sw (r1+0),r0
}
}
8003348: 2b 9d 00 04 lw ra,(sp+4)
800334c: 2b 8b 00 10 lw r11,(sp+16)
8003350: 2b 8c 00 0c lw r12,(sp+12)
8003354: 2b 8d 00 08 lw r13,(sp+8)
8003358: 37 9c 00 10 addi sp,sp,16
800335c: c3 a0 00 00 ret
080030b0 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
80030b0: 37 9c ff f8 addi sp,sp,-8
80030b4: 5b 8b 00 08 sw (sp+8),r11
80030b8: 5b 9d 00 04 sw (sp+4),ra
80030bc: b8 20 58 00 mv r11,r1
switch ( fileno(fp) ) {
80030c0: f8 00 3a 01 calli 80118c4 <fileno>
80030c4: 34 02 00 02 mvi r2,2
80030c8: 54 22 00 0c bgu r1,r2,80030f8 <newlib_free_buffers+0x48> <== NEVER TAKEN
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
80030cc: 2d 61 00 0c lhu r1,(r11+12)
80030d0: 20 21 00 80 andi r1,r1,0x80
80030d4: 44 20 00 0b be r1,r0,8003100 <newlib_free_buffers+0x50> <== ALWAYS TAKEN
free( fp->_bf._base );
80030d8: 29 61 00 10 lw r1,(r11+16) <== NOT EXECUTED
80030dc: fb ff fd 7a calli 80026c4 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
80030e0: 2d 61 00 0c lhu r1,(r11+12) <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
80030e4: 59 60 00 00 sw (r11+0),r0 <== NOT EXECUTED
80030e8: 59 60 00 10 sw (r11+16),r0 <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
80030ec: 20 21 ff 7f andi r1,r1,0xff7f <== NOT EXECUTED
80030f0: 0d 61 00 0c sh (r11+12),r1 <== NOT EXECUTED
80030f4: e0 00 00 03 bi 8003100 <newlib_free_buffers+0x50> <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
80030f8: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
80030fc: f8 00 39 3d calli 80115f0 <fclose> <== NOT EXECUTED
}
return 0;
}
8003100: 34 01 00 00 mvi r1,0
8003104: 2b 9d 00 04 lw ra,(sp+4)
8003108: 2b 8b 00 08 lw r11,(sp+8)
800310c: 37 9c 00 08 addi sp,sp,8
8003110: c3 a0 00 00 ret
080033e4 <open>:
int open(
const char *pathname,
int flags,
...
)
{
80033e4: 37 9c ff ac addi sp,sp,-84
80033e8: 5b 8b 00 24 sw (sp+36),r11
80033ec: 5b 8c 00 20 sw (sp+32),r12
80033f0: 5b 8d 00 1c sw (sp+28),r13
80033f4: 5b 8e 00 18 sw (sp+24),r14
80033f8: 5b 8f 00 14 sw (sp+20),r15
80033fc: 5b 90 00 10 sw (sp+16),r16
8003400: 5b 91 00 0c sw (sp+12),r17
8003404: 5b 92 00 08 sw (sp+8),r18
8003408: 5b 9d 00 04 sw (sp+4),ra
800340c: b8 20 78 00 mv r15,r1
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
8003410: 34 41 00 01 addi r1,r2,1
int open(
const char *pathname,
int flags,
...
)
{
8003414: 5b 82 00 3c sw (sp+60),r2
8003418: b8 40 70 00 mv r14,r2
800341c: 5b 83 00 40 sw (sp+64),r3
8003420: 5b 84 00 44 sw (sp+68),r4
8003424: 5b 85 00 48 sw (sp+72),r5
8003428: 5b 86 00 4c sw (sp+76),r6
800342c: 5b 87 00 50 sw (sp+80),r7
8003430: 5b 88 00 54 sw (sp+84),r8
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
if ( ( status & _FREAD ) == _FREAD )
8003434: 20 22 00 01 andi r2,r1,0x1
int eval_flags;
/*
* Set the Evaluation flags
*/
eval_flags = 0;
8003438: 34 10 00 00 mvi r16,0
status = flags + 1;
if ( ( status & _FREAD ) == _FREAD )
800343c: 44 40 00 02 be r2,r0,8003444 <open+0x60>
eval_flags |= RTEMS_LIBIO_PERMS_READ;
8003440: 34 10 00 04 mvi r16,4
if ( ( status & _FWRITE ) == _FWRITE )
8003444: 20 21 00 02 andi r1,r1,0x2
8003448: 44 20 00 02 be r1,r0,8003450 <open+0x6c>
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
800344c: 3a 10 00 02 ori r16,r16,0x2
va_start(ap, flags);
mode = va_arg( ap, int );
8003450: 2b 92 00 40 lw r18,(sp+64)
* code does not require changes here since network file
* descriptors are obtained using socket(), not open().
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
8003454: f8 00 25 00 calli 800c854 <rtems_libio_allocate>
8003458: b8 20 58 00 mv r11,r1
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
800345c: 34 0d 00 00 mvi r13,0
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
rc = ENFILE;
8003460: 34 0c 00 17 mvi r12,23
* descriptors are obtained using socket(), not open().
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
8003464: 44 20 00 62 be r1,r0,80035ec <open+0x208>
}
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
8003468: b9 e0 08 00 mv r1,r15
800346c: f8 00 3c 62 calli 80125f4 <strlen>
8003470: 37 91 00 28 addi r17,sp,40
8003474: b8 20 10 00 mv r2,r1
8003478: ba 00 18 00 mv r3,r16
800347c: b9 e0 08 00 mv r1,r15
8003480: ba 20 20 00 mv r4,r17
8003484: 34 05 00 01 mvi r5,1
8003488: fb ff fc 3f calli 8002584 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
800348c: 34 02 ff ff mvi r2,-1
8003490: 5c 22 00 1c bne r1,r2,8003500 <open+0x11c>
if ( errno != ENOENT ) {
8003494: f8 00 37 f7 calli 8011470 <__errno>
8003498: 28 22 00 00 lw r2,(r1+0)
800349c: 34 01 00 02 mvi r1,2
80034a0: 5c 41 00 0a bne r2,r1,80034c8 <open+0xe4>
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
80034a4: 21 c1 02 00 andi r1,r14,0x200
rc = ENOENT;
80034a8: 34 0c 00 02 mvi r12,2
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
80034ac: 44 20 00 50 be r1,r0,80035ec <open+0x208>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
80034b0: b9 e0 08 00 mv r1,r15
80034b4: 3a 42 80 00 ori r2,r18,0x8000
80034b8: 34 03 00 00 mvi r3,0
80034bc: 34 04 00 00 mvi r4,0
80034c0: fb ff fd c3 calli 8002bcc <mknod>
if ( rc ) {
80034c4: 44 20 00 04 be r1,r0,80034d4 <open+0xf0> <== ALWAYS TAKEN
rc = errno;
80034c8: f8 00 37 ea calli 8011470 <__errno>
80034cc: 28 2c 00 00 lw r12,(r1+0)
goto done;
80034d0: e0 00 00 46 bi 80035e8 <open+0x204>
/*
* After we do the mknod(), we have to evaluate the path to get the
* "loc" structure needed to actually have the file itself open.
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
80034d4: b9 e0 08 00 mv r1,r15
80034d8: f8 00 3c 47 calli 80125f4 <strlen>
80034dc: b8 20 10 00 mv r2,r1
80034e0: 34 03 00 00 mvi r3,0
80034e4: b9 e0 08 00 mv r1,r15
80034e8: ba 20 20 00 mv r4,r17
80034ec: 34 05 00 01 mvi r5,1
80034f0: fb ff fc 25 calli 8002584 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
80034f4: 34 0c 00 0d mvi r12,13
* "loc" structure needed to actually have the file itself open.
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
80034f8: 5d a1 00 3d bne r13,r1,80035ec <open+0x208> <== NEVER TAKEN
80034fc: e0 00 00 06 bi 8003514 <open+0x130>
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
8003500: 21 c2 0a 00 andi r2,r14,0xa00
8003504: 34 01 0a 00 mvi r1,2560
/* We were trying to create a file that already exists */
rc = EEXIST;
loc_to_free = &loc;
8003508: ba 20 68 00 mv r13,r17
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
/* We were trying to create a file that already exists */
rc = EEXIST;
800350c: 34 0c 00 11 mvi r12,17
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
8003510: 44 41 00 37 be r2,r1,80035ec <open+0x208>
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
8003514: b9 c0 08 00 mv r1,r14
8003518: 29 6c 00 18 lw r12,(r11+24)
800351c: f8 00 24 a4 calli 800c7ac <rtems_libio_fcntl_flags>
iop->pathinfo = loc;
8003520: 2b 82 00 28 lw r2,(sp+40)
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
8003524: b8 2c 08 00 or r1,r1,r12
8003528: 59 61 00 18 sw (r11+24),r1
iop->pathinfo = loc;
800352c: 59 62 00 1c sw (r11+28),r2
8003530: 2b 82 00 2c lw r2,(sp+44)
8003534: 2b 81 00 30 lw r1,(sp+48)
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
8003538: b9 c0 18 00 mv r3,r14
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
iop->pathinfo = loc;
800353c: 59 62 00 20 sw (r11+32),r2
8003540: 2b 82 00 34 lw r2,(sp+52)
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
8003544: 28 25 00 00 lw r5,(r1+0)
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
iop->pathinfo = loc;
8003548: 59 61 00 24 sw (r11+36),r1
800354c: 59 62 00 28 sw (r11+40),r2
8003550: 2b 82 00 38 lw r2,(sp+56)
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
8003554: b9 60 08 00 mv r1,r11
8003558: ba 40 20 00 mv r4,r18
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
iop->pathinfo = loc;
800355c: 59 62 00 2c sw (r11+44),r2
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
8003560: b9 e0 10 00 mv r2,r15
8003564: d8 a0 00 00 call r5
if ( rc ) {
8003568: 44 20 00 05 be r1,r0,800357c <open+0x198>
rc = errno;
800356c: f8 00 37 c1 calli 8011470 <__errno>
8003570: 28 2c 00 00 lw r12,(r1+0)
rc = EEXIST;
loc_to_free = &loc;
goto done;
}
loc_to_free = &loc;
8003574: 37 8d 00 28 addi r13,sp,40
iop->pathinfo = loc;
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
if ( rc ) {
rc = errno;
goto done;
8003578: e0 00 00 1c bi 80035e8 <open+0x204>
}
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
800357c: 21 ce 04 00 andi r14,r14,0x400
8003580: 45 c1 00 25 be r14,r1,8003614 <open+0x230>
rc = ftruncate( iop - rtems_libio_iops, 0 );
8003584: 78 01 08 01 mvhi r1,0x801
8003588: 38 21 98 58 ori r1,r1,0x9858
800358c: 28 21 00 00 lw r1,(r1+0)
8003590: 34 02 00 06 mvi r2,6
rc = EEXIST;
loc_to_free = &loc;
goto done;
}
loc_to_free = &loc;
8003594: 37 8d 00 28 addi r13,sp,40
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
8003598: c9 61 08 00 sub r1,r11,r1
800359c: f8 00 4e 84 calli 8016fac <__ashrsi3>
80035a0: 34 02 00 00 mvi r2,0
80035a4: f8 00 24 24 calli 800c634 <ftruncate>
80035a8: b8 20 60 00 mv r12,r1
if ( rc ) {
80035ac: 44 20 00 0f be r1,r0,80035e8 <open+0x204>
if(errno) rc = errno;
80035b0: f8 00 37 b0 calli 8011470 <__errno>
80035b4: 28 21 00 00 lw r1,(r1+0)
80035b8: 44 20 00 03 be r1,r0,80035c4 <open+0x1e0> <== NEVER TAKEN
80035bc: f8 00 37 ad calli 8011470 <__errno>
80035c0: 28 2c 00 00 lw r12,(r1+0)
close( iop - rtems_libio_iops );
80035c4: 78 01 08 01 mvhi r1,0x801
80035c8: 38 21 98 58 ori r1,r1,0x9858
80035cc: 28 21 00 00 lw r1,(r1+0)
80035d0: 34 02 00 06 mvi r2,6
/* those are released by close(): */
iop = 0;
loc_to_free = NULL;
80035d4: 34 0d 00 00 mvi r13,0
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
close( iop - rtems_libio_iops );
80035d8: c9 61 08 00 sub r1,r11,r1
80035dc: f8 00 4e 74 calli 8016fac <__ashrsi3>
80035e0: f8 00 23 e8 calli 800c580 <close>
/* those are released by close(): */
iop = 0;
80035e4: 34 0b 00 00 mvi r11,0
* Single exit and clean up path.
*/
done:
va_end(ap);
if ( rc ) {
80035e8: 45 80 00 0b be r12,r0,8003614 <open+0x230>
if ( iop )
80035ec: 45 60 00 03 be r11,r0,80035f8 <open+0x214>
rtems_libio_free( iop );
80035f0: b9 60 08 00 mv r1,r11
80035f4: f8 00 24 c6 calli 800c90c <rtems_libio_free>
if ( loc_to_free )
80035f8: 45 a0 00 03 be r13,r0,8003604 <open+0x220>
rtems_filesystem_freenode( loc_to_free );
80035fc: b9 a0 08 00 mv r1,r13
8003600: fb ff fc 29 calli 80026a4 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( rc );
8003604: f8 00 37 9b calli 8011470 <__errno>
8003608: 58 2c 00 00 sw (r1+0),r12
800360c: 34 01 ff ff mvi r1,-1
8003610: e0 00 00 07 bi 800362c <open+0x248>
}
return iop - rtems_libio_iops;
8003614: 78 01 08 01 mvhi r1,0x801
8003618: 38 21 98 58 ori r1,r1,0x9858
800361c: 28 21 00 00 lw r1,(r1+0)
8003620: 34 02 00 06 mvi r2,6
8003624: c9 61 08 00 sub r1,r11,r1
8003628: f8 00 4e 61 calli 8016fac <__ashrsi3>
}
800362c: 2b 9d 00 04 lw ra,(sp+4)
8003630: 2b 8b 00 24 lw r11,(sp+36)
8003634: 2b 8c 00 20 lw r12,(sp+32)
8003638: 2b 8d 00 1c lw r13,(sp+28)
800363c: 2b 8e 00 18 lw r14,(sp+24)
8003640: 2b 8f 00 14 lw r15,(sp+20)
8003644: 2b 90 00 10 lw r16,(sp+16)
8003648: 2b 91 00 0c lw r17,(sp+12)
800364c: 2b 92 00 08 lw r18,(sp+8)
8003650: 37 9c 00 54 addi sp,sp,84
8003654: c3 a0 00 00 ret
08003360 <open_dev_console>:
/*
* This is a replaceable stub which opens the console, if present.
*/
void open_dev_console(void)
{
8003360: 37 9c ff f4 addi sp,sp,-12
8003364: 5b 8b 00 0c sw (sp+12),r11
8003368: 5b 8c 00 08 sw (sp+8),r12
800336c: 5b 9d 00 04 sw (sp+4),ra
int stderr_fd;
/*
* Attempt to open /dev/console.
*/
if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) {
8003370: 78 0b 08 01 mvhi r11,0x801
8003374: 39 6b 7e ac ori r11,r11,0x7eac
8003378: b9 60 08 00 mv r1,r11
800337c: 34 02 00 00 mvi r2,0
8003380: 34 03 00 00 mvi r3,0
8003384: f8 00 00 18 calli 80033e4 <open>
8003388: 34 0c ff ff mvi r12,-1
800338c: 44 2c 00 11 be r1,r12,80033d0 <open_dev_console+0x70>
/*
* But if we find /dev/console once, we better find it twice more
* or something is REALLY wrong.
*/
if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1)
8003390: 34 02 00 01 mvi r2,1
8003394: b9 60 08 00 mv r1,r11
8003398: 34 03 00 00 mvi r3,0
800339c: f8 00 00 12 calli 80033e4 <open>
rtems_fatal_error_occurred( 0x55544431 ); /* error STD1 */
80033a0: 78 02 08 01 mvhi r2,0x801
80033a4: 38 42 7f b8 ori r2,r2,0x7fb8
/*
* But if we find /dev/console once, we better find it twice more
* or something is REALLY wrong.
*/
if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1)
80033a8: 44 2c 00 08 be r1,r12,80033c8 <open_dev_console+0x68> <== NEVER TAKEN
rtems_fatal_error_occurred( 0x55544431 ); /* error STD1 */
if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1)
80033ac: b9 60 08 00 mv r1,r11
80033b0: 34 02 00 01 mvi r2,1
80033b4: 34 03 00 00 mvi r3,0
80033b8: f8 00 00 0b calli 80033e4 <open>
80033bc: 5c 2c 00 05 bne r1,r12,80033d0 <open_dev_console+0x70> <== ALWAYS TAKEN
rtems_fatal_error_occurred( 0x55544432 ); /* error STD2 */
80033c0: 78 02 08 01 mvhi r2,0x801 <== NOT EXECUTED
80033c4: 38 42 7f bc ori r2,r2,0x7fbc <== NOT EXECUTED
80033c8: 28 41 00 00 lw r1,(r2+0) <== NOT EXECUTED
80033cc: f8 00 04 54 calli 800451c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
80033d0: 2b 9d 00 04 lw ra,(sp+4)
80033d4: 2b 8b 00 0c lw r11,(sp+12)
80033d8: 2b 8c 00 08 lw r12,(sp+8)
80033dc: 37 9c 00 0c addi sp,sp,12
80033e0: c3 a0 00 00 ret
08003e68 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
8003e68: 37 9c ff f4 addi sp,sp,-12
8003e6c: 5b 8b 00 08 sw (sp+8),r11
8003e70: 5b 9d 00 04 sw (sp+4),ra
8003e74: 33 81 00 0c sb (sp+12),r1
int i;
if (tty->termios.c_oflag & OPOST) {
8003e78: 28 41 00 34 lw r1,(r2+52)
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
8003e7c: b8 40 58 00 mv r11,r2
int i;
if (tty->termios.c_oflag & OPOST) {
8003e80: 20 22 00 01 andi r2,r1,0x1
8003e84: 44 40 00 4d be r2,r0,8003fb8 <oproc+0x150> <== NEVER TAKEN
switch (c) {
8003e88: 43 82 00 0c lbu r2,(sp+12)
8003e8c: 34 03 00 09 mvi r3,9
8003e90: 44 43 00 21 be r2,r3,8003f14 <oproc+0xac>
8003e94: 54 43 00 04 bgu r2,r3,8003ea4 <oproc+0x3c> <== ALWAYS TAKEN
8003e98: 34 03 00 08 mvi r3,8 <== NOT EXECUTED
8003e9c: 5c 43 00 30 bne r2,r3,8003f5c <oproc+0xf4> <== NOT EXECUTED
8003ea0: e0 00 00 2b bi 8003f4c <oproc+0xe4> <== NOT EXECUTED
8003ea4: 34 03 00 0a mvi r3,10
8003ea8: 44 43 00 04 be r2,r3,8003eb8 <oproc+0x50>
8003eac: 34 03 00 0d mvi r3,13
8003eb0: 5c 43 00 2b bne r2,r3,8003f5c <oproc+0xf4> <== ALWAYS TAKEN
8003eb4: e0 00 00 0c bi 8003ee4 <oproc+0x7c> <== NOT EXECUTED
case '\n':
if (tty->termios.c_oflag & ONLRET)
8003eb8: 20 22 00 20 andi r2,r1,0x20
8003ebc: 44 40 00 02 be r2,r0,8003ec4 <oproc+0x5c> <== ALWAYS TAKEN
tty->column = 0;
8003ec0: 59 60 00 28 sw (r11+40),r0 <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
8003ec4: 20 21 00 04 andi r1,r1,0x4
8003ec8: 44 20 00 3c be r1,r0,8003fb8 <oproc+0x150> <== NEVER TAKEN
rtems_termios_puts ("\r", 1, tty);
8003ecc: 78 01 08 02 mvhi r1,0x802
8003ed0: 38 21 38 f0 ori r1,r1,0x38f0
8003ed4: 34 02 00 01 mvi r2,1
8003ed8: b9 60 18 00 mv r3,r11
8003edc: fb ff ff 8d calli 8003d10 <rtems_termios_puts>
8003ee0: e0 00 00 0b bi 8003f0c <oproc+0xa4>
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
8003ee4: 20 22 00 10 andi r2,r1,0x10 <== NOT EXECUTED
8003ee8: 44 40 00 03 be r2,r0,8003ef4 <oproc+0x8c> <== NOT EXECUTED
8003eec: 29 62 00 28 lw r2,(r11+40) <== NOT EXECUTED
8003ef0: 44 40 00 36 be r2,r0,8003fc8 <oproc+0x160> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
8003ef4: 20 22 00 08 andi r2,r1,0x8 <== NOT EXECUTED
8003ef8: 44 40 00 05 be r2,r0,8003f0c <oproc+0xa4> <== NOT EXECUTED
c = '\n';
8003efc: 34 02 00 0a mvi r2,10 <== NOT EXECUTED
8003f00: 33 82 00 0c sb (sp+12),r2 <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
8003f04: 20 21 00 20 andi r1,r1,0x20 <== NOT EXECUTED
8003f08: 44 20 00 2c be r1,r0,8003fb8 <oproc+0x150> <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
8003f0c: 59 60 00 28 sw (r11+40),r0
break;
8003f10: e0 00 00 2a bi 8003fb8 <oproc+0x150>
case '\t':
i = 8 - (tty->column & 7);
8003f14: 29 63 00 28 lw r3,(r11+40)
8003f18: 34 04 00 08 mvi r4,8
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
8003f1c: 20 21 18 00 andi r1,r1,0x1800
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
8003f20: 20 62 00 07 andi r2,r3,0x7
8003f24: c8 82 10 00 sub r2,r4,r2
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
8003f28: 34 04 18 00 mvi r4,6144
8003f2c: b4 43 18 00 add r3,r2,r3
8003f30: 5c 24 00 05 bne r1,r4,8003f44 <oproc+0xdc> <== NEVER TAKEN
tty->column += i;
rtems_termios_puts ( " ", i, tty);
8003f34: 78 01 08 02 mvhi r1,0x802
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
8003f38: 59 63 00 28 sw (r11+40),r3
rtems_termios_puts ( " ", i, tty);
8003f3c: 38 21 38 f4 ori r1,r1,0x38f4
8003f40: e0 00 00 20 bi 8003fc0 <oproc+0x158>
return;
}
tty->column += i;
8003f44: 59 63 00 28 sw (r11+40),r3 <== NOT EXECUTED
break;
8003f48: e0 00 00 1c bi 8003fb8 <oproc+0x150> <== NOT EXECUTED
case '\b':
if (tty->column > 0)
8003f4c: 29 61 00 28 lw r1,(r11+40) <== NOT EXECUTED
8003f50: 4c 01 00 1a bge r0,r1,8003fb8 <oproc+0x150> <== NOT EXECUTED
tty->column--;
8003f54: 34 21 ff ff addi r1,r1,-1 <== NOT EXECUTED
8003f58: e0 00 00 17 bi 8003fb4 <oproc+0x14c> <== NOT EXECUTED
break;
default:
if (tty->termios.c_oflag & OLCUC)
8003f5c: 20 21 00 02 andi r1,r1,0x2
8003f60: 44 20 00 0b be r1,r0,8003f8c <oproc+0x124> <== ALWAYS TAKEN
c = toupper(c);
8003f64: 78 01 08 02 mvhi r1,0x802 <== NOT EXECUTED
8003f68: 38 21 52 58 ori r1,r1,0x5258 <== NOT EXECUTED
8003f6c: 28 21 00 00 lw r1,(r1+0) <== NOT EXECUTED
8003f70: b4 22 08 00 add r1,r1,r2 <== NOT EXECUTED
8003f74: 40 23 00 01 lbu r3,(r1+1) <== NOT EXECUTED
8003f78: 34 01 00 02 mvi r1,2 <== NOT EXECUTED
8003f7c: 20 63 00 03 andi r3,r3,0x3 <== NOT EXECUTED
8003f80: 5c 61 00 02 bne r3,r1,8003f88 <oproc+0x120> <== NOT EXECUTED
8003f84: 34 42 ff e0 addi r2,r2,-32 <== NOT EXECUTED
8003f88: 33 82 00 0c sb (sp+12),r2 <== NOT EXECUTED
if (!iscntrl(c))
8003f8c: 78 01 08 02 mvhi r1,0x802
8003f90: 38 21 52 58 ori r1,r1,0x5258
8003f94: 43 82 00 0c lbu r2,(sp+12)
8003f98: 28 21 00 00 lw r1,(r1+0)
8003f9c: b4 22 08 00 add r1,r1,r2
8003fa0: 40 21 00 01 lbu r1,(r1+1)
8003fa4: 20 21 00 20 andi r1,r1,0x20
8003fa8: 5c 20 00 04 bne r1,r0,8003fb8 <oproc+0x150> <== NEVER TAKEN
tty->column++;
8003fac: 29 61 00 28 lw r1,(r11+40)
8003fb0: 34 21 00 01 addi r1,r1,1
8003fb4: 59 61 00 28 sw (r11+40),r1
break;
}
}
rtems_termios_puts (&c, 1, tty);
8003fb8: 37 81 00 0c addi r1,sp,12
8003fbc: 34 02 00 01 mvi r2,1
8003fc0: b9 60 18 00 mv r3,r11
8003fc4: fb ff ff 53 calli 8003d10 <rtems_termios_puts>
}
8003fc8: 2b 9d 00 04 lw ra,(sp+4)
8003fcc: 2b 8b 00 08 lw r11,(sp+8)
8003fd0: 37 9c 00 0c addi sp,sp,12
8003fd4: c3 a0 00 00 ret
080093c0 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
80093c0: 37 9c ff d8 addi sp,sp,-40
80093c4: 5b 8b 00 18 sw (sp+24),r11
80093c8: 5b 8c 00 14 sw (sp+20),r12
80093cc: 5b 8d 00 10 sw (sp+16),r13
80093d0: 5b 8e 00 0c sw (sp+12),r14
80093d4: 5b 8f 00 08 sw (sp+8),r15
80093d8: 5b 9d 00 04 sw (sp+4),ra
80093dc: b8 20 70 00 mv r14,r1
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
80093e0: 78 01 08 01 mvhi r1,0x801
80093e4: 38 21 e9 a0 ori r1,r1,0xe9a0
80093e8: 34 02 01 ff mvi r2,511
80093ec: f8 00 06 42 calli 800acf4 <rtems_mkdir>
80093f0: b8 20 78 00 mv r15,r1
return -1;
80093f4: 34 0d ff ff mvi r13,-1
)
{
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
80093f8: 5c 20 00 43 bne r1,r0,8009504 <pipe_create+0x144> <== NEVER TAKEN
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
80093fc: 78 02 08 01 mvhi r2,0x801
8009400: 38 42 e9 a8 ori r2,r2,0xe9a8
8009404: 28 43 00 00 lw r3,(r2+0)
8009408: 28 41 00 04 lw r1,(r2+4)
800940c: 37 8b 00 1c addi r11,sp,28
8009410: 5b 83 00 1c sw (sp+28),r3
8009414: 59 61 00 04 sw (r11+4),r1
8009418: 2c 41 00 08 lhu r1,(r2+8)
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
800941c: 78 02 08 02 mvhi r2,0x802
8009420: 38 42 07 3c ori r2,r2,0x73c
8009424: 2c 43 00 00 lhu r3,(r2+0)
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
8009428: 0d 61 00 08 sh (r11+8),r1
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
800942c: 34 61 00 01 addi r1,r3,1
8009430: 0c 41 00 00 sh (r2+0),r1
8009434: 78 02 08 01 mvhi r2,0x801
8009438: 38 42 e9 b4 ori r2,r2,0xe9b4
800943c: 37 81 00 26 addi r1,sp,38
8009440: f8 00 17 7c calli 800f230 <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
8009444: b9 60 08 00 mv r1,r11
8009448: 34 02 01 80 mvi r2,384
800944c: f8 00 05 5f calli 800a9c8 <mkfifo>
8009450: b8 20 60 00 mv r12,r1
8009454: 44 2f 00 03 be r1,r15,8009460 <pipe_create+0xa0>
if (errno != EEXIST){
8009458: f8 00 14 00 calli 800e458 <__errno>
800945c: e0 00 00 2a bi 8009504 <pipe_create+0x144>
return -1;
/* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
8009460: b9 60 08 00 mv r1,r11
8009464: 34 02 40 00 mvi r2,16384
8009468: fb ff e9 1c calli 80038d8 <open>
800946c: 59 c1 00 00 sw (r14+0),r1
if (filsdes[0] < 0) {
8009470: 4c 2c 00 05 bge r1,r12,8009484 <pipe_create+0xc4>
err = errno;
8009474: f8 00 13 f9 calli 800e458 <__errno>
8009478: 28 2c 00 00 lw r12,(r1+0)
/* Delete file at errors, or else if pipe is successfully created
the file node will be deleted after it is closed by all. */
unlink(fifopath);
800947c: b9 60 08 00 mv r1,r11
8009480: e0 00 00 1b bi 80094ec <pipe_create+0x12c>
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
8009484: 78 02 08 02 mvhi r2,0x802
8009488: 38 42 00 10 ori r2,r2,0x10
800948c: 28 44 00 00 lw r4,(r2+0)
8009490: 34 02 00 00 mvi r2,0
8009494: 50 24 00 07 bgeu r1,r4,80094b0 <pipe_create+0xf0> <== NEVER TAKEN
8009498: 34 02 00 06 mvi r2,6
800949c: 78 0b 08 02 mvhi r11,0x802
80094a0: f8 00 4e fa calli 801d088 <__ashlsi3>
80094a4: 39 6b 07 b4 ori r11,r11,0x7b4
80094a8: 29 62 00 00 lw r2,(r11+0)
80094ac: b4 41 10 00 add r2,r2,r1
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
80094b0: 28 43 00 18 lw r3,(r2+24)
80094b4: 34 01 ff fe mvi r1,-2
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
80094b8: 34 0c 00 00 mvi r12,0
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
80094bc: a0 61 08 00 and r1,r3,r1
80094c0: 58 41 00 18 sw (r2+24),r1
filsdes[1] = open(fifopath, O_WRONLY);
80094c4: 37 81 00 1c addi r1,sp,28
80094c8: 34 02 00 01 mvi r2,1
80094cc: fb ff e9 03 calli 80038d8 <open>
80094d0: 59 c1 00 04 sw (r14+4),r1
if (filsdes[1] < 0) {
80094d4: 4c 20 00 05 bge r1,r0,80094e8 <pipe_create+0x128>
err = errno;
80094d8: f8 00 13 e0 calli 800e458 <__errno>
80094dc: 28 2c 00 00 lw r12,(r1+0)
close(filsdes[0]);
80094e0: 29 c1 00 00 lw r1,(r14+0)
80094e4: fb ff e4 43 calli 80025f0 <close>
}
unlink(fifopath);
80094e8: 37 81 00 1c addi r1,sp,28
80094ec: fb ff ea 0d calli 8003d20 <unlink>
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
80094f0: 34 0d 00 00 mvi r13,0
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
80094f4: 45 80 00 04 be r12,r0,8009504 <pipe_create+0x144>
rtems_set_errno_and_return_minus_one(err);
80094f8: f8 00 13 d8 calli 800e458 <__errno>
80094fc: 58 2c 00 00 sw (r1+0),r12
8009500: 34 0d ff ff mvi r13,-1
return 0;
}
8009504: b9 a0 08 00 mv r1,r13
8009508: 2b 9d 00 04 lw ra,(sp+4)
800950c: 2b 8b 00 18 lw r11,(sp+24)
8009510: 2b 8c 00 14 lw r12,(sp+20)
8009514: 2b 8d 00 10 lw r13,(sp+16)
8009518: 2b 8e 00 0c lw r14,(sp+12)
800951c: 2b 8f 00 08 lw r15,(sp+8)
8009520: 37 9c 00 28 addi sp,sp,40
8009524: c3 a0 00 00 ret
0800abf0 <pipe_ioctl>:
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
800abf0: 37 9c ff f4 addi sp,sp,-12
800abf4: 5b 8b 00 0c sw (sp+12),r11
800abf8: 5b 8c 00 08 sw (sp+8),r12
800abfc: 5b 9d 00 04 sw (sp+4),ra
800ac00: b8 60 60 00 mv r12,r3
if (cmd == FIONREAD) {
800ac04: 78 03 08 02 mvhi r3,0x802
800ac08: 38 63 21 28 ori r3,r3,0x2128
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
800ac0c: b8 20 58 00 mv r11,r1
if (cmd == FIONREAD) {
800ac10: 28 61 00 00 lw r1,(r3+0)
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
800ac14: 34 04 ff ea mvi r4,-22
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
800ac18: 5c 41 00 0e bne r2,r1,800ac50 <pipe_ioctl+0x60>
if (buffer == NULL)
return -EFAULT;
800ac1c: 34 04 ff f2 mvi r4,-14
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
800ac20: 45 80 00 0c be r12,r0,800ac50 <pipe_ioctl+0x60>
return -EFAULT;
if (! PIPE_LOCK(pipe))
800ac24: 29 61 00 28 lw r1,(r11+40)
800ac28: 34 02 00 00 mvi r2,0
800ac2c: 34 03 00 00 mvi r3,0
800ac30: fb ff e9 42 calli 8005138 <rtems_semaphore_obtain>
return -EINTR;
800ac34: 34 04 ff fc mvi r4,-4
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
if (! PIPE_LOCK(pipe))
800ac38: 5c 20 00 06 bne r1,r0,800ac50 <pipe_ioctl+0x60> <== NEVER TAKEN
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
800ac3c: 29 61 00 0c lw r1,(r11+12)
800ac40: 59 81 00 00 sw (r12+0),r1
PIPE_UNLOCK(pipe);
800ac44: 29 61 00 28 lw r1,(r11+40)
800ac48: fb ff e9 8c calli 8005278 <rtems_semaphore_release>
return 0;
800ac4c: 34 04 00 00 mvi r4,0
}
return -EINVAL;
}
800ac50: b8 80 08 00 mv r1,r4
800ac54: 2b 9d 00 04 lw ra,(sp+4)
800ac58: 2b 8b 00 0c lw r11,(sp+12)
800ac5c: 2b 8c 00 08 lw r12,(sp+8)
800ac60: 37 9c 00 0c addi sp,sp,12
800ac64: c3 a0 00 00 ret
0800a84c <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
800a84c: 37 9c ff d8 addi sp,sp,-40
800a850: 5b 8b 00 24 sw (sp+36),r11
800a854: 5b 8c 00 20 sw (sp+32),r12
800a858: 5b 8d 00 1c sw (sp+28),r13
800a85c: 5b 8e 00 18 sw (sp+24),r14
800a860: 5b 8f 00 14 sw (sp+20),r15
800a864: 5b 90 00 10 sw (sp+16),r16
800a868: 5b 91 00 0c sw (sp+12),r17
800a86c: 5b 92 00 08 sw (sp+8),r18
800a870: 5b 9d 00 04 sw (sp+4),ra
800a874: b8 20 58 00 mv r11,r1
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
800a878: 28 21 00 28 lw r1,(r1+40)
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
800a87c: b8 40 78 00 mv r15,r2
800a880: b8 60 80 00 mv r16,r3
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
800a884: 34 02 00 00 mvi r2,0
800a888: 34 03 00 00 mvi r3,0
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
800a88c: b8 80 88 00 mv r17,r4
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
800a890: fb ff ea 2a calli 8005138 <rtems_semaphore_obtain>
return -EINTR;
800a894: 34 0d ff fc mvi r13,-4
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
800a898: 34 0c 00 00 mvi r12,0
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
800a89c: 34 12 ff fc mvi r18,-4
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
800a8a0: 44 20 00 40 be r1,r0,800a9a0 <pipe_read+0x154> <== ALWAYS TAKEN
800a8a4: e0 00 00 49 bi 800a9c8 <pipe_read+0x17c> <== NOT EXECUTED
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
800a8a8: 29 61 00 14 lw r1,(r11+20)
800a8ac: 44 2d 00 3e be r1,r13,800a9a4 <pipe_read+0x158>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
800a8b0: 2a 2d 00 18 lw r13,(r17+24)
800a8b4: 21 ad 00 01 andi r13,r13,0x1
800a8b8: 5d a0 00 3d bne r13,r0,800a9ac <pipe_read+0x160>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
800a8bc: 29 61 00 18 lw r1,(r11+24)
800a8c0: 34 21 00 01 addi r1,r1,1
800a8c4: 59 61 00 18 sw (r11+24),r1
PIPE_UNLOCK(pipe);
800a8c8: 29 61 00 28 lw r1,(r11+40)
800a8cc: fb ff ea 6b calli 8005278 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
800a8d0: 29 61 00 2c lw r1,(r11+44)
800a8d4: 34 02 00 00 mvi r2,0
800a8d8: f8 00 06 ca calli 800c400 <rtems_barrier_wait>
800a8dc: fc 2d 68 00 cmpne r13,r1,r13
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
800a8e0: 29 61 00 28 lw r1,(r11+40)
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
800a8e4: c8 0d 68 00 sub r13,r0,r13
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
800a8e8: 34 02 00 00 mvi r2,0
800a8ec: 34 03 00 00 mvi r3,0
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
800a8f0: a1 b2 68 00 and r13,r13,r18
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
800a8f4: fb ff ea 11 calli 8005138 <rtems_semaphore_obtain>
800a8f8: 5c 20 00 31 bne r1,r0,800a9bc <pipe_read+0x170> <== NEVER TAKEN
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
800a8fc: 29 62 00 18 lw r2,(r11+24)
800a900: 34 42 ff ff addi r2,r2,-1
800a904: 59 62 00 18 sw (r11+24),r2
if (ret != 0)
800a908: 5d a1 00 2a bne r13,r1,800a9b0 <pipe_read+0x164> <== NEVER TAKEN
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
800a90c: 29 6d 00 0c lw r13,(r11+12)
800a910: 45 a0 ff e6 be r13,r0,800a8a8 <pipe_read+0x5c>
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
800a914: ca 0c 08 00 sub r1,r16,r12
800a918: 50 2d 00 02 bgeu r1,r13,800a920 <pipe_read+0xd4>
800a91c: b8 20 68 00 mv r13,r1
chunk1 = pipe->Size - pipe->Start;
800a920: 29 65 00 08 lw r5,(r11+8)
800a924: 29 6e 00 04 lw r14,(r11+4)
800a928: 29 66 00 00 lw r6,(r11+0)
800a92c: b5 ec 08 00 add r1,r15,r12
800a930: c9 c5 70 00 sub r14,r14,r5
if (chunk > chunk1) {
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);
800a934: b4 c5 10 00 add r2,r6,r5
800a938: b9 a0 18 00 mv r3,r13
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
800a93c: 4d cd 00 08 bge r14,r13,800a95c <pipe_read+0x110>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
800a940: b4 c5 10 00 add r2,r6,r5
800a944: b9 c0 18 00 mv r3,r14
800a948: f8 00 15 aa calli 800fff0 <memcpy>
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
800a94c: 29 62 00 00 lw r2,(r11+0)
800a950: b5 8e 08 00 add r1,r12,r14
800a954: b5 e1 08 00 add r1,r15,r1
800a958: c9 ae 18 00 sub r3,r13,r14
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
800a95c: f8 00 15 a5 calli 800fff0 <memcpy>
pipe->Start += chunk;
800a960: 29 61 00 08 lw r1,(r11+8)
pipe->Start %= pipe->Size;
800a964: 29 62 00 04 lw r2,(r11+4)
800a968: b5 a1 08 00 add r1,r13,r1
800a96c: f8 00 57 82 calli 8020774 <__umodsi3>
800a970: 59 61 00 08 sw (r11+8),r1
pipe->Length -= chunk;
800a974: 29 61 00 0c lw r1,(r11+12)
800a978: c8 2d 08 00 sub r1,r1,r13
800a97c: 59 61 00 0c sw (r11+12),r1
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
800a980: 5c 20 00 02 bne r1,r0,800a988 <pipe_read+0x13c>
pipe->Start = 0;
800a984: 59 60 00 08 sw (r11+8),r0
if (pipe->waitingWriters > 0)
800a988: 29 61 00 1c lw r1,(r11+28)
800a98c: 44 20 00 04 be r1,r0,800a99c <pipe_read+0x150>
PIPE_WAKEUPWRITERS(pipe);
800a990: 29 61 00 30 lw r1,(r11+48)
800a994: 37 82 00 28 addi r2,sp,40
800a998: f8 00 06 7d calli 800c38c <rtems_barrier_release>
read += chunk;
800a99c: b5 8d 60 00 add r12,r12,r13
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
800a9a0: 56 0c ff db bgu r16,r12,800a90c <pipe_read+0xc0>
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
800a9a4: 34 0d 00 00 mvi r13,0
800a9a8: e0 00 00 02 bi 800a9b0 <pipe_read+0x164>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
800a9ac: 34 0d ff f5 mvi r13,-11
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
800a9b0: 29 61 00 28 lw r1,(r11+40)
800a9b4: fb ff ea 31 calli 8005278 <rtems_semaphore_release>
800a9b8: e0 00 00 02 bi 800a9c0 <pipe_read+0x174>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
800a9bc: 34 0d ff fc mvi r13,-4 <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
800a9c0: 4c 0c 00 02 bge r0,r12,800a9c8 <pipe_read+0x17c>
800a9c4: b9 80 68 00 mv r13,r12
return read;
return ret;
}
800a9c8: b9 a0 08 00 mv r1,r13
800a9cc: 2b 9d 00 04 lw ra,(sp+4)
800a9d0: 2b 8b 00 24 lw r11,(sp+36)
800a9d4: 2b 8c 00 20 lw r12,(sp+32)
800a9d8: 2b 8d 00 1c lw r13,(sp+28)
800a9dc: 2b 8e 00 18 lw r14,(sp+24)
800a9e0: 2b 8f 00 14 lw r15,(sp+20)
800a9e4: 2b 90 00 10 lw r16,(sp+16)
800a9e8: 2b 91 00 0c lw r17,(sp+12)
800a9ec: 2b 92 00 08 lw r18,(sp+8)
800a9f0: 37 9c 00 28 addi sp,sp,40
800a9f4: c3 a0 00 00 ret
0800a364 <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
800a364: 37 9c ff ec addi sp,sp,-20
800a368: 5b 8b 00 10 sw (sp+16),r11
800a36c: 5b 8c 00 0c sw (sp+12),r12
800a370: 5b 8d 00 08 sw (sp+8),r13
800a374: 5b 9d 00 04 sw (sp+4),ra
800a378: b8 20 68 00 mv r13,r1
pipe_control_t *pipe = *pipep;
800a37c: 28 2b 00 00 lw r11,(r1+0)
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
800a380: 28 41 00 18 lw r1,(r2+24)
800a384: 20 2c 00 06 andi r12,r1,0x6
if (mode & LIBIO_FLAGS_READ)
800a388: 20 21 00 02 andi r1,r1,0x2
800a38c: 44 20 00 04 be r1,r0,800a39c <pipe_release+0x38>
pipe->Readers --;
800a390: 29 61 00 10 lw r1,(r11+16)
800a394: 34 21 ff ff addi r1,r1,-1
800a398: 59 61 00 10 sw (r11+16),r1
if (mode & LIBIO_FLAGS_WRITE)
800a39c: 21 81 00 04 andi r1,r12,0x4
800a3a0: 44 20 00 04 be r1,r0,800a3b0 <pipe_release+0x4c>
pipe->Writers --;
800a3a4: 29 61 00 14 lw r1,(r11+20)
800a3a8: 34 21 ff ff addi r1,r1,-1
800a3ac: 59 61 00 14 sw (r11+20),r1
PIPE_UNLOCK(pipe);
800a3b0: 29 61 00 28 lw r1,(r11+40)
800a3b4: fb ff eb b1 calli 8005278 <rtems_semaphore_release>
if (pipe->Readers == 0 && pipe->Writers == 0) {
800a3b8: 29 62 00 10 lw r2,(r11+16)
800a3bc: 5c 40 00 07 bne r2,r0,800a3d8 <pipe_release+0x74>
800a3c0: 29 61 00 14 lw r1,(r11+20)
800a3c4: 5c 22 00 05 bne r1,r2,800a3d8 <pipe_release+0x74>
#if 0
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
800a3c8: b9 60 08 00 mv r1,r11
800a3cc: fb ff ff d4 calli 800a31c <pipe_free>
*pipep = NULL;
800a3d0: 59 a0 00 00 sw (r13+0),r0
800a3d4: e0 00 00 0f bi 800a410 <pipe_release+0xac>
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
800a3d8: 7d 81 00 04 cmpnei r1,r12,4
800a3dc: 64 42 00 00 cmpei r2,r2,0
800a3e0: a0 22 10 00 and r2,r1,r2
800a3e4: 44 40 00 03 be r2,r0,800a3f0 <pipe_release+0x8c>
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
800a3e8: 29 61 00 30 lw r1,(r11+48)
800a3ec: e0 00 00 07 bi 800a408 <pipe_release+0xa4>
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
800a3f0: 29 61 00 14 lw r1,(r11+20)
800a3f4: 7d 8c 00 02 cmpnei r12,r12,2
800a3f8: 64 21 00 00 cmpei r1,r1,0
800a3fc: a1 81 60 00 and r12,r12,r1
800a400: 45 82 00 04 be r12,r2,800a410 <pipe_release+0xac> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
800a404: 29 61 00 2c lw r1,(r11+44)
800a408: 37 82 00 14 addi r2,sp,20
800a40c: f8 00 07 e0 calli 800c38c <rtems_barrier_release>
pipe_unlock();
800a410: fb ff ff ba calli 800a2f8 <pipe_unlock>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
800a414: 2b 9d 00 04 lw ra,(sp+4)
800a418: 2b 8b 00 10 lw r11,(sp+16)
800a41c: 2b 8c 00 0c lw r12,(sp+12)
800a420: 2b 8d 00 08 lw r13,(sp+8)
800a424: 37 9c 00 14 addi sp,sp,20
800a428: c3 a0 00 00 ret
0800a9f8 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
800a9f8: 37 9c ff d4 addi sp,sp,-44
800a9fc: 5b 8b 00 28 sw (sp+40),r11
800aa00: 5b 8c 00 24 sw (sp+36),r12
800aa04: 5b 8d 00 20 sw (sp+32),r13
800aa08: 5b 8e 00 1c sw (sp+28),r14
800aa0c: 5b 8f 00 18 sw (sp+24),r15
800aa10: 5b 90 00 14 sw (sp+20),r16
800aa14: 5b 91 00 10 sw (sp+16),r17
800aa18: 5b 92 00 0c sw (sp+12),r18
800aa1c: 5b 93 00 08 sw (sp+8),r19
800aa20: 5b 9d 00 04 sw (sp+4),ra
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
800aa24: 34 0d 00 00 mvi r13,0
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
800aa28: b8 20 58 00 mv r11,r1
800aa2c: b8 40 88 00 mv r17,r2
800aa30: b8 60 70 00 mv r14,r3
800aa34: b8 80 90 00 mv r18,r4
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
800aa38: 44 60 00 61 be r3,r0,800abbc <pipe_write+0x1c4> <== NEVER TAKEN
return 0;
if (! PIPE_LOCK(pipe))
800aa3c: 28 21 00 28 lw r1,(r1+40)
800aa40: 34 02 00 00 mvi r2,0
800aa44: 34 03 00 00 mvi r3,0
800aa48: fb ff e9 bc calli 8005138 <rtems_semaphore_obtain>
return -EINTR;
800aa4c: 34 0d ff fc mvi r13,-4
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
800aa50: 5c 20 00 5b bne r1,r0,800abbc <pipe_write+0x1c4> <== NEVER TAKEN
return -EINTR;
if (pipe->Readers == 0) {
800aa54: 29 62 00 10 lw r2,(r11+16)
800aa58: 44 41 00 48 be r2,r1,800ab78 <pipe_write+0x180>
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
800aa5c: 29 61 00 04 lw r1,(r11+4)
800aa60: 34 10 00 01 mvi r16,1
800aa64: 55 c1 00 02 bgu r14,r1,800aa6c <pipe_write+0x74> <== NEVER TAKEN
800aa68: b9 c0 80 00 mv r16,r14
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
800aa6c: 34 0c 00 00 mvi r12,0
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
800aa70: 34 13 ff fc mvi r19,-4
800aa74: e0 00 00 3e bi 800ab6c <pipe_write+0x174>
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
800aa78: 2a 4d 00 18 lw r13,(r18+24)
800aa7c: 21 ad 00 01 andi r13,r13,0x1
800aa80: 5d a0 00 41 bne r13,r0,800ab84 <pipe_write+0x18c>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
800aa84: 29 61 00 1c lw r1,(r11+28)
800aa88: 34 21 00 01 addi r1,r1,1
800aa8c: 59 61 00 1c sw (r11+28),r1
PIPE_UNLOCK(pipe);
800aa90: 29 61 00 28 lw r1,(r11+40)
800aa94: fb ff e9 f9 calli 8005278 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
800aa98: 29 61 00 30 lw r1,(r11+48)
800aa9c: 34 02 00 00 mvi r2,0
800aaa0: f8 00 06 58 calli 800c400 <rtems_barrier_wait>
800aaa4: fc 2d 68 00 cmpne r13,r1,r13
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
800aaa8: 29 61 00 28 lw r1,(r11+40)
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
800aaac: c8 0d 68 00 sub r13,r0,r13
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
800aab0: 34 02 00 00 mvi r2,0
800aab4: 34 03 00 00 mvi r3,0
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
800aab8: a1 b3 68 00 and r13,r13,r19
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
800aabc: fb ff e9 9f calli 8005138 <rtems_semaphore_obtain>
800aac0: 5c 20 00 3c bne r1,r0,800abb0 <pipe_write+0x1b8> <== NEVER TAKEN
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
800aac4: 29 62 00 1c lw r2,(r11+28)
800aac8: 34 42 ff ff addi r2,r2,-1
800aacc: 59 62 00 1c sw (r11+28),r2
if (ret != 0)
800aad0: 5d a1 00 30 bne r13,r1,800ab90 <pipe_write+0x198> <== NEVER TAKEN
goto out_locked;
if (pipe->Readers == 0) {
800aad4: 29 61 00 10 lw r1,(r11+16)
800aad8: 44 2d 00 2d be r1,r13,800ab8c <pipe_write+0x194> <== NEVER TAKEN
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
800aadc: 29 6f 00 04 lw r15,(r11+4)
800aae0: 29 61 00 0c lw r1,(r11+12)
800aae4: c9 e1 68 00 sub r13,r15,r1
800aae8: 56 0d ff e4 bgu r16,r13,800aa78 <pipe_write+0x80>
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
800aaec: c9 cc 10 00 sub r2,r14,r12
800aaf0: 50 4d 00 02 bgeu r2,r13,800aaf8 <pipe_write+0x100>
800aaf4: b8 40 68 00 mv r13,r2
chunk1 = pipe->Size - PIPE_WSTART(pipe);
800aaf8: 29 62 00 08 lw r2,(r11+8)
800aafc: b4 22 08 00 add r1,r1,r2
800ab00: b9 e0 10 00 mv r2,r15
800ab04: f8 00 57 1c calli 8020774 <__umodsi3>
800ab08: c9 e1 78 00 sub r15,r15,r1
800ab0c: 29 63 00 00 lw r3,(r11+0)
800ab10: b6 2c 10 00 add r2,r17,r12
if (chunk > chunk1) {
800ab14: 4d ed 00 09 bge r15,r13,800ab38 <pipe_write+0x140>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
800ab18: b4 61 08 00 add r1,r3,r1
800ab1c: b9 e0 18 00 mv r3,r15
800ab20: f8 00 15 34 calli 800fff0 <memcpy>
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
800ab24: b5 ec 10 00 add r2,r15,r12
800ab28: 29 61 00 00 lw r1,(r11+0)
800ab2c: b6 22 10 00 add r2,r17,r2
800ab30: c9 af 18 00 sub r3,r13,r15
800ab34: e0 00 00 03 bi 800ab40 <pipe_write+0x148>
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
800ab38: b4 61 08 00 add r1,r3,r1
800ab3c: b9 a0 18 00 mv r3,r13
800ab40: f8 00 15 2c calli 800fff0 <memcpy>
pipe->Length += chunk;
800ab44: 29 61 00 0c lw r1,(r11+12)
800ab48: b4 2d 08 00 add r1,r1,r13
800ab4c: 59 61 00 0c sw (r11+12),r1
if (pipe->waitingReaders > 0)
800ab50: 29 61 00 18 lw r1,(r11+24)
800ab54: 44 20 00 04 be r1,r0,800ab64 <pipe_write+0x16c>
PIPE_WAKEUPREADERS(pipe);
800ab58: 29 61 00 2c lw r1,(r11+44)
800ab5c: 37 82 00 2c addi r2,sp,44
800ab60: f8 00 06 0b calli 800c38c <rtems_barrier_release>
written += chunk;
800ab64: b5 8d 60 00 add r12,r12,r13
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
800ab68: 34 10 00 01 mvi r16,1
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
800ab6c: 55 cc ff dc bgu r14,r12,800aadc <pipe_write+0xe4>
800ab70: 34 0d 00 00 mvi r13,0
800ab74: e0 00 00 07 bi 800ab90 <pipe_write+0x198>
if (! PIPE_LOCK(pipe))
return -EINTR;
if (pipe->Readers == 0) {
ret = -EPIPE;
800ab78: 34 0d ff e0 mvi r13,-32
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
int chunk, chunk1, written = 0, ret = 0;
800ab7c: 34 0c 00 00 mvi r12,0
800ab80: e0 00 00 04 bi 800ab90 <pipe_write+0x198>
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
800ab84: 34 0d ff f5 mvi r13,-11
800ab88: e0 00 00 02 bi 800ab90 <pipe_write+0x198>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
800ab8c: 34 0d ff e0 mvi r13,-32 <== NOT EXECUTED
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
800ab90: 29 61 00 28 lw r1,(r11+40)
800ab94: fb ff e9 b9 calli 8005278 <rtems_semaphore_release>
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
800ab98: 34 01 ff e0 mvi r1,-32
800ab9c: 5d a1 00 06 bne r13,r1,800abb4 <pipe_write+0x1bc>
kill(getpid(), SIGPIPE);
800aba0: f8 00 02 52 calli 800b4e8 <getpid>
800aba4: 34 02 00 0d mvi r2,13
800aba8: f8 00 03 36 calli 800b880 <kill>
800abac: e0 00 00 02 bi 800abb4 <pipe_write+0x1bc>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
800abb0: 34 0d ff fc mvi r13,-4 <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
800abb4: 4c 0c 00 02 bge r0,r12,800abbc <pipe_write+0x1c4>
800abb8: b9 80 68 00 mv r13,r12
return written;
return ret;
}
800abbc: b9 a0 08 00 mv r1,r13
800abc0: 2b 9d 00 04 lw ra,(sp+4)
800abc4: 2b 8b 00 28 lw r11,(sp+40)
800abc8: 2b 8c 00 24 lw r12,(sp+36)
800abcc: 2b 8d 00 20 lw r13,(sp+32)
800abd0: 2b 8e 00 1c lw r14,(sp+28)
800abd4: 2b 8f 00 18 lw r15,(sp+24)
800abd8: 2b 90 00 14 lw r16,(sp+20)
800abdc: 2b 91 00 10 lw r17,(sp+16)
800abe0: 2b 92 00 0c lw r18,(sp+12)
800abe4: 2b 93 00 08 lw r19,(sp+8)
800abe8: 37 9c 00 2c addi sp,sp,44
800abec: c3 a0 00 00 ret
0800845c <pthread_attr_setschedpolicy>:
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
800845c: 34 03 00 16 mvi r3,22
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
8008460: 44 20 00 0c be r1,r0,8008490 <pthread_attr_setschedpolicy+0x34>
8008464: 28 24 00 00 lw r4,(r1+0)
8008468: 44 80 00 0a be r4,r0,8008490 <pthread_attr_setschedpolicy+0x34>
return EINVAL;
switch ( policy ) {
800846c: 48 02 00 08 bg r0,r2,800848c <pthread_attr_setschedpolicy+0x30>
8008470: 34 03 00 02 mvi r3,2
8008474: 4c 62 00 03 bge r3,r2,8008480 <pthread_attr_setschedpolicy+0x24>
8008478: 34 03 00 04 mvi r3,4
800847c: 5c 43 00 04 bne r2,r3,800848c <pthread_attr_setschedpolicy+0x30><== NEVER TAKEN
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
8008480: 58 22 00 14 sw (r1+20),r2
return 0;
8008484: 34 03 00 00 mvi r3,0
8008488: e0 00 00 02 bi 8008490 <pthread_attr_setschedpolicy+0x34>
default:
return ENOTSUP;
800848c: 34 03 00 86 mvi r3,134
}
}
8008490: b8 60 08 00 mv r1,r3
8008494: c3 a0 00 00 ret
0800343c <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
800343c: 37 9c ff dc addi sp,sp,-36
8003440: 5b 8b 00 14 sw (sp+20),r11
8003444: 5b 8c 00 10 sw (sp+16),r12
8003448: 5b 8d 00 0c sw (sp+12),r13
800344c: 5b 8e 00 08 sw (sp+8),r14
8003450: 5b 9d 00 04 sw (sp+4),ra
/*
* Error check parameters
*/
if ( !barrier )
return EINVAL;
8003454: 34 04 00 16 mvi r4,22
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
8003458: b8 20 68 00 mv r13,r1
800345c: b8 60 58 00 mv r11,r3
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
8003460: 44 20 00 2a be r1,r0,8003508 <pthread_barrier_init+0xcc>
return EINVAL;
if ( count == 0 )
8003464: 44 60 00 29 be r3,r0,8003508 <pthread_barrier_init+0xcc>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
8003468: 5c 40 00 05 bne r2,r0,800347c <pthread_barrier_init+0x40>
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
800346c: 37 8c 00 18 addi r12,sp,24
8003470: b9 80 08 00 mv r1,r12
8003474: fb ff ff bb calli 8003360 <pthread_barrierattr_init>
the_attr = &my_attr;
8003478: b9 80 10 00 mv r2,r12
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
800347c: 28 41 00 00 lw r1,(r2+0)
return EINVAL;
8003480: 34 04 00 16 mvi r4,22
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
8003484: 44 20 00 21 be r1,r0,8003508 <pthread_barrier_init+0xcc>
return EINVAL;
switch ( the_attr->process_shared ) {
8003488: 28 4e 00 04 lw r14,(r2+4)
800348c: 5d c0 00 1f bne r14,r0,8003508 <pthread_barrier_init+0xcc> <== NEVER TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
8003490: 78 02 08 01 mvhi r2,0x801
8003494: 38 42 68 d8 ori r2,r2,0x68d8
8003498: 28 41 00 00 lw r1,(r2+0)
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
800349c: 5b 80 00 20 sw (sp+32),r0
the_attributes.maximum_count = count;
80034a0: 5b 8b 00 24 sw (sp+36),r11
80034a4: 34 21 00 01 addi r1,r1,1
80034a8: 58 41 00 00 sw (r2+0),r1
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void )
{
return (POSIX_Barrier_Control *)
_Objects_Allocate( &_POSIX_Barrier_Information );
80034ac: 78 0c 08 01 mvhi r12,0x801
80034b0: 39 8c 6c 0c ori r12,r12,0x6c0c
80034b4: b9 80 08 00 mv r1,r12
80034b8: f8 00 07 de calli 8005430 <_Objects_Allocate>
80034bc: b8 20 58 00 mv r11,r1
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
80034c0: 5c 2e 00 04 bne r1,r14,80034d0 <pthread_barrier_init+0x94>
_Thread_Enable_dispatch();
80034c4: f8 00 0c d4 calli 8006814 <_Thread_Enable_dispatch>
return EAGAIN;
80034c8: 34 04 00 0b mvi r4,11
80034cc: e0 00 00 0f bi 8003508 <pthread_barrier_init+0xcc>
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
80034d0: 34 21 00 10 addi r1,r1,16
80034d4: 37 82 00 20 addi r2,sp,32
80034d8: f8 00 04 e3 calli 8004864 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
80034dc: 29 6e 00 08 lw r14,(r11+8)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
80034e0: 29 8c 00 1c lw r12,(r12+28)
80034e4: 34 02 00 02 mvi r2,2
80034e8: 21 c1 ff ff andi r1,r14,0xffff
80034ec: f8 00 3d e4 calli 8012c7c <__ashlsi3>
80034f0: b5 81 08 00 add r1,r12,r1
80034f4: 58 2b 00 00 sw (r1+0),r11
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
80034f8: 59 60 00 0c sw (r11+12),r0
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
80034fc: 59 ae 00 00 sw (r13+0),r14
_Thread_Enable_dispatch();
8003500: f8 00 0c c5 calli 8006814 <_Thread_Enable_dispatch>
return 0;
8003504: 34 04 00 00 mvi r4,0
}
8003508: b8 80 08 00 mv r1,r4
800350c: 2b 9d 00 04 lw ra,(sp+4)
8003510: 2b 8b 00 14 lw r11,(sp+20)
8003514: 2b 8c 00 10 lw r12,(sp+16)
8003518: 2b 8d 00 0c lw r13,(sp+12)
800351c: 2b 8e 00 08 lw r14,(sp+8)
8003520: 37 9c 00 24 addi sp,sp,36
8003524: c3 a0 00 00 ret
08002cb0 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
8002cb0: 37 9c ff f4 addi sp,sp,-12
8002cb4: 5b 8b 00 0c sw (sp+12),r11
8002cb8: 5b 8c 00 08 sw (sp+8),r12
8002cbc: 5b 9d 00 04 sw (sp+4),ra
8002cc0: b8 20 58 00 mv r11,r1
8002cc4: b8 40 60 00 mv r12,r2
/*
* The POSIX standard does not address what to do when the routine
* is NULL. It also does not address what happens when we cannot
* allocate memory or anything else bad happens.
*/
if ( !routine )
8002cc8: 44 20 00 13 be r1,r0,8002d14 <pthread_cleanup_push+0x64>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
8002ccc: 78 03 08 01 mvhi r3,0x801
8002cd0: 38 63 68 c0 ori r3,r3,0x68c0
8002cd4: 28 61 00 00 lw r1,(r3+0)
8002cd8: 34 21 00 01 addi r1,r1,1
8002cdc: 58 61 00 00 sw (r3+0),r1
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
8002ce0: 34 01 00 10 mvi r1,16
8002ce4: f8 00 12 18 calli 8007544 <_Workspace_Allocate>
8002ce8: b8 20 10 00 mv r2,r1
if ( handler ) {
8002cec: 44 20 00 09 be r1,r0,8002d10 <pthread_cleanup_push+0x60> <== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
8002cf0: 78 03 08 01 mvhi r3,0x801
8002cf4: 38 63 6d 6c ori r3,r3,0x6d6c
8002cf8: 28 61 00 0c lw r1,(r3+12)
handler_stack = &thread_support->Cancellation_Handlers;
8002cfc: 28 21 01 20 lw r1,(r1+288)
handler->routine = routine;
8002d00: 58 4b 00 08 sw (r2+8),r11
handler->arg = arg;
8002d04: 58 4c 00 0c sw (r2+12),r12
_Chain_Append( handler_stack, &handler->Node );
8002d08: 34 21 00 e4 addi r1,r1,228
8002d0c: f8 00 04 ef calli 80040c8 <_Chain_Append>
}
_Thread_Enable_dispatch();
8002d10: f8 00 0c ab calli 8005fbc <_Thread_Enable_dispatch>
}
8002d14: 2b 9d 00 04 lw ra,(sp+4)
8002d18: 2b 8b 00 0c lw r11,(sp+12)
8002d1c: 2b 8c 00 08 lw r12,(sp+8)
8002d20: 37 9c 00 0c addi sp,sp,12
8002d24: c3 a0 00 00 ret
08003d80 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
8003d80: 37 9c ff ec addi sp,sp,-20
8003d84: 5b 8b 00 14 sw (sp+20),r11
8003d88: 5b 8c 00 10 sw (sp+16),r12
8003d8c: 5b 8d 00 0c sw (sp+12),r13
8003d90: 5b 8e 00 08 sw (sp+8),r14
8003d94: 5b 9d 00 04 sw (sp+4),ra
8003d98: b8 20 70 00 mv r14,r1
8003d9c: b8 40 58 00 mv r11,r2
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
8003da0: 5c 40 00 03 bne r2,r0,8003dac <pthread_cond_init+0x2c>
else the_attr = &_POSIX_Condition_variables_Default_attributes;
8003da4: 78 0b 08 01 mvhi r11,0x801
8003da8: 39 6b 5a a0 ori r11,r11,0x5aa0
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
8003dac: 29 63 00 04 lw r3,(r11+4)
8003db0: 34 02 00 01 mvi r2,1
return EINVAL;
8003db4: 34 01 00 16 mvi r1,22
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
8003db8: 44 62 00 26 be r3,r2,8003e50 <pthread_cond_init+0xd0> <== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
8003dbc: 29 62 00 00 lw r2,(r11+0)
8003dc0: 44 40 00 24 be r2,r0,8003e50 <pthread_cond_init+0xd0>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
8003dc4: 78 02 08 01 mvhi r2,0x801
8003dc8: 38 42 78 d8 ori r2,r2,0x78d8
8003dcc: 28 41 00 00 lw r1,(r2+0)
8003dd0: 34 21 00 01 addi r1,r1,1
8003dd4: 58 41 00 00 sw (r2+0),r1
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
_Objects_Allocate( &_POSIX_Condition_variables_Information );
8003dd8: 78 0d 08 01 mvhi r13,0x801
8003ddc: 39 ad 7c a4 ori r13,r13,0x7ca4
8003de0: b9 a0 08 00 mv r1,r13
8003de4: f8 00 09 7f calli 80063e0 <_Objects_Allocate>
8003de8: b8 20 60 00 mv r12,r1
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
8003dec: 5c 20 00 04 bne r1,r0,8003dfc <pthread_cond_init+0x7c>
_Thread_Enable_dispatch();
8003df0: f8 00 0e e5 calli 8007984 <_Thread_Enable_dispatch>
return ENOMEM;
8003df4: 34 01 00 0c mvi r1,12
8003df8: e0 00 00 16 bi 8003e50 <pthread_cond_init+0xd0>
the_cond->process_shared = the_attr->process_shared;
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
8003dfc: 78 04 08 01 mvhi r4,0x801
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
8003e00: 29 61 00 04 lw r1,(r11+4)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
8003e04: 38 84 5a a8 ori r4,r4,0x5aa8
8003e08: 28 83 00 00 lw r3,(r4+0)
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
8003e0c: 59 81 00 10 sw (r12+16),r1
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
8003e10: 34 04 00 74 mvi r4,116
8003e14: 35 81 00 18 addi r1,r12,24
8003e18: 34 02 00 00 mvi r2,0
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
8003e1c: 59 80 00 14 sw (r12+20),r0
_Thread_queue_Initialize(
8003e20: f8 00 11 1e calli 8008298 <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
8003e24: 29 8b 00 08 lw r11,(r12+8)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8003e28: 29 ad 00 1c lw r13,(r13+28)
8003e2c: 34 02 00 02 mvi r2,2
8003e30: 21 61 ff ff andi r1,r11,0xffff
8003e34: f8 00 3f 49 calli 8013b58 <__ashlsi3>
8003e38: b5 a1 10 00 add r2,r13,r1
8003e3c: 58 4c 00 00 sw (r2+0),r12
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
8003e40: 59 80 00 0c sw (r12+12),r0
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
8003e44: 59 cb 00 00 sw (r14+0),r11
_Thread_Enable_dispatch();
8003e48: f8 00 0e cf calli 8007984 <_Thread_Enable_dispatch>
return 0;
8003e4c: 34 01 00 00 mvi r1,0
}
8003e50: 2b 9d 00 04 lw ra,(sp+4)
8003e54: 2b 8b 00 14 lw r11,(sp+20)
8003e58: 2b 8c 00 10 lw r12,(sp+16)
8003e5c: 2b 8d 00 0c lw r13,(sp+12)
8003e60: 2b 8e 00 08 lw r14,(sp+8)
8003e64: 37 9c 00 14 addi sp,sp,20
8003e68: c3 a0 00 00 ret
08003bf4 <pthread_condattr_destroy>:
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
8003bf4: 34 02 00 16 mvi r2,22
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
8003bf8: 44 20 00 05 be r1,r0,8003c0c <pthread_condattr_destroy+0x18>
8003bfc: 28 23 00 00 lw r3,(r1+0)
8003c00: 44 60 00 03 be r3,r0,8003c0c <pthread_condattr_destroy+0x18><== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
8003c04: 58 20 00 00 sw (r1+0),r0
return 0;
8003c08: 34 02 00 00 mvi r2,0
}
8003c0c: b8 40 08 00 mv r1,r2
8003c10: c3 a0 00 00 ret
080030d0 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
80030d0: 37 9c ff a0 addi sp,sp,-96
80030d4: 5b 8b 00 3c sw (sp+60),r11
80030d8: 5b 8c 00 38 sw (sp+56),r12
80030dc: 5b 8d 00 34 sw (sp+52),r13
80030e0: 5b 8e 00 30 sw (sp+48),r14
80030e4: 5b 8f 00 2c sw (sp+44),r15
80030e8: 5b 90 00 28 sw (sp+40),r16
80030ec: 5b 91 00 24 sw (sp+36),r17
80030f0: 5b 92 00 20 sw (sp+32),r18
80030f4: 5b 93 00 1c sw (sp+28),r19
80030f8: 5b 94 00 18 sw (sp+24),r20
80030fc: 5b 95 00 14 sw (sp+20),r21
8003100: 5b 9d 00 10 sw (sp+16),ra
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
8003104: 34 0d 00 0e mvi r13,14
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
8003108: b8 20 88 00 mv r17,r1
800310c: b8 60 80 00 mv r16,r3
8003110: b8 80 90 00 mv r18,r4
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
8003114: 44 60 00 a5 be r3,r0,80033a8 <pthread_create+0x2d8>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
8003118: b8 40 58 00 mv r11,r2
800311c: 5c 40 00 03 bne r2,r0,8003128 <pthread_create+0x58>
8003120: 78 0b 08 01 mvhi r11,0x801
8003124: 39 6b d9 d4 ori r11,r11,0xd9d4
if ( !the_attr->is_initialized )
8003128: 29 61 00 00 lw r1,(r11+0)
return EINVAL;
800312c: 34 0d 00 16 mvi r13,22
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
if ( !the_attr->is_initialized )
8003130: 44 20 00 9e be r1,r0,80033a8 <pthread_create+0x2d8>
* stack space if it is allowed to allocate it itself.
*
* NOTE: If the user provides the stack we will let it drop below
* twice the minimum.
*/
if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) )
8003134: 29 61 00 04 lw r1,(r11+4)
8003138: 44 20 00 06 be r1,r0,8003150 <pthread_create+0x80>
800313c: 78 02 08 01 mvhi r2,0x801
8003140: 38 42 f1 10 ori r2,r2,0xf110
8003144: 29 63 00 08 lw r3,(r11+8)
8003148: 28 41 00 00 lw r1,(r2+0)
800314c: 54 23 00 97 bgu r1,r3,80033a8 <pthread_create+0x2d8>
* If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
* inherits scheduling attributes from the creating thread. If it is
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
8003150: 29 62 00 10 lw r2,(r11+16)
8003154: 34 01 00 01 mvi r1,1
8003158: 44 41 00 05 be r2,r1,800316c <pthread_create+0x9c>
800315c: 34 01 00 02 mvi r1,2
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
8003160: 34 0d 00 16 mvi r13,22
* If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
* inherits scheduling attributes from the creating thread. If it is
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
8003164: 5c 41 00 91 bne r2,r1,80033a8 <pthread_create+0x2d8>
8003168: e0 00 00 14 bi 80031b8 <pthread_create+0xe8>
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
800316c: 78 02 08 01 mvhi r2,0x801
8003170: 38 42 fd 74 ori r2,r2,0xfd74
8003174: 28 41 00 0c lw r1,(r2+12)
8003178: 28 22 01 20 lw r2,(r1+288)
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
800317c: 28 48 00 88 lw r8,(r2+136)
8003180: 28 47 00 8c lw r7,(r2+140)
8003184: 28 46 00 90 lw r6,(r2+144)
8003188: 28 45 00 94 lw r5,(r2+148)
800318c: 28 44 00 98 lw r4,(r2+152)
8003190: 28 43 00 9c lw r3,(r2+156)
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
schedpolicy = api->schedpolicy;
8003194: 28 4f 00 84 lw r15,(r2+132)
schedparam = api->schedparam;
8003198: 28 41 00 a0 lw r1,(r2+160)
800319c: 5b 88 00 40 sw (sp+64),r8
80031a0: 5b 87 00 44 sw (sp+68),r7
80031a4: 5b 86 00 48 sw (sp+72),r6
80031a8: 5b 85 00 4c sw (sp+76),r5
80031ac: 5b 84 00 50 sw (sp+80),r4
80031b0: 5b 83 00 54 sw (sp+84),r3
80031b4: e0 00 00 0f bi 80031f0 <pthread_create+0x120>
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
80031b8: 29 67 00 18 lw r7,(r11+24)
80031bc: 29 66 00 1c lw r6,(r11+28)
80031c0: 29 65 00 20 lw r5,(r11+32)
80031c4: 29 64 00 24 lw r4,(r11+36)
80031c8: 29 63 00 28 lw r3,(r11+40)
80031cc: 29 62 00 2c lw r2,(r11+44)
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
80031d0: 29 6f 00 14 lw r15,(r11+20)
schedparam = the_attr->schedparam;
80031d4: 29 61 00 30 lw r1,(r11+48)
80031d8: 5b 87 00 40 sw (sp+64),r7
80031dc: 5b 86 00 44 sw (sp+68),r6
80031e0: 5b 85 00 48 sw (sp+72),r5
80031e4: 5b 84 00 4c sw (sp+76),r4
80031e8: 5b 83 00 50 sw (sp+80),r3
80031ec: 5b 82 00 54 sw (sp+84),r2
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
80031f0: 29 6c 00 0c lw r12,(r11+12)
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
80031f4: 5b 81 00 58 sw (sp+88),r1
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
return ENOTSUP;
80031f8: 34 0d 00 86 mvi r13,134
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
80031fc: 5d 80 00 6b bne r12,r0,80033a8 <pthread_create+0x2d8>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
8003200: 2b 81 00 40 lw r1,(sp+64)
return EINVAL;
8003204: 34 0d 00 16 mvi r13,22
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
8003208: f8 00 1b ef calli 800a1c4 <_POSIX_Priority_Is_valid>
800320c: 44 2c 00 67 be r1,r12,80033a8 <pthread_create+0x2d8> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
8003210: 78 02 08 01 mvhi r2,0x801
8003214: 38 42 f1 14 ori r2,r2,0xf114
8003218: 40 54 00 00 lbu r20,(r2+0)
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
800321c: b9 e0 08 00 mv r1,r15
8003220: 37 82 00 40 addi r2,sp,64
8003224: 37 83 00 60 addi r3,sp,96
8003228: 37 84 00 5c addi r4,sp,92
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
800322c: 2b 93 00 40 lw r19,(sp+64)
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
8003230: f8 00 1b ed calli 800a1e4 <_POSIX_Thread_Translate_sched_param>
8003234: b8 20 68 00 mv r13,r1
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
8003238: 5c 20 00 5c bne r1,r0,80033a8 <pthread_create+0x2d8> <== NEVER TAKEN
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
800323c: 78 0c 08 01 mvhi r12,0x801
8003240: 39 8c f9 68 ori r12,r12,0xf968
8003244: 29 81 00 00 lw r1,(r12+0)
8003248: f8 00 04 f0 calli 8004608 <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
800324c: 78 02 08 01 mvhi r2,0x801
8003250: b8 40 08 00 mv r1,r2
8003254: 38 21 fa 7c ori r1,r1,0xfa7c
8003258: f8 00 08 00 calli 8005258 <_Objects_Allocate>
800325c: b8 20 70 00 mv r14,r1
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
8003260: 5c 2d 00 03 bne r1,r13,800326c <pthread_create+0x19c>
_RTEMS_Unlock_allocator();
8003264: 29 81 00 00 lw r1,(r12+0)
8003268: e0 00 00 21 bi 80032ec <pthread_create+0x21c>
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
800326c: 78 02 08 01 mvhi r2,0x801
8003270: 38 42 f1 10 ori r2,r2,0xf110
8003274: 28 41 00 00 lw r1,(r2+0)
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
8003278: 29 6c 00 08 lw r12,(r11+8)
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
800327c: 34 02 00 01 mvi r2,1
8003280: f8 00 63 59 calli 801bfe4 <__ashlsi3>
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
8003284: 29 75 00 04 lw r21,(r11+4)
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
8003288: b8 20 28 00 mv r5,r1
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
800328c: 50 2c 00 02 bgeu r1,r12,8003294 <pthread_create+0x1c4>
8003290: b9 80 28 00 mv r5,r12
8003294: 2b 81 00 5c lw r1,(sp+92)
8003298: 78 0c 08 01 mvhi r12,0x801
800329c: 2b 88 00 60 lw r8,(sp+96)
80032a0: 39 8c fa 7c ori r12,r12,0xfa7c
80032a4: 5b 81 00 04 sw (sp+4),r1
80032a8: b8 a0 20 00 mv r4,r5
80032ac: b9 80 08 00 mv r1,r12
80032b0: b9 c0 10 00 mv r2,r14
80032b4: ba a0 18 00 mv r3,r21
80032b8: 34 05 00 00 mvi r5,0
80032bc: ca 93 30 00 sub r6,r20,r19
80032c0: 34 07 00 01 mvi r7,1
80032c4: 5b 80 00 08 sw (sp+8),r0
80032c8: 5b 80 00 0c sw (sp+12),r0
80032cc: f8 00 0d 36 calli 80067a4 <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
80032d0: 5c 20 00 0a bne r1,r0,80032f8 <pthread_create+0x228> <== ALWAYS TAKEN
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
80032d4: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
80032d8: b9 c0 10 00 mv r2,r14 <== NOT EXECUTED
80032dc: f8 00 08 da calli 8005644 <_Objects_Free> <== NOT EXECUTED
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
80032e0: 78 01 08 01 mvhi r1,0x801 <== NOT EXECUTED
80032e4: 38 21 f9 68 ori r1,r1,0xf968 <== NOT EXECUTED
80032e8: 28 21 00 00 lw r1,(r1+0) <== NOT EXECUTED
80032ec: f8 00 04 e4 calli 800467c <_API_Mutex_Unlock>
return EAGAIN;
80032f0: 34 0d 00 0b mvi r13,11
80032f4: e0 00 00 2d bi 80033a8 <pthread_create+0x2d8>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
80032f8: 29 cc 01 20 lw r12,(r14+288)
api->Attributes = *the_attr;
80032fc: b9 60 10 00 mv r2,r11
8003300: 34 03 00 40 mvi r3,64
8003304: b9 80 08 00 mv r1,r12
8003308: f8 00 2a c7 calli 800de24 <memcpy>
api->detachstate = the_attr->detachstate;
800330c: 29 61 00 3c lw r1,(r11+60)
api->schedparam = schedparam;
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
8003310: 34 02 00 01 mvi r2,1
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
api->schedpolicy = schedpolicy;
8003314: 59 8f 00 84 sw (r12+132),r15
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
8003318: 59 81 00 40 sw (r12+64),r1
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
800331c: 2b 81 00 40 lw r1,(sp+64)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
8003320: ba 00 18 00 mv r3,r16
8003324: ba 40 20 00 mv r4,r18
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
8003328: 59 81 00 88 sw (r12+136),r1
800332c: 2b 81 00 44 lw r1,(sp+68)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
8003330: 34 05 00 00 mvi r5,0
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
8003334: 59 81 00 8c sw (r12+140),r1
8003338: 2b 81 00 48 lw r1,(sp+72)
800333c: 59 81 00 90 sw (r12+144),r1
8003340: 2b 81 00 4c lw r1,(sp+76)
8003344: 59 81 00 94 sw (r12+148),r1
8003348: 2b 81 00 50 lw r1,(sp+80)
800334c: 59 81 00 98 sw (r12+152),r1
8003350: 2b 81 00 54 lw r1,(sp+84)
8003354: 59 81 00 9c sw (r12+156),r1
8003358: 2b 81 00 58 lw r1,(sp+88)
800335c: 59 81 00 a0 sw (r12+160),r1
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
8003360: b9 c0 08 00 mv r1,r14
8003364: f8 00 0f da calli 80072cc <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
8003368: 34 01 00 04 mvi r1,4
800336c: 5d e1 00 09 bne r15,r1,8003390 <pthread_create+0x2c0>
_Watchdog_Insert_ticks(
8003370: 35 81 00 90 addi r1,r12,144
8003374: f8 00 10 5d calli 80074e8 <_Timespec_To_ticks>
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8003378: 78 02 08 01 mvhi r2,0x801
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
800337c: 59 81 00 b4 sw (r12+180),r1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8003380: b8 40 08 00 mv r1,r2
8003384: 38 21 f9 88 ori r1,r1,0xf988
8003388: 35 82 00 a8 addi r2,r12,168
800338c: f8 00 11 8c calli 80079bc <_Watchdog_Insert>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
8003390: 29 c1 00 08 lw r1,(r14+8)
8003394: 5a 21 00 00 sw (r17+0),r1
_RTEMS_Unlock_allocator();
8003398: 78 01 08 01 mvhi r1,0x801
800339c: 38 21 f9 68 ori r1,r1,0xf968
80033a0: 28 21 00 00 lw r1,(r1+0)
80033a4: f8 00 04 b6 calli 800467c <_API_Mutex_Unlock>
return 0;
}
80033a8: b9 a0 08 00 mv r1,r13
80033ac: 2b 9d 00 10 lw ra,(sp+16)
80033b0: 2b 8b 00 3c lw r11,(sp+60)
80033b4: 2b 8c 00 38 lw r12,(sp+56)
80033b8: 2b 8d 00 34 lw r13,(sp+52)
80033bc: 2b 8e 00 30 lw r14,(sp+48)
80033c0: 2b 8f 00 2c lw r15,(sp+44)
80033c4: 2b 90 00 28 lw r16,(sp+40)
80033c8: 2b 91 00 24 lw r17,(sp+36)
80033cc: 2b 92 00 20 lw r18,(sp+32)
80033d0: 2b 93 00 1c lw r19,(sp+28)
80033d4: 2b 94 00 18 lw r20,(sp+24)
80033d8: 2b 95 00 14 lw r21,(sp+20)
80033dc: 37 9c 00 60 addi sp,sp,96
80033e0: c3 a0 00 00 ret
08010e68 <pthread_exit>:
void pthread_exit(
void *value_ptr
)
{
8010e68: 37 9c ff fc addi sp,sp,-4
8010e6c: 5b 9d 00 04 sw (sp+4),ra
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
8010e70: 78 03 08 01 mvhi r3,0x801
8010e74: 38 63 9e 3c ori r3,r3,0x9e3c
}
void pthread_exit(
void *value_ptr
)
{
8010e78: b8 20 10 00 mv r2,r1
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
8010e7c: 28 61 00 0c lw r1,(r3+12)
8010e80: fb ff ff d4 calli 8010dd0 <_POSIX_Thread_Exit>
}
8010e84: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
8010e88: 37 9c 00 04 addi sp,sp,4 <== NOT EXECUTED
8010e8c: c3 a0 00 00 ret <== NOT EXECUTED
080260b8 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
80260b8: 37 9c ff e4 addi sp,sp,-28
80260bc: 5b 8b 00 18 sw (sp+24),r11
80260c0: 5b 8c 00 14 sw (sp+20),r12
80260c4: 5b 8d 00 10 sw (sp+16),r13
80260c8: 5b 8e 00 0c sw (sp+12),r14
80260cc: 5b 8f 00 08 sw (sp+8),r15
80260d0: 5b 9d 00 04 sw (sp+4),ra
80260d4: b8 40 58 00 mv r11,r2
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
80260d8: 44 40 00 04 be r2,r0,80260e8 <pthread_kill+0x30>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
80260dc: 34 4f ff ff addi r15,r2,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
80260e0: 34 02 00 1f mvi r2,31
80260e4: 50 4f 00 04 bgeu r2,r15,80260f4 <pthread_kill+0x3c>
rtems_set_errno_and_return_minus_one( EINVAL );
80260e8: fb ff b3 c9 calli 801300c <__errno>
80260ec: 34 02 00 16 mvi r2,22
80260f0: e0 00 00 29 bi 8026194 <pthread_kill+0xdc>
the_thread = _Thread_Get( thread, &location );
80260f4: 37 82 00 1c addi r2,sp,28
80260f8: fb ff 98 36 calli 800c1d0 <_Thread_Get>
80260fc: b8 20 60 00 mv r12,r1
switch ( location ) {
8026100: 2b 81 00 1c lw r1,(sp+28)
8026104: 5c 20 00 22 bne r1,r0,802618c <pthread_kill+0xd4> <== NEVER TAKEN
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
8026108: 34 02 00 01 mvi r2,1
802610c: b9 60 08 00 mv r1,r11
8026110: fb ff 6f 65 calli 8001ea4 <__ashlsi3>
8026114: 78 0d 08 02 mvhi r13,0x802
8026118: b4 2b 08 00 add r1,r1,r11
802611c: 34 02 00 02 mvi r2,2
8026120: 39 ad 9f 78 ori r13,r13,0x9f78
8026124: fb ff 6f 60 calli 8001ea4 <__ashlsi3>
8026128: b5 a1 08 00 add r1,r13,r1
802612c: 28 21 00 08 lw r1,(r1+8)
8026130: 34 0d 00 01 mvi r13,1
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
8026134: 29 8e 01 20 lw r14,(r12+288)
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
8026138: 44 2d 00 12 be r1,r13,8026180 <pthread_kill+0xc8>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
802613c: b9 e0 10 00 mv r2,r15
8026140: 34 01 00 01 mvi r1,1
8026144: fb ff 6f 58 calli 8001ea4 <__ashlsi3>
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
8026148: 29 c2 00 d4 lw r2,(r14+212)
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
802614c: 34 03 00 00 mvi r3,0
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
8026150: b8 41 08 00 or r1,r2,r1
8026154: 59 c1 00 d4 sw (r14+212),r1
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
8026158: b9 60 10 00 mv r2,r11
802615c: b9 80 08 00 mv r1,r12
8026160: fb ff ff 7b calli 8025f4c <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
8026164: 78 02 08 02 mvhi r2,0x802
8026168: 38 42 9f 2c ori r2,r2,0x9f2c
802616c: 28 41 00 08 lw r1,(r2+8)
8026170: 44 20 00 04 be r1,r0,8026180 <pthread_kill+0xc8>
8026174: 28 41 00 0c lw r1,(r2+12)
8026178: 5d 81 00 02 bne r12,r1,8026180 <pthread_kill+0xc8>
_Thread_Dispatch_necessary = true;
802617c: 30 4d 00 18 sb (r2+24),r13
}
_Thread_Enable_dispatch();
8026180: fb ff 98 07 calli 800c19c <_Thread_Enable_dispatch>
return 0;
8026184: 34 01 00 00 mvi r1,0
8026188: e0 00 00 05 bi 802619c <pthread_kill+0xe4>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
802618c: fb ff b3 a0 calli 801300c <__errno> <== NOT EXECUTED
8026190: 34 02 00 03 mvi r2,3 <== NOT EXECUTED
8026194: 58 22 00 00 sw (r1+0),r2
8026198: 34 01 ff ff mvi r1,-1
}
802619c: 2b 9d 00 04 lw ra,(sp+4)
80261a0: 2b 8b 00 18 lw r11,(sp+24)
80261a4: 2b 8c 00 14 lw r12,(sp+20)
80261a8: 2b 8d 00 10 lw r13,(sp+16)
80261ac: 2b 8e 00 0c lw r14,(sp+12)
80261b0: 2b 8f 00 08 lw r15,(sp+8)
80261b4: 37 9c 00 1c addi sp,sp,28
80261b8: c3 a0 00 00 ret
08005688 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
8005688: 37 9c ff ec addi sp,sp,-20
800568c: 5b 8b 00 10 sw (sp+16),r11
8005690: 5b 8c 00 0c sw (sp+12),r12
8005694: 5b 8d 00 08 sw (sp+8),r13
8005698: 5b 9d 00 04 sw (sp+4),ra
800569c: b8 20 68 00 mv r13,r1
*
* 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 );
80056a0: b8 40 08 00 mv r1,r2
80056a4: 37 82 00 14 addi r2,sp,20
80056a8: f8 00 00 41 calli 80057ac <_POSIX_Absolute_timeout_to_ticks>
int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex));
int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex));
#if defined(_POSIX_TIMEOUTS)
int _EXFUN(pthread_mutex_timedlock,
80056ac: 64 2c 00 03 cmpei r12,r1,3
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
80056b0: 2b 83 00 14 lw r3,(sp+20)
*
* 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 );
80056b4: b8 20 58 00 mv r11,r1
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
80056b8: b9 80 10 00 mv r2,r12
80056bc: b9 a0 08 00 mv r1,r13
80056c0: fb ff ff a3 calli 800554c <_POSIX_Mutex_Lock_support>
* This service only gives us the option to block. We used a polling
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
80056c4: 5d 80 00 0b bne r12,r0,80056f0 <pthread_mutex_timedlock+0x68>
80056c8: 34 02 00 10 mvi r2,16
80056cc: 5c 22 00 09 bne r1,r2,80056f0 <pthread_mutex_timedlock+0x68><== NEVER TAKEN
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
80056d0: 45 60 00 05 be r11,r0,80056e4 <pthread_mutex_timedlock+0x5c><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
80056d4: 35 6b ff ff addi r11,r11,-1
80056d8: 34 02 00 01 mvi r2,1
80056dc: 50 4b 00 04 bgeu r2,r11,80056ec <pthread_mutex_timedlock+0x64><== ALWAYS TAKEN
80056e0: e0 00 00 04 bi 80056f0 <pthread_mutex_timedlock+0x68> <== NOT EXECUTED
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
80056e4: 34 01 00 16 mvi r1,22 <== NOT EXECUTED
80056e8: e0 00 00 02 bi 80056f0 <pthread_mutex_timedlock+0x68> <== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
80056ec: 34 01 00 74 mvi r1,116
}
return lock_status;
}
80056f0: 2b 9d 00 04 lw ra,(sp+4)
80056f4: 2b 8b 00 10 lw r11,(sp+16)
80056f8: 2b 8c 00 0c lw r12,(sp+12)
80056fc: 2b 8d 00 08 lw r13,(sp+8)
8005700: 37 9c 00 14 addi sp,sp,20
8005704: c3 a0 00 00 ret
0800298c <pthread_mutexattr_gettype>:
const pthread_mutexattr_t *attr,
int *type
)
{
if ( !attr )
return EINVAL;
800298c: 34 03 00 16 mvi r3,22
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
if ( !attr )
8002990: 44 20 00 07 be r1,r0,80029ac <pthread_mutexattr_gettype+0x20>
return EINVAL;
if ( !attr->is_initialized )
8002994: 28 24 00 00 lw r4,(r1+0)
8002998: 44 80 00 05 be r4,r0,80029ac <pthread_mutexattr_gettype+0x20>
return EINVAL;
if ( !type )
800299c: 44 40 00 04 be r2,r0,80029ac <pthread_mutexattr_gettype+0x20><== NEVER TAKEN
return EINVAL;
*type = attr->type;
80029a0: 28 21 00 10 lw r1,(r1+16)
return 0;
80029a4: 34 03 00 00 mvi r3,0
return EINVAL;
if ( !type )
return EINVAL;
*type = attr->type;
80029a8: 58 41 00 00 sw (r2+0),r1
return 0;
}
80029ac: b8 60 08 00 mv r1,r3
80029b0: c3 a0 00 00 ret
080051b8 <pthread_mutexattr_setpshared>:
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
80051b8: 34 03 00 16 mvi r3,22
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
80051bc: 44 20 00 07 be r1,r0,80051d8 <pthread_mutexattr_setpshared+0x20>
80051c0: 28 24 00 00 lw r4,(r1+0)
80051c4: 44 80 00 05 be r4,r0,80051d8 <pthread_mutexattr_setpshared+0x20>
return EINVAL;
switch ( pshared ) {
80051c8: 34 04 00 01 mvi r4,1
80051cc: 54 44 00 03 bgu r2,r4,80051d8 <pthread_mutexattr_setpshared+0x20><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
80051d0: 58 22 00 04 sw (r1+4),r2
return 0;
80051d4: 34 03 00 00 mvi r3,0
default:
return EINVAL;
}
}
80051d8: b8 60 08 00 mv r1,r3
80051dc: c3 a0 00 00 ret
08002a00 <pthread_mutexattr_settype>:
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
8002a00: 34 03 00 16 mvi r3,22
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
8002a04: 44 20 00 07 be r1,r0,8002a20 <pthread_mutexattr_settype+0x20>
8002a08: 28 24 00 00 lw r4,(r1+0)
8002a0c: 44 80 00 05 be r4,r0,8002a20 <pthread_mutexattr_settype+0x20><== NEVER TAKEN
return EINVAL;
switch ( type ) {
8002a10: 34 04 00 03 mvi r4,3
8002a14: 54 44 00 03 bgu r2,r4,8002a20 <pthread_mutexattr_settype+0x20>
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
8002a18: 58 22 00 10 sw (r1+16),r2
return 0;
8002a1c: 34 03 00 00 mvi r3,0
default:
return EINVAL;
}
}
8002a20: b8 60 08 00 mv r1,r3
8002a24: c3 a0 00 00 ret
080038d4 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
80038d4: 37 9c ff ec addi sp,sp,-20
80038d8: 5b 8b 00 10 sw (sp+16),r11
80038dc: 5b 8c 00 0c sw (sp+12),r12
80038e0: 5b 8d 00 08 sw (sp+8),r13
80038e4: 5b 9d 00 04 sw (sp+4),ra
80038e8: b8 20 58 00 mv r11,r1
80038ec: b8 40 60 00 mv r12,r2
if ( !once_control || !init_routine )
80038f0: 64 21 00 00 cmpei r1,r1,0
80038f4: 64 42 00 00 cmpei r2,r2,0
80038f8: b8 41 10 00 or r2,r2,r1
return EINVAL;
80038fc: 34 01 00 16 mvi r1,22
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
8003900: 5c 40 00 13 bne r2,r0,800394c <pthread_once+0x78>
return EINVAL;
if ( !once_control->init_executed ) {
8003904: 29 6d 00 04 lw r13,(r11+4)
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
8003908: 34 01 00 00 mvi r1,0
)
{
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
800390c: 5d a2 00 10 bne r13,r2,800394c <pthread_once+0x78>
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
8003910: 34 01 01 00 mvi r1,256
8003914: 34 02 01 00 mvi r2,256
8003918: 37 83 00 14 addi r3,sp,20
800391c: f8 00 01 96 calli 8003f74 <rtems_task_mode>
if ( !once_control->init_executed ) {
8003920: 29 61 00 04 lw r1,(r11+4)
8003924: 5c 2d 00 05 bne r1,r13,8003938 <pthread_once+0x64> <== NEVER TAKEN
once_control->is_initialized = true;
8003928: 34 01 00 01 mvi r1,1
800392c: 59 61 00 00 sw (r11+0),r1
once_control->init_executed = true;
8003930: 59 61 00 04 sw (r11+4),r1
(*init_routine)();
8003934: d9 80 00 00 call r12
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
8003938: 2b 81 00 14 lw r1,(sp+20)
800393c: 34 02 01 00 mvi r2,256
8003940: 37 83 00 14 addi r3,sp,20
8003944: f8 00 01 8c calli 8003f74 <rtems_task_mode>
}
return 0;
8003948: 34 01 00 00 mvi r1,0
}
800394c: 2b 9d 00 04 lw ra,(sp+4)
8003950: 2b 8b 00 10 lw r11,(sp+16)
8003954: 2b 8c 00 0c lw r12,(sp+12)
8003958: 2b 8d 00 08 lw r13,(sp+8)
800395c: 37 9c 00 14 addi sp,sp,20
8003960: c3 a0 00 00 ret
0800428c <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
800428c: 37 9c ff e0 addi sp,sp,-32
8004290: 5b 8b 00 14 sw (sp+20),r11
8004294: 5b 8c 00 10 sw (sp+16),r12
8004298: 5b 8d 00 0c sw (sp+12),r13
800429c: 5b 8e 00 08 sw (sp+8),r14
80042a0: 5b 9d 00 04 sw (sp+4),ra
/*
* Error check parameters
*/
if ( !rwlock )
return EINVAL;
80042a4: 34 03 00 16 mvi r3,22
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
80042a8: b8 20 68 00 mv r13,r1
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
80042ac: 44 20 00 28 be r1,r0,800434c <pthread_rwlock_init+0xc0>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
80042b0: 5c 40 00 05 bne r2,r0,80042c4 <pthread_rwlock_init+0x38>
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
80042b4: 37 8b 00 18 addi r11,sp,24
80042b8: b9 60 08 00 mv r1,r11
80042bc: f8 00 02 ff calli 8004eb8 <pthread_rwlockattr_init>
the_attr = &default_attr;
80042c0: b9 60 10 00 mv r2,r11
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
80042c4: 28 41 00 00 lw r1,(r2+0)
return EINVAL;
80042c8: 34 03 00 16 mvi r3,22
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
80042cc: 44 20 00 20 be r1,r0,800434c <pthread_rwlock_init+0xc0> <== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
80042d0: 28 4e 00 04 lw r14,(r2+4)
80042d4: 5d c0 00 1e bne r14,r0,800434c <pthread_rwlock_init+0xc0> <== NEVER TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
80042d8: 78 02 08 01 mvhi r2,0x801
80042dc: 38 42 88 d8 ori r2,r2,0x88d8
80042e0: 28 41 00 00 lw r1,(r2+0)
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
80042e4: 5b 80 00 20 sw (sp+32),r0
80042e8: 34 21 00 01 addi r1,r1,1
80042ec: 58 41 00 00 sw (r2+0),r1
* the inactive chain of free RWLock control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void )
{
return (POSIX_RWLock_Control *)
_Objects_Allocate( &_POSIX_RWLock_Information );
80042f0: 78 0c 08 01 mvhi r12,0x801
80042f4: 39 8c 8a 4c ori r12,r12,0x8a4c
80042f8: b9 80 08 00 mv r1,r12
80042fc: f8 00 09 9c calli 800696c <_Objects_Allocate>
8004300: b8 20 58 00 mv r11,r1
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
8004304: 5c 2e 00 04 bne r1,r14,8004314 <pthread_rwlock_init+0x88>
_Thread_Enable_dispatch();
8004308: f8 00 0e 92 calli 8007d50 <_Thread_Enable_dispatch>
return EAGAIN;
800430c: 34 03 00 0b mvi r3,11
8004310: e0 00 00 0f bi 800434c <pthread_rwlock_init+0xc0>
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
8004314: 34 21 00 10 addi r1,r1,16
8004318: 37 82 00 20 addi r2,sp,32
800431c: f8 00 06 d9 calli 8005e80 <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
8004320: 29 6e 00 08 lw r14,(r11+8)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8004324: 29 8c 00 1c lw r12,(r12+28)
8004328: 34 02 00 02 mvi r2,2
800432c: 21 c1 ff ff andi r1,r14,0xffff
8004330: f8 00 40 e8 calli 80146d0 <__ashlsi3>
8004334: b5 81 08 00 add r1,r12,r1
8004338: 58 2b 00 00 sw (r1+0),r11
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
800433c: 59 60 00 0c sw (r11+12),r0
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
8004340: 59 ae 00 00 sw (r13+0),r14
_Thread_Enable_dispatch();
8004344: f8 00 0e 83 calli 8007d50 <_Thread_Enable_dispatch>
return 0;
8004348: 34 03 00 00 mvi r3,0
}
800434c: b8 60 08 00 mv r1,r3
8004350: 2b 9d 00 04 lw ra,(sp+4)
8004354: 2b 8b 00 14 lw r11,(sp+20)
8004358: 2b 8c 00 10 lw r12,(sp+16)
800435c: 2b 8d 00 0c lw r13,(sp+12)
8004360: 2b 8e 00 08 lw r14,(sp+8)
8004364: 37 9c 00 20 addi sp,sp,32
8004368: c3 a0 00 00 ret
080043f4 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
80043f4: 37 9c ff e0 addi sp,sp,-32
80043f8: 5b 8b 00 18 sw (sp+24),r11
80043fc: 5b 8c 00 14 sw (sp+20),r12
8004400: 5b 8d 00 10 sw (sp+16),r13
8004404: 5b 8e 00 0c sw (sp+12),r14
8004408: 5b 8f 00 08 sw (sp+8),r15
800440c: 5b 9d 00 04 sw (sp+4),ra
8004410: b8 20 70 00 mv r14,r1
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
8004414: 34 0b 00 16 mvi r11,22
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
8004418: b8 40 08 00 mv r1,r2
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
800441c: 45 c0 00 25 be r14,r0,80044b0 <pthread_rwlock_timedrdlock+0xbc>
*
* 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 );
8004420: 37 82 00 1c addi r2,sp,28
8004424: f8 00 1c 6a calli 800b5cc <_POSIX_Absolute_timeout_to_ticks>
8004428: 29 c2 00 00 lw r2,(r14+0)
800442c: b8 20 60 00 mv r12,r1
8004430: 78 01 08 01 mvhi r1,0x801
8004434: 38 21 8a 4c ori r1,r1,0x8a4c
8004438: 37 83 00 20 addi r3,sp,32
800443c: f8 00 0a b0 calli 8006efc <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
8004440: 2b 8f 00 20 lw r15,(sp+32)
8004444: 5d e0 00 1b bne r15,r0,80044b0 <pthread_rwlock_timedrdlock+0xbc>
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,
8004448: 65 8d 00 03 cmpei r13,r12,3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
800444c: 29 c2 00 00 lw r2,(r14+0)
8004450: 2b 84 00 1c lw r4,(sp+28)
8004454: 34 21 00 10 addi r1,r1,16
8004458: b9 a0 18 00 mv r3,r13
800445c: 34 05 00 00 mvi r5,0
8004460: f8 00 06 95 calli 8005eb4 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
8004464: f8 00 0e 3b calli 8007d50 <_Thread_Enable_dispatch>
if ( !do_wait ) {
8004468: 5d af 00 0c bne r13,r15,8004498 <pthread_rwlock_timedrdlock+0xa4>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
800446c: 78 01 08 01 mvhi r1,0x801
8004470: 38 21 8d 84 ori r1,r1,0x8d84
8004474: 28 21 00 0c lw r1,(r1+12)
8004478: 28 22 00 34 lw r2,(r1+52)
800447c: 34 01 00 02 mvi r1,2
8004480: 5c 41 00 06 bne r2,r1,8004498 <pthread_rwlock_timedrdlock+0xa4>
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
8004484: 45 8d 00 0b be r12,r13,80044b0 <pthread_rwlock_timedrdlock+0xbc><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
8004488: 35 8c ff ff addi r12,r12,-1
800448c: 34 01 00 01 mvi r1,1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
8004490: 34 0b 00 74 mvi r11,116
_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 ||
8004494: 50 2c 00 07 bgeu r1,r12,80044b0 <pthread_rwlock_timedrdlock+0xbc><== ALWAYS TAKEN
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
8004498: 78 01 08 01 mvhi r1,0x801
800449c: 38 21 8d 84 ori r1,r1,0x8d84
80044a0: 28 21 00 0c lw r1,(r1+12)
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
80044a4: 28 21 00 34 lw r1,(r1+52)
80044a8: f8 00 00 43 calli 80045b4 <_POSIX_RWLock_Translate_core_RWLock_return_code>
80044ac: b8 20 58 00 mv r11,r1
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
80044b0: b9 60 08 00 mv r1,r11
80044b4: 2b 9d 00 04 lw ra,(sp+4)
80044b8: 2b 8b 00 18 lw r11,(sp+24)
80044bc: 2b 8c 00 14 lw r12,(sp+20)
80044c0: 2b 8d 00 10 lw r13,(sp+16)
80044c4: 2b 8e 00 0c lw r14,(sp+12)
80044c8: 2b 8f 00 08 lw r15,(sp+8)
80044cc: 37 9c 00 20 addi sp,sp,32
80044d0: c3 a0 00 00 ret
080044d4 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
80044d4: 37 9c ff e0 addi sp,sp,-32
80044d8: 5b 8b 00 18 sw (sp+24),r11
80044dc: 5b 8c 00 14 sw (sp+20),r12
80044e0: 5b 8d 00 10 sw (sp+16),r13
80044e4: 5b 8e 00 0c sw (sp+12),r14
80044e8: 5b 8f 00 08 sw (sp+8),r15
80044ec: 5b 9d 00 04 sw (sp+4),ra
80044f0: b8 20 70 00 mv r14,r1
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
80044f4: 34 0b 00 16 mvi r11,22
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
80044f8: b8 40 08 00 mv r1,r2
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
80044fc: 45 c0 00 25 be r14,r0,8004590 <pthread_rwlock_timedwrlock+0xbc>
*
* 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 );
8004500: 37 82 00 1c addi r2,sp,28
8004504: f8 00 1c 32 calli 800b5cc <_POSIX_Absolute_timeout_to_ticks>
8004508: 29 c2 00 00 lw r2,(r14+0)
800450c: b8 20 60 00 mv r12,r1
8004510: 78 01 08 01 mvhi r1,0x801
8004514: 38 21 8a 4c ori r1,r1,0x8a4c
8004518: 37 83 00 20 addi r3,sp,32
800451c: f8 00 0a 78 calli 8006efc <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
8004520: 2b 8f 00 20 lw r15,(sp+32)
8004524: 5d e0 00 1b bne r15,r0,8004590 <pthread_rwlock_timedwrlock+0xbc>
(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,
8004528: 65 8d 00 03 cmpei r13,r12,3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
800452c: 29 c2 00 00 lw r2,(r14+0)
8004530: 2b 84 00 1c lw r4,(sp+28)
8004534: 34 21 00 10 addi r1,r1,16
8004538: b9 a0 18 00 mv r3,r13
800453c: 34 05 00 00 mvi r5,0
8004540: f8 00 06 9f calli 8005fbc <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
8004544: f8 00 0e 03 calli 8007d50 <_Thread_Enable_dispatch>
if ( !do_wait &&
8004548: 5d af 00 0c bne r13,r15,8004578 <pthread_rwlock_timedwrlock+0xa4>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
800454c: 78 01 08 01 mvhi r1,0x801
8004550: 38 21 8d 84 ori r1,r1,0x8d84
8004554: 28 21 00 0c lw r1,(r1+12)
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
8004558: 28 22 00 34 lw r2,(r1+52)
800455c: 34 01 00 02 mvi r1,2
8004560: 5c 41 00 06 bne r2,r1,8004578 <pthread_rwlock_timedwrlock+0xa4>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
8004564: 45 8d 00 0b be r12,r13,8004590 <pthread_rwlock_timedwrlock+0xbc><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
8004568: 35 8c ff ff addi r12,r12,-1
800456c: 34 01 00 01 mvi r1,1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
8004570: 34 0b 00 74 mvi r11,116
_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 ||
8004574: 50 2c 00 07 bgeu r1,r12,8004590 <pthread_rwlock_timedwrlock+0xbc><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
8004578: 78 01 08 01 mvhi r1,0x801
800457c: 38 21 8d 84 ori r1,r1,0x8d84
8004580: 28 21 00 0c lw r1,(r1+12)
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
8004584: 28 21 00 34 lw r1,(r1+52)
8004588: f8 00 00 0b calli 80045b4 <_POSIX_RWLock_Translate_core_RWLock_return_code>
800458c: b8 20 58 00 mv r11,r1
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
8004590: b9 60 08 00 mv r1,r11
8004594: 2b 9d 00 04 lw ra,(sp+4)
8004598: 2b 8b 00 18 lw r11,(sp+24)
800459c: 2b 8c 00 14 lw r12,(sp+20)
80045a0: 2b 8d 00 10 lw r13,(sp+16)
80045a4: 2b 8e 00 0c lw r14,(sp+12)
80045a8: 2b 8f 00 08 lw r15,(sp+8)
80045ac: 37 9c 00 20 addi sp,sp,32
80045b0: c3 a0 00 00 ret
08004ed8 <pthread_rwlockattr_setpshared>:
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
return EINVAL;
8004ed8: 34 03 00 16 mvi r3,22
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
8004edc: 44 20 00 07 be r1,r0,8004ef8 <pthread_rwlockattr_setpshared+0x20>
return EINVAL;
if ( !attr->is_initialized )
8004ee0: 28 24 00 00 lw r4,(r1+0)
8004ee4: 44 80 00 05 be r4,r0,8004ef8 <pthread_rwlockattr_setpshared+0x20>
return EINVAL;
switch ( pshared ) {
8004ee8: 34 04 00 01 mvi r4,1
8004eec: 54 44 00 03 bgu r2,r4,8004ef8 <pthread_rwlockattr_setpshared+0x20><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
8004ef0: 58 22 00 04 sw (r1+4),r2
return 0;
8004ef4: 34 03 00 00 mvi r3,0
default:
return EINVAL;
}
}
8004ef8: b8 60 08 00 mv r1,r3
8004efc: c3 a0 00 00 ret
08006144 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
8006144: 37 9c ff dc addi sp,sp,-36
8006148: 5b 8b 00 18 sw (sp+24),r11
800614c: 5b 8c 00 14 sw (sp+20),r12
8006150: 5b 8d 00 10 sw (sp+16),r13
8006154: 5b 8e 00 0c sw (sp+12),r14
8006158: 5b 8f 00 08 sw (sp+8),r15
800615c: 5b 9d 00 04 sw (sp+4),ra
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
8006160: 34 0e 00 16 mvi r14,22
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
8006164: b8 20 58 00 mv r11,r1
8006168: b8 40 78 00 mv r15,r2
800616c: b8 60 60 00 mv r12,r3
int rc;
/*
* Check all the parameters
*/
if ( !param )
8006170: 44 60 00 43 be r3,r0,800627c <pthread_setschedparam+0x138> <== NEVER TAKEN
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
8006174: b8 40 08 00 mv r1,r2
8006178: 37 84 00 20 addi r4,sp,32
800617c: b8 60 10 00 mv r2,r3
8006180: 37 83 00 24 addi r3,sp,36
8006184: f8 00 1a 85 calli 800cb98 <_POSIX_Thread_Translate_sched_param>
8006188: b8 20 70 00 mv r14,r1
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
800618c: 5c 20 00 3c bne r1,r0,800627c <pthread_setschedparam+0x138><== NEVER TAKEN
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
8006190: b9 60 08 00 mv r1,r11
8006194: 37 82 00 1c addi r2,sp,28
8006198: f8 00 0b 77 calli 8008f74 <_Thread_Get>
800619c: b8 20 68 00 mv r13,r1
switch ( location ) {
80061a0: 2b 81 00 1c lw r1,(sp+28)
80061a4: 5c 2e 00 35 bne r1,r14,8006278 <pthread_setschedparam+0x134><== NEVER TAKEN
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
80061a8: 29 ab 01 20 lw r11,(r13+288)
if ( api->schedpolicy == SCHED_SPORADIC )
80061ac: 34 01 00 04 mvi r1,4
80061b0: 29 62 00 84 lw r2,(r11+132)
80061b4: 5c 41 00 03 bne r2,r1,80061c0 <pthread_setschedparam+0x7c>
(void) _Watchdog_Remove( &api->Sporadic_timer );
80061b8: 35 61 00 a8 addi r1,r11,168
80061bc: f8 00 10 d4 calli 800a50c <_Watchdog_Remove>
api->schedpolicy = policy;
80061c0: 59 6f 00 84 sw (r11+132),r15
api->schedparam = *param;
80061c4: 29 81 00 14 lw r1,(r12+20)
80061c8: 29 82 00 00 lw r2,(r12+0)
80061cc: 29 86 00 04 lw r6,(r12+4)
80061d0: 29 85 00 08 lw r5,(r12+8)
80061d4: 29 84 00 0c lw r4,(r12+12)
80061d8: 29 83 00 10 lw r3,(r12+16)
80061dc: 29 87 00 18 lw r7,(r12+24)
80061e0: 59 61 00 9c sw (r11+156),r1
the_thread->budget_algorithm = budget_algorithm;
80061e4: 2b 81 00 24 lw r1,(sp+36)
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
80061e8: 59 62 00 88 sw (r11+136),r2
80061ec: 59 66 00 8c sw (r11+140),r6
80061f0: 59 65 00 90 sw (r11+144),r5
80061f4: 59 64 00 94 sw (r11+148),r4
80061f8: 59 63 00 98 sw (r11+152),r3
80061fc: 59 67 00 a0 sw (r11+160),r7
the_thread->budget_algorithm = budget_algorithm;
8006200: 59 a1 00 7c sw (r13+124),r1
the_thread->budget_callout = budget_callout;
8006204: 2b 81 00 20 lw r1,(sp+32)
8006208: 59 a1 00 80 sw (r13+128),r1
switch ( api->schedpolicy ) {
800620c: 48 0f 00 19 bg r0,r15,8006270 <pthread_setschedparam+0x12c><== NEVER TAKEN
8006210: 34 01 00 02 mvi r1,2
8006214: 4c 2f 00 04 bge r1,r15,8006224 <pthread_setschedparam+0xe0>
8006218: 34 01 00 04 mvi r1,4
800621c: 5d e1 00 15 bne r15,r1,8006270 <pthread_setschedparam+0x12c><== NEVER TAKEN
8006220: e0 00 00 0e bi 8006258 <pthread_setschedparam+0x114>
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
8006224: 78 01 08 01 mvhi r1,0x801
8006228: 38 21 a8 c0 ori r1,r1,0xa8c0
800622c: 28 21 00 00 lw r1,(r1+0)
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
8006230: 34 03 00 01 mvi r3,1
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
8006234: 59 a1 00 78 sw (r13+120),r1
8006238: 78 01 08 01 mvhi r1,0x801
800623c: 38 21 a1 14 ori r1,r1,0xa114
8006240: 40 21 00 00 lbu r1,(r1+0)
8006244: c8 22 10 00 sub r2,r1,r2
the_thread->real_priority =
8006248: 59 a2 00 18 sw (r13+24),r2
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
800624c: b9 a0 08 00 mv r1,r13
8006250: f8 00 0a 22 calli 8008ad8 <_Thread_Change_priority>
the_thread,
the_thread->real_priority,
true
);
break;
8006254: e0 00 00 07 bi 8006270 <pthread_setschedparam+0x12c>
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
8006258: 59 62 00 a4 sw (r11+164),r2
_Watchdog_Remove( &api->Sporadic_timer );
800625c: 35 61 00 a8 addi r1,r11,168
8006260: f8 00 10 ab calli 800a50c <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
8006264: 34 01 00 00 mvi r1,0
8006268: b9 a0 10 00 mv r2,r13
800626c: fb ff ff 65 calli 8006000 <_POSIX_Threads_Sporadic_budget_TSR>
break;
}
_Thread_Enable_dispatch();
8006270: f8 00 0b 34 calli 8008f40 <_Thread_Enable_dispatch>
return 0;
8006274: e0 00 00 02 bi 800627c <pthread_setschedparam+0x138>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
8006278: 34 0e 00 03 mvi r14,3
}
800627c: b9 c0 08 00 mv r1,r14
8006280: 2b 9d 00 04 lw ra,(sp+4)
8006284: 2b 8b 00 18 lw r11,(sp+24)
8006288: 2b 8c 00 14 lw r12,(sp+20)
800628c: 2b 8d 00 10 lw r13,(sp+16)
8006290: 2b 8e 00 0c lw r14,(sp+12)
8006294: 2b 8f 00 08 lw r15,(sp+8)
8006298: 37 9c 00 24 addi sp,sp,36
800629c: c3 a0 00 00 ret
080035e8 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
80035e8: 37 9c ff f8 addi sp,sp,-8
80035ec: 5b 8b 00 08 sw (sp+8),r11
80035f0: 5b 9d 00 04 sw (sp+4),ra
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
80035f4: 78 01 08 01 mvhi r1,0x801
80035f8: 38 21 6d 6c ori r1,r1,0x6d6c
80035fc: 28 22 00 08 lw r2,(r1+8)
8003600: 5c 40 00 14 bne r2,r0,8003650 <pthread_testcancel+0x68> <== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
8003604: 28 21 00 0c lw r1,(r1+12)
8003608: 28 22 01 20 lw r2,(r1+288)
800360c: 78 01 08 01 mvhi r1,0x801
8003610: 38 21 68 c0 ori r1,r1,0x68c0
8003614: 28 23 00 00 lw r3,(r1+0)
8003618: 34 63 00 01 addi r3,r3,1
800361c: 58 23 00 00 sw (r1+0),r3
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
8003620: 28 41 00 d8 lw r1,(r2+216)
*/
void pthread_testcancel( void )
{
POSIX_API_Control *thread_support;
bool cancel = false;
8003624: 34 0b 00 00 mvi r11,0
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
8003628: 5c 2b 00 03 bne r1,r11,8003634 <pthread_testcancel+0x4c> <== NEVER TAKEN
/* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */
int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate));
int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype));
void _EXFUN(pthread_testcancel, (void));
800362c: 28 4b 00 e0 lw r11,(r2+224)
8003630: 7d 6b 00 00 cmpnei r11,r11,0
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
8003634: f8 00 0a 62 calli 8005fbc <_Thread_Enable_dispatch>
if ( cancel )
8003638: 45 60 00 06 be r11,r0,8003650 <pthread_testcancel+0x68>
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
800363c: 78 01 08 01 mvhi r1,0x801
8003640: 38 21 6d 6c ori r1,r1,0x6d6c
8003644: 28 21 00 0c lw r1,(r1+12)
8003648: 34 02 ff ff mvi r2,-1
800364c: f8 00 19 78 calli 8009c2c <_POSIX_Thread_Exit>
}
8003650: 2b 9d 00 04 lw ra,(sp+4)
8003654: 2b 8b 00 08 lw r11,(sp+8)
8003658: 37 9c 00 08 addi sp,sp,8
800365c: c3 a0 00 00 ret
080176b4 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
80176b4: 37 9c ff ec addi sp,sp,-20
80176b8: 5b 8b 00 10 sw (sp+16),r11
80176bc: 5b 8c 00 0c sw (sp+12),r12
80176c0: 5b 8d 00 08 sw (sp+8),r13
80176c4: 5b 9d 00 04 sw (sp+4),ra
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
80176c8: 78 04 08 01 mvhi r4,0x801
80176cc: 38 84 90 10 ori r4,r4,0x9010
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
80176d0: b8 40 68 00 mv r13,r2
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
80176d4: 28 82 00 00 lw r2,(r4+0)
80176d8: 54 41 00 02 bgu r2,r1,80176e0 <read+0x2c> <== ALWAYS TAKEN
80176dc: e0 00 00 0c bi 801770c <read+0x58> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
80176e0: 78 0b 08 01 mvhi r11,0x801
80176e4: 34 02 00 06 mvi r2,6
80176e8: 39 6b 98 58 ori r11,r11,0x9858
80176ec: 5b 83 00 14 sw (sp+20),r3
80176f0: fb ff fe 08 calli 8016f10 <__ashlsi3>
80176f4: 29 6b 00 00 lw r11,(r11+0)
rtems_libio_check_is_open( iop );
80176f8: 2b 83 00 14 lw r3,(sp+20)
{
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
80176fc: b5 61 58 00 add r11,r11,r1
rtems_libio_check_is_open( iop );
8017700: 29 61 00 18 lw r1,(r11+24)
8017704: 20 22 01 00 andi r2,r1,0x100
8017708: 5c 40 00 04 bne r2,r0,8017718 <read+0x64>
801770c: fb ff e7 59 calli 8011470 <__errno>
8017710: 34 02 00 09 mvi r2,9
8017714: e0 00 00 08 bi 8017734 <read+0x80>
rtems_libio_check_buffer( buffer );
8017718: 45 a0 00 05 be r13,r0,801772c <read+0x78> <== NEVER TAKEN
rtems_libio_check_count( count );
801771c: 34 0c 00 00 mvi r12,0
8017720: 44 60 00 19 be r3,r0,8017784 <read+0xd0>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
8017724: 20 21 00 02 andi r1,r1,0x2
8017728: 5c 20 00 06 bne r1,r0,8017740 <read+0x8c>
801772c: fb ff e7 51 calli 8011470 <__errno>
8017730: 34 02 00 16 mvi r2,22
8017734: 58 22 00 00 sw (r1+0),r2
8017738: 34 0c ff ff mvi r12,-1
801773c: e0 00 00 12 bi 8017784 <read+0xd0>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
8017740: 29 61 00 24 lw r1,(r11+36)
8017744: b9 a0 10 00 mv r2,r13
8017748: 28 24 00 08 lw r4,(r1+8)
801774c: b9 60 08 00 mv r1,r11
8017750: d8 80 00 00 call r4
8017754: b8 20 60 00 mv r12,r1
if ( rc > 0 )
8017758: 4c 01 00 0b bge r0,r1,8017784 <read+0xd0>
iop->offset += rc;
801775c: 34 02 00 1f mvi r2,31
8017760: fb ff fe 13 calli 8016fac <__ashrsi3>
8017764: 29 62 00 14 lw r2,(r11+20)
8017768: 29 64 00 10 lw r4,(r11+16)
801776c: b5 82 10 00 add r2,r12,r2
8017770: f5 82 18 00 cmpgu r3,r12,r2
8017774: b4 24 08 00 add r1,r1,r4
8017778: b4 61 08 00 add r1,r3,r1
801777c: 59 61 00 10 sw (r11+16),r1
8017780: 59 62 00 14 sw (r11+20),r2
return rc;
}
8017784: b9 80 08 00 mv r1,r12
8017788: 2b 9d 00 04 lw ra,(sp+4)
801778c: 2b 8b 00 10 lw r11,(sp+16)
8017790: 2b 8c 00 0c lw r12,(sp+12)
8017794: 2b 8d 00 08 lw r13,(sp+8)
8017798: 37 9c 00 14 addi sp,sp,20
801779c: c3 a0 00 00 ret
08004dc4 <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
8004dc4: 37 9c ff d8 addi sp,sp,-40
8004dc8: 5b 8b 00 14 sw (sp+20),r11
8004dcc: 5b 8c 00 10 sw (sp+16),r12
8004dd0: 5b 8d 00 0c sw (sp+12),r13
8004dd4: 5b 8e 00 08 sw (sp+8),r14
8004dd8: 5b 9d 00 04 sw (sp+4),ra
8004ddc: b8 20 60 00 mv r12,r1
8004de0: b8 40 68 00 mv r13,r2
8004de4: b8 60 70 00 mv r14,r3
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
8004de8: 5c 40 00 06 bne r2,r0,8004e00 <readlink+0x3c>
rtems_set_errno_and_return_minus_one( EFAULT );
8004dec: f8 00 2b 78 calli 800fbcc <__errno>
8004df0: 34 02 00 0e mvi r2,14
8004df4: 58 22 00 00 sw (r1+0),r2
8004df8: 34 0c ff ff mvi r12,-1
8004dfc: e0 00 00 20 bi 8004e7c <readlink+0xb8>
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
8004e00: f8 00 33 24 calli 8011a90 <strlen>
8004e04: 37 8b 00 18 addi r11,sp,24
8004e08: b8 20 10 00 mv r2,r1
8004e0c: 34 03 00 00 mvi r3,0
8004e10: b9 80 08 00 mv r1,r12
8004e14: b9 60 20 00 mv r4,r11
8004e18: 34 05 00 00 mvi r5,0
8004e1c: fb ff fa dd calli 8003990 <rtems_filesystem_evaluate_path>
0, &loc, false );
if ( result != 0 )
return -1;
8004e20: 34 0c ff ff mvi r12,-1
if (!buf)
rtems_set_errno_and_return_minus_one( EFAULT );
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
0, &loc, false );
if ( result != 0 )
8004e24: 5c 20 00 16 bne r1,r0,8004e7c <readlink+0xb8> <== NEVER TAKEN
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
8004e28: 2b 81 00 24 lw r1,(sp+36)
8004e2c: 28 22 00 10 lw r2,(r1+16)
8004e30: b9 60 08 00 mv r1,r11
8004e34: d8 40 00 00 call r2
8004e38: 34 02 00 04 mvi r2,4
8004e3c: 44 22 00 07 be r1,r2,8004e58 <readlink+0x94>
rtems_filesystem_freenode( &loc );
8004e40: b9 60 08 00 mv r1,r11
8004e44: fb ff fb 1b calli 8003ab0 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EINVAL );
8004e48: f8 00 2b 61 calli 800fbcc <__errno>
8004e4c: 34 02 00 16 mvi r2,22
8004e50: 58 22 00 00 sw (r1+0),r2
8004e54: e0 00 00 0a bi 8004e7c <readlink+0xb8>
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
8004e58: 2b 81 00 24 lw r1,(sp+36)
8004e5c: b9 a0 10 00 mv r2,r13
8004e60: b9 c0 18 00 mv r3,r14
8004e64: 28 24 00 3c lw r4,(r1+60)
8004e68: b9 60 08 00 mv r1,r11
8004e6c: d8 80 00 00 call r4
8004e70: b8 20 60 00 mv r12,r1
rtems_filesystem_freenode( &loc );
8004e74: b9 60 08 00 mv r1,r11
8004e78: fb ff fb 0e calli 8003ab0 <rtems_filesystem_freenode>
return result;
}
8004e7c: b9 80 08 00 mv r1,r12
8004e80: 2b 9d 00 04 lw ra,(sp+4)
8004e84: 2b 8b 00 14 lw r11,(sp+20)
8004e88: 2b 8c 00 10 lw r12,(sp+16)
8004e8c: 2b 8d 00 0c lw r13,(sp+12)
8004e90: 2b 8e 00 08 lw r14,(sp+8)
8004e94: 37 9c 00 28 addi sp,sp,40
8004e98: c3 a0 00 00 ret
08003688 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
8003688: 37 9c ff e4 addi sp,sp,-28
800368c: 5b 8b 00 1c sw (sp+28),r11
8003690: 5b 8c 00 18 sw (sp+24),r12
8003694: 5b 8d 00 14 sw (sp+20),r13
8003698: 5b 8e 00 10 sw (sp+16),r14
800369c: 5b 8f 00 0c sw (sp+12),r15
80036a0: 5b 90 00 08 sw (sp+8),r16
80036a4: 5b 9d 00 04 sw (sp+4),ra
80036a8: b8 60 78 00 mv r15,r3
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
80036ac: 78 03 08 01 mvhi r3,0x801
80036b0: 38 63 60 10 ori r3,r3,0x6010
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
80036b4: b8 40 68 00 mv r13,r2
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
80036b8: 28 62 00 00 lw r2,(r3+0)
80036bc: 54 41 00 02 bgu r2,r1,80036c4 <readv+0x3c>
80036c0: e0 00 00 0a bi 80036e8 <readv+0x60>
iop = rtems_libio_iop( fd );
80036c4: 78 0b 08 01 mvhi r11,0x801
80036c8: 34 02 00 06 mvi r2,6
80036cc: 39 6b 67 8c ori r11,r11,0x678c
80036d0: f8 00 3d ff calli 8012ecc <__ashlsi3>
80036d4: 29 6c 00 00 lw r12,(r11+0)
80036d8: b5 81 60 00 add r12,r12,r1
rtems_libio_check_is_open( iop );
80036dc: 29 81 00 18 lw r1,(r12+24)
80036e0: 20 22 01 00 andi r2,r1,0x100
80036e4: 5c 40 00 04 bne r2,r0,80036f4 <readv+0x6c>
80036e8: f8 00 28 0c calli 800d718 <__errno>
80036ec: 34 02 00 09 mvi r2,9
80036f0: e0 00 00 16 bi 8003748 <readv+0xc0>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
80036f4: 20 21 00 02 andi r1,r1,0x2
80036f8: 44 20 00 12 be r1,r0,8003740 <readv+0xb8> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
80036fc: 45 a0 00 11 be r13,r0,8003740 <readv+0xb8>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
8003700: 49 e0 00 02 bg r15,r0,8003708 <readv+0x80>
8003704: e0 00 00 0f bi 8003740 <readv+0xb8>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
8003708: 34 01 04 00 mvi r1,1024
800370c: 4c 2f 00 02 bge r1,r15,8003714 <readv+0x8c> <== ALWAYS TAKEN
8003710: e0 00 00 0c bi 8003740 <readv+0xb8> <== NOT EXECUTED
8003714: b9 a0 08 00 mv r1,r13
8003718: 34 02 00 01 mvi r2,1
800371c: 34 04 00 00 mvi r4,0
8003720: 34 03 00 00 mvi r3,0
8003724: e0 00 00 02 bi 800372c <readv+0xa4>
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
8003728: b8 c0 18 00 mv r3,r6
/*
* 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 )
800372c: 28 25 00 00 lw r5,(r1+0)
8003730: 44 a0 00 04 be r5,r0,8003740 <readv+0xb8>
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
8003734: 28 25 00 04 lw r5,(r1+4)
8003738: b4 65 30 00 add r6,r3,r5
if ( total < old )
800373c: 4c c3 00 05 bge r6,r3,8003750 <readv+0xc8>
rtems_set_errno_and_return_minus_one( EINVAL );
8003740: f8 00 27 f6 calli 800d718 <__errno>
8003744: 34 02 00 16 mvi r2,22
8003748: 58 22 00 00 sw (r1+0),r2
800374c: e0 00 00 24 bi 80037dc <readv+0x154>
if ( iov[v].iov_len )
all_zeros = false;
8003750: 64 a5 00 00 cmpei r5,r5,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++ ) {
8003754: 34 84 00 01 addi r4,r4,1
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
8003758: c8 05 28 00 sub r5,r0,r5
800375c: a0 45 10 00 and r2,r2,r5
* 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++ ) {
8003760: 34 21 00 08 addi r1,r1,8
8003764: 49 e4 ff f1 bg r15,r4,8003728 <readv+0xa0>
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
return 0;
8003768: 34 0b 00 00 mvi r11,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 ) {
800376c: 5c 40 00 1d bne r2,r0,80037e0 <readv+0x158>
8003770: 34 10 00 00 mvi r16,0
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
8003774: 29 81 00 24 lw r1,(r12+36)
8003778: 29 a2 00 00 lw r2,(r13+0)
800377c: 29 a3 00 04 lw r3,(r13+4)
8003780: 28 24 00 08 lw r4,(r1+8)
8003784: b9 80 08 00 mv r1,r12
8003788: d8 80 00 00 call r4
800378c: b8 20 70 00 mv r14,r1
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
8003790: 48 01 00 13 bg r0,r1,80037dc <readv+0x154> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
8003794: 44 20 00 0c be r1,r0,80037c4 <readv+0x13c> <== NEVER TAKEN
iop->offset += bytes;
8003798: 34 02 00 1f mvi r2,31
800379c: f8 00 3d f3 calli 8012f68 <__ashrsi3>
80037a0: 29 82 00 14 lw r2,(r12+20)
80037a4: 29 84 00 10 lw r4,(r12+16)
total += bytes;
80037a8: b5 6e 58 00 add r11,r11,r14
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
iop->offset += bytes;
80037ac: b5 c2 10 00 add r2,r14,r2
80037b0: f5 c2 18 00 cmpgu r3,r14,r2
80037b4: b4 24 08 00 add r1,r1,r4
80037b8: b4 61 08 00 add r1,r3,r1
80037bc: 59 81 00 10 sw (r12+16),r1
80037c0: 59 82 00 14 sw (r12+20),r2
total += bytes;
}
if (bytes != iov[ v ].iov_len)
80037c4: 29 a1 00 04 lw r1,(r13+4)
80037c8: 5d c1 00 06 bne r14,r1,80037e0 <readv+0x158> <== NEVER TAKEN
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
80037cc: 36 10 00 01 addi r16,r16,1
80037d0: 35 ad 00 08 addi r13,r13,8
80037d4: 49 f0 ff e8 bg r15,r16,8003774 <readv+0xec>
80037d8: e0 00 00 02 bi 80037e0 <readv+0x158>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
80037dc: 34 0b ff ff mvi r11,-1
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
80037e0: b9 60 08 00 mv r1,r11
80037e4: 2b 9d 00 04 lw ra,(sp+4)
80037e8: 2b 8b 00 1c lw r11,(sp+28)
80037ec: 2b 8c 00 18 lw r12,(sp+24)
80037f0: 2b 8d 00 14 lw r13,(sp+20)
80037f4: 2b 8e 00 10 lw r14,(sp+16)
80037f8: 2b 8f 00 0c lw r15,(sp+12)
80037fc: 2b 90 00 08 lw r16,(sp+8)
8003800: 37 9c 00 1c addi sp,sp,28
8003804: c3 a0 00 00 ret
080036b8 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
80036b8: 37 9c ff e8 addi sp,sp,-24
80036bc: 5b 8b 00 14 sw (sp+20),r11
80036c0: 5b 8c 00 10 sw (sp+16),r12
80036c4: 5b 8d 00 0c sw (sp+12),r13
80036c8: 5b 8e 00 08 sw (sp+8),r14
80036cc: 5b 9d 00 04 sw (sp+4),ra
80036d0: b8 20 58 00 mv r11,r1
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
80036d4: 78 01 08 01 mvhi r1,0x801
80036d8: 38 21 98 70 ori r1,r1,0x9870
void *realloc(
void *ptr,
size_t size
)
{
80036dc: b8 40 60 00 mv r12,r2
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
80036e0: 28 22 00 10 lw r2,(r1+16)
80036e4: 34 42 00 01 addi r2,r2,1
80036e8: 58 22 00 10 sw (r1+16),r2
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
80036ec: 78 01 08 01 mvhi r1,0x801
80036f0: 38 21 9a e8 ori r1,r1,0x9ae8
80036f4: 28 22 00 00 lw r2,(r1+0)
80036f8: 34 01 00 03 mvi r1,3
80036fc: 5c 41 00 09 bne r2,r1,8003720 <realloc+0x68> <== NEVER TAKEN
if (_Thread_Dispatch_disable_level > 0)
8003700: 78 01 08 01 mvhi r1,0x801
8003704: 38 21 99 90 ori r1,r1,0x9990
8003708: 28 22 00 00 lw r2,(r1+0)
800370c: 5c 40 00 33 bne r2,r0,80037d8 <realloc+0x120> <== NEVER TAKEN
return (void *) 0;
if (_ISR_Nest_level > 0)
8003710: 78 01 08 01 mvhi r1,0x801
8003714: 38 21 9e 3c ori r1,r1,0x9e3c
8003718: 28 21 00 08 lw r1,(r1+8)
800371c: 5c 22 00 2f bne r1,r2,80037d8 <realloc+0x120> <== NEVER TAKEN
}
/*
* Continue with realloc().
*/
if ( !ptr )
8003720: 5d 60 00 05 bne r11,r0,8003734 <realloc+0x7c>
return malloc( size );
8003724: b9 80 08 00 mv r1,r12
8003728: fb ff fc e1 calli 8002aac <malloc>
800372c: b8 20 58 00 mv r11,r1
8003730: e0 00 00 2b bi 80037dc <realloc+0x124>
if ( !size ) {
8003734: 5d 80 00 04 bne r12,r0,8003744 <realloc+0x8c> <== ALWAYS TAKEN
free( ptr );
8003738: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
800373c: fb ff fb e2 calli 80026c4 <free> <== NOT EXECUTED
8003740: e0 00 00 26 bi 80037d8 <realloc+0x120> <== NOT EXECUTED
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
8003744: 78 0d 08 01 mvhi r13,0x801
8003748: 39 ad 90 4c ori r13,r13,0x904c
800374c: 29 a1 00 00 lw r1,(r13+0)
8003750: b9 60 10 00 mv r2,r11
8003754: 37 83 00 18 addi r3,sp,24
8003758: f8 00 0a 24 calli 8005fe8 <_Protected_heap_Get_block_size>
800375c: 5c 20 00 05 bne r1,r0,8003770 <realloc+0xb8>
errno = EINVAL;
8003760: f8 00 37 44 calli 8011470 <__errno>
8003764: 34 02 00 16 mvi r2,22
8003768: 58 22 00 00 sw (r1+0),r2
800376c: e0 00 00 1b bi 80037d8 <realloc+0x120>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
8003770: 29 a1 00 00 lw r1,(r13+0)
8003774: b9 60 10 00 mv r2,r11
8003778: b9 80 18 00 mv r3,r12
800377c: f8 00 0a 35 calli 8006050 <_Protected_heap_Resize_block>
8003780: b8 20 70 00 mv r14,r1
8003784: 5c 20 00 16 bne r1,r0,80037dc <realloc+0x124>
* 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 );
8003788: b9 80 08 00 mv r1,r12
800378c: fb ff fc c8 calli 8002aac <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
8003790: 78 02 08 01 mvhi r2,0x801
8003794: 38 42 98 70 ori r2,r2,0x9870
* 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 );
8003798: b8 20 68 00 mv r13,r1
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
800379c: 28 41 00 04 lw r1,(r2+4)
80037a0: 34 21 ff ff addi r1,r1,-1
80037a4: 58 41 00 04 sw (r2+4),r1
if ( !new_area ) {
80037a8: 45 ae 00 0c be r13,r14,80037d8 <realloc+0x120>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
80037ac: 2b 81 00 18 lw r1,(sp+24)
80037b0: b9 80 18 00 mv r3,r12
80037b4: 50 2c 00 02 bgeu r1,r12,80037bc <realloc+0x104> <== NEVER TAKEN
80037b8: b8 20 18 00 mv r3,r1
80037bc: b9 60 10 00 mv r2,r11
80037c0: b9 a0 08 00 mv r1,r13
80037c4: f8 00 39 e1 calli 8011f48 <memcpy>
free( ptr );
80037c8: b9 60 08 00 mv r1,r11
80037cc: fb ff fb be calli 80026c4 <free>
return new_area;
80037d0: b9 a0 58 00 mv r11,r13
80037d4: e0 00 00 02 bi 80037dc <realloc+0x124>
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
80037d8: 34 0b 00 00 mvi r11,0
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
80037dc: b9 60 08 00 mv r1,r11
80037e0: 2b 9d 00 04 lw ra,(sp+4)
80037e4: 2b 8b 00 14 lw r11,(sp+20)
80037e8: 2b 8c 00 10 lw r12,(sp+16)
80037ec: 2b 8d 00 0c lw r13,(sp+12)
80037f0: 2b 8e 00 08 lw r14,(sp+8)
80037f4: 37 9c 00 18 addi sp,sp,24
80037f8: c3 a0 00 00 ret
08002848 <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
8002848: 37 9c ff c0 addi sp,sp,-64
800284c: 5b 8b 00 14 sw (sp+20),r11
8002850: 5b 8c 00 10 sw (sp+16),r12
8002854: 5b 8d 00 0c sw (sp+12),r13
8002858: 5b 8e 00 08 sw (sp+8),r14
800285c: 5b 9d 00 04 sw (sp+4),ra
8002860: b8 20 70 00 mv r14,r1
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
8002864: fb ff fb c7 calli 8001780 <rtems_filesystem_dirname>
8002868: b8 20 58 00 mv r11,r1
800286c: 37 84 00 2c addi r4,sp,44
if ( parentpathlen == 0 )
8002870: 5c 20 00 07 bne r1,r0,800288c <rmdir+0x44>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
8002874: b9 c0 08 00 mv r1,r14
8002878: 37 82 00 40 addi r2,sp,64
800287c: b8 80 18 00 mv r3,r4
8002880: f8 00 00 4e calli 80029b8 <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;
8002884: 34 0d 00 00 mvi r13,0
8002888: e0 00 00 09 bi 80028ac <rmdir+0x64>
parentpathlen = rtems_filesystem_dirname ( pathname );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
800288c: b9 c0 08 00 mv r1,r14
8002890: b9 60 10 00 mv r2,r11
8002894: 34 03 00 02 mvi r3,2
8002898: 34 05 00 00 mvi r5,0
800289c: fb ff fb 9e calli 8001714 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
return -1;
80028a0: 34 0c ff ff mvi r12,-1
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
80028a4: 5c 20 00 3d bne r1,r0,8002998 <rmdir+0x150> <== NEVER TAKEN
return -1;
free_parentloc = true;
80028a8: 34 0d 00 01 mvi r13,1
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
80028ac: 2b 81 00 2c lw r1,(sp+44)
name = pathname + parentpathlen;
80028b0: b5 cb 58 00 add r11,r14,r11
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
80028b4: 5b 81 00 18 sw (sp+24),r1
80028b8: 2b 81 00 30 lw r1,(sp+48)
80028bc: 5b 81 00 1c sw (sp+28),r1
80028c0: 2b 81 00 34 lw r1,(sp+52)
80028c4: 5b 81 00 20 sw (sp+32),r1
80028c8: 2b 81 00 38 lw r1,(sp+56)
80028cc: 5b 81 00 24 sw (sp+36),r1
80028d0: 2b 81 00 3c lw r1,(sp+60)
80028d4: 5b 81 00 28 sw (sp+40),r1
name = pathname + parentpathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
80028d8: b9 60 08 00 mv r1,r11
80028dc: f8 00 2d f3 calli 800e0a8 <strlen>
80028e0: b8 20 10 00 mv r2,r1
80028e4: b9 60 08 00 mv r1,r11
80028e8: fb ff fb ba calli 80017d0 <rtems_filesystem_prefix_separators>
80028ec: b5 61 60 00 add r12,r11,r1
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
80028f0: b9 80 08 00 mv r1,r12
80028f4: f8 00 2d ed calli 800e0a8 <strlen>
80028f8: 37 8b 00 18 addi r11,sp,24
80028fc: b8 20 10 00 mv r2,r1
8002900: 34 03 00 00 mvi r3,0
8002904: b9 80 08 00 mv r1,r12
8002908: b9 60 20 00 mv r4,r11
800290c: 34 05 00 00 mvi r5,0
8002910: fb ff fb 5f calli 800168c <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
8002914: 44 20 00 05 be r1,r0,8002928 <rmdir+0xe0>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
8002918: 34 0c ff ff mvi r12,-1
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
800291c: 37 81 00 2c addi r1,sp,44
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 )
8002920: 45 a0 00 1e be r13,r0,8002998 <rmdir+0x150>
8002924: e0 00 00 1c bi 8002994 <rmdir+0x14c>
}
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
8002928: 2b 81 00 24 lw r1,(sp+36)
800292c: 28 22 00 10 lw r2,(r1+16)
8002930: b9 60 08 00 mv r1,r11
8002934: d8 40 00 00 call r2
8002938: 34 02 00 01 mvi r2,1
800293c: 44 22 00 0b be r1,r2,8002968 <rmdir+0x120>
rtems_filesystem_freenode( &loc );
8002940: b9 60 08 00 mv r1,r11
8002944: fb ff fb bc calli 8001834 <rtems_filesystem_freenode>
if ( free_parentloc )
8002948: 45 a0 00 03 be r13,r0,8002954 <rmdir+0x10c> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
800294c: 37 81 00 2c addi r1,sp,44
8002950: fb ff fb b9 calli 8001834 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( ENOTDIR );
8002954: f8 00 29 74 calli 800cf24 <__errno>
8002958: 34 02 00 14 mvi r2,20
800295c: 58 22 00 00 sw (r1+0),r2
8002960: 34 0c ff ff mvi r12,-1
8002964: e0 00 00 0d bi 8002998 <rmdir+0x150>
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
8002968: 2b 81 00 20 lw r1,(sp+32)
800296c: 37 8e 00 2c addi r14,sp,44
8002970: b9 60 10 00 mv r2,r11
8002974: 28 23 00 34 lw r3,(r1+52)
8002978: b9 c0 08 00 mv r1,r14
800297c: d8 60 00 00 call r3
8002980: b8 20 60 00 mv r12,r1
rtems_filesystem_freenode( &loc );
8002984: b9 60 08 00 mv r1,r11
8002988: fb ff fb ab calli 8001834 <rtems_filesystem_freenode>
if ( free_parentloc )
800298c: 45 a0 00 03 be r13,r0,8002998 <rmdir+0x150>
rtems_filesystem_freenode( &parentloc );
8002990: b9 c0 08 00 mv r1,r14
8002994: fb ff fb a8 calli 8001834 <rtems_filesystem_freenode>
return result;
}
8002998: b9 80 08 00 mv r1,r12
800299c: 2b 9d 00 04 lw ra,(sp+4)
80029a0: 2b 8b 00 14 lw r11,(sp+20)
80029a4: 2b 8c 00 10 lw r12,(sp+16)
80029a8: 2b 8d 00 0c lw r13,(sp+12)
80029ac: 2b 8e 00 08 lw r14,(sp+8)
80029b0: 37 9c 00 40 addi sp,sp,64
80029b4: c3 a0 00 00 ret
08004200 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
8004200: 37 9c ff bc addi sp,sp,-68
8004204: 5b 8b 00 20 sw (sp+32),r11
8004208: 5b 8c 00 1c sw (sp+28),r12
800420c: 5b 8d 00 18 sw (sp+24),r13
8004210: 5b 8e 00 14 sw (sp+20),r14
8004214: 5b 8f 00 10 sw (sp+16),r15
8004218: 5b 90 00 0c sw (sp+12),r16
800421c: 5b 91 00 08 sw (sp+8),r17
8004220: 5b 9d 00 04 sw (sp+4),ra
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);
8004224: 78 0c 08 01 mvhi r12,0x801
8004228: 39 8c 78 68 ori r12,r12,0x7868
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
800422c: b8 20 58 00 mv r11,r1
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);
8004230: b9 80 08 00 mv r1,r12
8004234: f8 00 02 b1 calli 8004cf8 <pthread_mutex_lock>
8004238: b8 20 70 00 mv r14,r1
if (result != 0) {
800423c: 44 20 00 04 be r1,r0,800424c <rtems_aio_enqueue+0x4c> <== ALWAYS TAKEN
free (req);
8004240: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
8004244: fb ff f7 c7 calli 8002160 <free> <== NOT EXECUTED
return result;
8004248: e0 00 00 79 bi 800442c <rtems_aio_enqueue+0x22c> <== NOT EXECUTED
}
/* _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);
800424c: f8 00 05 42 calli 8005754 <pthread_self>
8004250: 37 82 00 40 addi r2,sp,64
8004254: 37 83 00 24 addi r3,sp,36
8004258: f8 00 04 04 calli 8005268 <pthread_getschedparam>
req->caller_thread = pthread_self ();
800425c: f8 00 05 3e calli 8005754 <pthread_self>
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
8004260: 29 62 00 14 lw r2,(r11+20)
/* _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 ();
8004264: 59 61 00 10 sw (r11+16),r1
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
8004268: 2b 83 00 24 lw r3,(sp+36)
800426c: 28 41 00 10 lw r1,(r2+16)
8004270: c8 61 08 00 sub r1,r3,r1
8004274: 59 61 00 0c sw (r11+12),r1
req->policy = policy;
8004278: 2b 81 00 40 lw r1,(sp+64)
800427c: 59 61 00 08 sw (r11+8),r1
req->aiocbp->error_code = EINPROGRESS;
8004280: 34 01 00 77 mvi r1,119
8004284: 58 41 00 2c sw (r2+44),r1
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
8004288: 29 81 00 68 lw r1,(r12+104)
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
800428c: 58 40 00 30 sw (r2+48),r0
if ((aio_request_queue.idle_threads == 0) &&
8004290: 5c 2e 00 34 bne r1,r14,8004360 <rtems_aio_enqueue+0x160> <== NEVER TAKEN
8004294: 29 83 00 64 lw r3,(r12+100)
8004298: 34 01 00 04 mvi r1,4
800429c: 48 61 00 31 bg r3,r1,8004360 <rtems_aio_enqueue+0x160>
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);
80042a0: 28 42 00 00 lw r2,(r2+0)
80042a4: 78 01 08 01 mvhi r1,0x801
80042a8: 38 21 78 b0 ori r1,r1,0x78b0
80042ac: 34 03 00 01 mvi r3,1
80042b0: fb ff fe 99 calli 8003d14 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
80042b4: 28 22 00 18 lw r2,(r1+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);
80042b8: b8 20 68 00 mv r13,r1
80042bc: 34 31 00 08 addi r17,r1,8
80042c0: 34 2f 00 1c addi r15,r1,28
80042c4: 34 30 00 20 addi r16,r1,32
if (r_chain->new_fd == 1) {
80042c8: 34 01 00 01 mvi r1,1
80042cc: 5c 41 00 1c bne r2,r1,800433c <rtems_aio_enqueue+0x13c>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
80042d0: b9 60 10 00 mv r2,r11
80042d4: ba 20 08 00 mv r1,r17
80042d8: f8 00 08 6f calli 8006494 <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
80042dc: 34 02 00 00 mvi r2,0
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;
80042e0: 59 a0 00 18 sw (r13+24),r0
pthread_mutex_init (&r_chain->mutex, NULL);
80042e4: b9 e0 08 00 mv r1,r15
80042e8: f8 00 02 27 calli 8004b84 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
80042ec: 34 02 00 00 mvi r2,0
80042f0: ba 00 08 00 mv r1,r16
80042f4: f8 00 01 02 calli 80046fc <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
80042f8: 78 02 08 01 mvhi r2,0x801
80042fc: 78 03 08 00 mvhi r3,0x800
8004300: 37 81 00 44 addi r1,sp,68
8004304: 38 42 78 70 ori r2,r2,0x7870
8004308: 38 63 3e 38 ori r3,r3,0x3e38
800430c: b9 a0 20 00 mv r4,r13
8004310: f8 00 03 11 calli 8004f54 <pthread_create>
8004314: b8 20 58 00 mv r11,r1
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
8004318: 44 20 00 05 be r1,r0,800432c <rtems_aio_enqueue+0x12c> <== ALWAYS TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
800431c: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
8004320: f8 00 02 a9 calli 8004dc4 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
8004324: b9 60 70 00 mv r14,r11 <== NOT EXECUTED
8004328: e0 00 00 41 bi 800442c <rtems_aio_enqueue+0x22c> <== NOT EXECUTED
}
++aio_request_queue.active_threads;
800432c: 29 81 00 64 lw r1,(r12+100)
8004330: 34 21 00 01 addi r1,r1,1
8004334: 59 81 00 64 sw (r12+100),r1
8004338: e0 00 00 3a bi 8004420 <rtems_aio_enqueue+0x220>
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
800433c: b9 e0 08 00 mv r1,r15
8004340: f8 00 02 6e calli 8004cf8 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
8004344: ba 20 08 00 mv r1,r17
8004348: b9 60 10 00 mv r2,r11
800434c: fb ff ff 5d calli 80040c0 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
8004350: ba 00 08 00 mv r1,r16
8004354: f8 00 01 25 calli 80047e8 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
8004358: b9 e0 08 00 mv r1,r15
800435c: e0 00 00 11 bi 80043a0 <rtems_aio_enqueue+0x1a0>
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,
8004360: 28 42 00 00 lw r2,(r2+0)
8004364: 78 01 08 01 mvhi r1,0x801
8004368: 38 21 78 b0 ori r1,r1,0x78b0
800436c: 34 03 00 00 mvi r3,0
8004370: fb ff fe 69 calli 8003d14 <rtems_aio_search_fd>
8004374: b8 20 60 00 mv r12,r1
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
8004378: 44 20 00 0c be r1,r0,80043a8 <rtems_aio_enqueue+0x1a8>
{
pthread_mutex_lock (&r_chain->mutex);
800437c: 34 2d 00 1c addi r13,r1,28
8004380: b9 a0 08 00 mv r1,r13
8004384: f8 00 02 5d calli 8004cf8 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
8004388: 35 81 00 08 addi r1,r12,8
800438c: b9 60 10 00 mv r2,r11
8004390: fb ff ff 4c calli 80040c0 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
8004394: 35 81 00 20 addi r1,r12,32
8004398: f8 00 01 14 calli 80047e8 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
800439c: b9 a0 08 00 mv r1,r13
80043a0: f8 00 02 89 calli 8004dc4 <pthread_mutex_unlock>
80043a4: e0 00 00 1f bi 8004420 <rtems_aio_enqueue+0x220>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
80043a8: 29 62 00 14 lw r2,(r11+20)
80043ac: 78 01 08 01 mvhi r1,0x801
80043b0: 34 03 00 01 mvi r3,1
80043b4: 28 42 00 00 lw r2,(r2+0)
80043b8: 38 21 78 bc ori r1,r1,0x78bc
80043bc: fb ff fe 56 calli 8003d14 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
80043c0: 28 23 00 18 lw r3,(r1+24)
80043c4: 34 02 00 01 mvi r2,1
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
80043c8: b8 20 60 00 mv r12,r1
80043cc: 34 21 00 08 addi r1,r1,8
if (r_chain->new_fd == 1) {
80043d0: 5c 62 00 0b bne r3,r2,80043fc <rtems_aio_enqueue+0x1fc>
80043d4: b9 60 10 00 mv r2,r11
80043d8: f8 00 08 2f calli 8006494 <_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);
80043dc: 35 81 00 1c addi r1,r12,28
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;
80043e0: 59 80 00 18 sw (r12+24),r0
pthread_mutex_init (&r_chain->mutex, NULL);
80043e4: 34 02 00 00 mvi r2,0
80043e8: f8 00 01 e7 calli 8004b84 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
80043ec: 35 81 00 20 addi r1,r12,32
80043f0: 34 02 00 00 mvi r2,0
80043f4: f8 00 00 c2 calli 80046fc <pthread_cond_init>
80043f8: e0 00 00 03 bi 8004404 <rtems_aio_enqueue+0x204>
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
80043fc: b9 60 10 00 mv r2,r11
8004400: fb ff ff 30 calli 80040c0 <rtems_aio_insert_prio>
if (aio_request_queue.idle_threads > 0)
8004404: 78 01 08 01 mvhi r1,0x801
8004408: 38 21 78 68 ori r1,r1,0x7868
800440c: 28 21 00 68 lw r1,(r1+104)
8004410: 4c 01 00 04 bge r0,r1,8004420 <rtems_aio_enqueue+0x220> <== ALWAYS TAKEN
pthread_cond_signal (&aio_request_queue.new_req);
8004414: 78 01 08 01 mvhi r1,0x801 <== NOT EXECUTED
8004418: 38 21 78 6c ori r1,r1,0x786c <== NOT EXECUTED
800441c: f8 00 00 f3 calli 80047e8 <pthread_cond_signal> <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
8004420: 78 01 08 01 mvhi r1,0x801
8004424: 38 21 78 68 ori r1,r1,0x7868
8004428: f8 00 02 67 calli 8004dc4 <pthread_mutex_unlock>
return 0;
}
800442c: b9 c0 08 00 mv r1,r14
8004430: 2b 9d 00 04 lw ra,(sp+4)
8004434: 2b 8b 00 20 lw r11,(sp+32)
8004438: 2b 8c 00 1c lw r12,(sp+28)
800443c: 2b 8d 00 18 lw r13,(sp+24)
8004440: 2b 8e 00 14 lw r14,(sp+20)
8004444: 2b 8f 00 10 lw r15,(sp+16)
8004448: 2b 90 00 0c lw r16,(sp+12)
800444c: 2b 91 00 08 lw r17,(sp+8)
8004450: 37 9c 00 44 addi sp,sp,68
8004454: c3 a0 00 00 ret
08003e38 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
8003e38: 37 9c ff a4 addi sp,sp,-92
8003e3c: 5b 8b 00 34 sw (sp+52),r11
8003e40: 5b 8c 00 30 sw (sp+48),r12
8003e44: 5b 8d 00 2c sw (sp+44),r13
8003e48: 5b 8e 00 28 sw (sp+40),r14
8003e4c: 5b 8f 00 24 sw (sp+36),r15
8003e50: 5b 90 00 20 sw (sp+32),r16
8003e54: 5b 91 00 1c sw (sp+28),r17
8003e58: 5b 92 00 18 sw (sp+24),r18
8003e5c: 5b 93 00 14 sw (sp+20),r19
8003e60: 5b 94 00 10 sw (sp+16),r20
8003e64: 5b 95 00 0c sw (sp+12),r21
8003e68: 5b 96 00 08 sw (sp+8),r22
8003e6c: 5b 9d 00 04 sw (sp+4),ra
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
8003e70: 78 0b 08 01 mvhi r11,0x801
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
8003e74: 78 11 08 01 mvhi r17,0x801
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
8003e78: 78 10 08 01 mvhi r16,0x801
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
8003e7c: b8 20 60 00 mv r12,r1
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
8003e80: 39 6b 78 68 ori r11,r11,0x7868
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
8003e84: 37 8e 00 54 addi r14,sp,84
&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) {
8003e88: 34 14 00 74 mvi r20,116
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
8003e8c: 3a 31 78 c0 ori r17,r17,0x78c0
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
8003e90: 3a 10 78 6c ori r16,r16,0x786c
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);
8003e94: 37 93 00 38 addi r19,sp,56
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
8003e98: 34 16 00 02 mvi r22,2
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
8003e9c: 34 12 ff ff mvi r18,-1
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
8003ea0: 34 15 00 03 mvi r21,3
/* 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);
8003ea4: 35 8f 00 1c addi r15,r12,28
8003ea8: b9 e0 08 00 mv r1,r15
8003eac: f8 00 03 93 calli 8004cf8 <pthread_mutex_lock>
if (result != 0)
8003eb0: 5c 20 00 74 bne r1,r0,8004080 <rtems_aio_handle+0x248> <== NEVER TAKEN
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
8003eb4: 29 8d 00 08 lw r13,(r12+8)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
8003eb8: 35 81 00 0c addi r1,r12,12
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
8003ebc: 45 a1 00 2e be r13,r1,8003f74 <rtems_aio_handle+0x13c>
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);
8003ec0: f8 00 06 25 calli 8005754 <pthread_self>
8003ec4: 37 82 00 5c addi r2,sp,92
8003ec8: ba 60 18 00 mv r3,r19
8003ecc: f8 00 04 e7 calli 8005268 <pthread_getschedparam>
param.sched_priority = req->priority;
8003ed0: 29 a1 00 0c lw r1,(r13+12)
8003ed4: 5b 81 00 38 sw (sp+56),r1
pthread_setschedparam (pthread_self(), req->policy, ¶m);
8003ed8: f8 00 06 1f calli 8005754 <pthread_self>
8003edc: 29 a2 00 08 lw r2,(r13+8)
8003ee0: ba 60 18 00 mv r3,r19
8003ee4: f8 00 06 21 calli 8005768 <pthread_setschedparam>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
8003ee8: b9 a0 08 00 mv r1,r13
8003eec: f8 00 09 51 calli 8006430 <_Chain_Extract>
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
8003ef0: b9 e0 08 00 mv r1,r15
8003ef4: f8 00 03 b4 calli 8004dc4 <pthread_mutex_unlock>
switch (req->aiocbp->aio_lio_opcode) {
8003ef8: 29 a4 00 14 lw r4,(r13+20)
8003efc: 28 81 00 28 lw r1,(r4+40)
8003f00: 44 36 00 0a be r1,r22,8003f28 <rtems_aio_handle+0xf0>
8003f04: 44 35 00 0f be r1,r21,8003f40 <rtems_aio_handle+0x108> <== NEVER TAKEN
8003f08: 34 02 00 01 mvi r2,1
8003f0c: 5c 22 00 10 bne r1,r2,8003f4c <rtems_aio_handle+0x114> <== NEVER TAKEN
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
8003f10: 28 82 00 08 lw r2,(r4+8)
8003f14: 28 83 00 0c lw r3,(r4+12)
8003f18: 28 81 00 00 lw r1,(r4+0)
8003f1c: 28 84 00 04 lw r4,(r4+4)
8003f20: f8 00 31 2a calli 80103c8 <pread>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
8003f24: e0 00 00 09 bi 8003f48 <rtems_aio_handle+0x110>
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
8003f28: 28 82 00 08 lw r2,(r4+8)
8003f2c: 28 83 00 0c lw r3,(r4+12)
8003f30: 28 81 00 00 lw r1,(r4+0)
8003f34: 28 84 00 04 lw r4,(r4+4)
8003f38: f8 00 31 68 calli 80104d8 <pwrite>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
8003f3c: e0 00 00 03 bi 8003f48 <rtems_aio_handle+0x110>
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
8003f40: 28 81 00 00 lw r1,(r4+0) <== NOT EXECUTED
8003f44: f8 00 1d 9e calli 800b5bc <fsync> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
8003f48: 5c 32 00 07 bne r1,r18,8003f64 <rtems_aio_handle+0x12c> <== ALWAYS TAKEN
req->aiocbp->return_value = -1;
8003f4c: 29 ad 00 14 lw r13,(r13+20) <== NOT EXECUTED
8003f50: 59 b2 00 30 sw (r13+48),r18 <== NOT EXECUTED
req->aiocbp->error_code = errno;
8003f54: f8 00 2d 6e calli 800f50c <__errno> <== NOT EXECUTED
8003f58: 28 21 00 00 lw r1,(r1+0) <== NOT EXECUTED
8003f5c: 59 a1 00 2c sw (r13+44),r1 <== NOT EXECUTED
8003f60: e3 ff ff d1 bi 8003ea4 <rtems_aio_handle+0x6c> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
8003f64: 29 a2 00 14 lw r2,(r13+20)
8003f68: 58 41 00 30 sw (r2+48),r1
req->aiocbp->error_code = 0;
8003f6c: 58 40 00 2c sw (r2+44),r0
8003f70: e3 ff ff cd bi 8003ea4 <rtems_aio_handle+0x6c>
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
8003f74: b9 e0 08 00 mv r1,r15
8003f78: f8 00 03 93 calli 8004dc4 <pthread_mutex_unlock>
pthread_mutex_lock (&aio_request_queue.mutex);
8003f7c: b9 60 08 00 mv r1,r11
8003f80: f8 00 03 5e calli 8004cf8 <pthread_mutex_lock>
if (rtems_chain_is_empty (chain))
8003f84: 29 81 00 08 lw r1,(r12+8)
8003f88: 5c 2d 00 3b bne r1,r13,8004074 <rtems_aio_handle+0x23c> <== NEVER TAKEN
{
clock_gettime (CLOCK_REALTIME, &timeout);
8003f8c: b9 c0 10 00 mv r2,r14
8003f90: 34 01 00 01 mvi r1,1
8003f94: f8 00 01 84 calli 80045a4 <clock_gettime>
timeout.tv_sec += 3;
8003f98: 2b 81 00 54 lw r1,(sp+84)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
8003f9c: 35 8d 00 20 addi r13,r12,32
8003fa0: b9 60 10 00 mv r2,r11
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
8003fa4: 34 21 00 03 addi r1,r1,3
8003fa8: 5b 81 00 54 sw (sp+84),r1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
8003fac: b9 c0 18 00 mv r3,r14
8003fb0: b9 a0 08 00 mv r1,r13
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
8003fb4: 5b 80 00 58 sw (sp+88),r0
result = pthread_cond_timedwait (&r_chain->cond,
8003fb8: f8 00 02 30 calli 8004878 <pthread_cond_timedwait>
&aio_request_queue.mutex,
&timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
8003fbc: 5c 34 00 2e bne r1,r20,8004074 <rtems_aio_handle+0x23c> <== NEVER TAKEN
8003fc0: b9 80 08 00 mv r1,r12
8003fc4: f8 00 09 1b calli 8006430 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
8003fc8: b9 e0 08 00 mv r1,r15
8003fcc: f8 00 02 91 calli 8004a10 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
8003fd0: b9 a0 08 00 mv r1,r13
8003fd4: f8 00 01 90 calli 8004614 <pthread_cond_destroy>
free (r_chain);
8003fd8: b9 80 08 00 mv r1,r12
8003fdc: fb ff f8 61 calli 8002160 <free>
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
8003fe0: 29 61 00 54 lw r1,(r11+84)
8003fe4: 5c 31 00 19 bne r1,r17,8004048 <rtems_aio_handle+0x210>
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
8003fe8: 29 61 00 68 lw r1,(r11+104)
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
8003fec: b9 c0 10 00 mv r2,r14
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
8003ff0: 34 21 00 01 addi r1,r1,1
8003ff4: 59 61 00 68 sw (r11+104),r1
--aio_request_queue.active_threads;
8003ff8: 29 61 00 64 lw r1,(r11+100)
8003ffc: 34 21 ff ff addi r1,r1,-1
8004000: 59 61 00 64 sw (r11+100),r1
clock_gettime (CLOCK_REALTIME, &timeout);
8004004: 34 01 00 01 mvi r1,1
8004008: f8 00 01 67 calli 80045a4 <clock_gettime>
timeout.tv_sec += 3;
800400c: 2b 81 00 54 lw r1,(sp+84)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
8004010: b9 60 10 00 mv r2,r11
8004014: b9 c0 18 00 mv r3,r14
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
8004018: 34 21 00 03 addi r1,r1,3
800401c: 5b 81 00 54 sw (sp+84),r1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
8004020: ba 00 08 00 mv r1,r16
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
8004024: 5b 80 00 58 sw (sp+88),r0
result = pthread_cond_timedwait (&aio_request_queue.new_req,
8004028: f8 00 02 14 calli 8004878 <pthread_cond_timedwait>
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
800402c: 5c 34 00 07 bne r1,r20,8004048 <rtems_aio_handle+0x210> <== NEVER TAKEN
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
8004030: 29 61 00 68 lw r1,(r11+104)
8004034: 34 21 ff ff addi r1,r1,-1
8004038: 59 61 00 68 sw (r11+104),r1
pthread_mutex_unlock (&aio_request_queue.mutex);
800403c: b9 60 08 00 mv r1,r11
8004040: f8 00 03 61 calli 8004dc4 <pthread_mutex_unlock>
return NULL;
8004044: e0 00 00 0f bi 8004080 <rtems_aio_handle+0x248>
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
8004048: 29 61 00 68 lw r1,(r11+104)
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
800404c: 29 6c 00 54 lw r12,(r11+84)
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
8004050: 34 21 ff ff addi r1,r1,-1
8004054: 59 61 00 68 sw (r11+104),r1
++aio_request_queue.active_threads;
8004058: 29 61 00 64 lw r1,(r11+100)
800405c: 34 21 00 01 addi r1,r1,1
8004060: 59 61 00 64 sw (r11+100),r1
8004064: b9 80 08 00 mv r1,r12
8004068: f8 00 08 f2 calli 8006430 <_Chain_Extract>
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = (rtems_aio_request_chain *) node;
rtems_aio_move_to_work (r_chain);
800406c: b9 80 08 00 mv r1,r12
8004070: fb ff ff 5f calli 8003dec <rtems_aio_move_to_work>
}
}
/* 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);
8004074: b9 60 08 00 mv r1,r11
8004078: f8 00 03 53 calli 8004dc4 <pthread_mutex_unlock>
800407c: e3 ff ff 8a bi 8003ea4 <rtems_aio_handle+0x6c>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
8004080: 34 01 00 00 mvi r1,0
8004084: 2b 9d 00 04 lw ra,(sp+4)
8004088: 2b 8b 00 34 lw r11,(sp+52)
800408c: 2b 8c 00 30 lw r12,(sp+48)
8004090: 2b 8d 00 2c lw r13,(sp+44)
8004094: 2b 8e 00 28 lw r14,(sp+40)
8004098: 2b 8f 00 24 lw r15,(sp+36)
800409c: 2b 90 00 20 lw r16,(sp+32)
80040a0: 2b 91 00 1c lw r17,(sp+28)
80040a4: 2b 92 00 18 lw r18,(sp+24)
80040a8: 2b 93 00 14 lw r19,(sp+20)
80040ac: 2b 94 00 10 lw r20,(sp+16)
80040b0: 2b 95 00 0c lw r21,(sp+12)
80040b4: 2b 96 00 08 lw r22,(sp+8)
80040b8: 37 9c 00 5c addi sp,sp,92
80040bc: c3 a0 00 00 ret
08003c1c <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
8003c1c: 37 9c ff f4 addi sp,sp,-12
8003c20: 5b 8b 00 0c sw (sp+12),r11
8003c24: 5b 8c 00 08 sw (sp+8),r12
8003c28: 5b 9d 00 04 sw (sp+4),ra
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
8003c2c: 78 0c 08 01 mvhi r12,0x801
8003c30: 39 8c 78 70 ori r12,r12,0x7870
8003c34: b9 80 08 00 mv r1,r12
8003c38: f8 00 04 b0 calli 8004ef8 <pthread_attr_init>
8003c3c: b8 20 58 00 mv r11,r1
if (result != 0)
8003c40: 5c 20 00 2f bne r1,r0,8003cfc <rtems_aio_init+0xe0> <== NEVER TAKEN
return result;
result =
8003c44: b9 80 08 00 mv r1,r12
8003c48: 34 02 00 00 mvi r2,0
8003c4c: f8 00 04 b8 calli 8004f2c <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
8003c50: 44 2b 00 03 be r1,r11,8003c5c <rtems_aio_init+0x40> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
8003c54: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
8003c58: f8 00 04 a0 calli 8004ed8 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
8003c5c: 78 01 08 01 mvhi r1,0x801
8003c60: 38 21 78 68 ori r1,r1,0x7868
8003c64: 34 02 00 00 mvi r2,0
8003c68: f8 00 03 c7 calli 8004b84 <pthread_mutex_init>
if (result != 0)
8003c6c: 44 20 00 04 be r1,r0,8003c7c <rtems_aio_init+0x60> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
8003c70: 78 01 08 01 mvhi r1,0x801 <== NOT EXECUTED
8003c74: 38 21 78 70 ori r1,r1,0x7870 <== NOT EXECUTED
8003c78: f8 00 04 98 calli 8004ed8 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
8003c7c: 78 01 08 01 mvhi r1,0x801
8003c80: 38 21 78 6c ori r1,r1,0x786c
8003c84: 34 02 00 00 mvi r2,0
8003c88: f8 00 02 9d calli 80046fc <pthread_cond_init>
8003c8c: b8 20 58 00 mv r11,r1
if (result != 0) {
8003c90: 44 20 00 07 be r1,r0,8003cac <rtems_aio_init+0x90> <== ALWAYS TAKEN
pthread_mutex_destroy (&aio_request_queue.mutex);
8003c94: 78 01 08 01 mvhi r1,0x801 <== NOT EXECUTED
8003c98: 38 21 78 68 ori r1,r1,0x7868 <== NOT EXECUTED
8003c9c: f8 00 03 5d calli 8004a10 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
8003ca0: 78 01 08 01 mvhi r1,0x801 <== NOT EXECUTED
8003ca4: 38 21 78 70 ori r1,r1,0x7870 <== NOT EXECUTED
8003ca8: f8 00 04 8c calli 8004ed8 <pthread_attr_destroy> <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
8003cac: 78 02 08 01 mvhi r2,0x801
8003cb0: 78 01 08 01 mvhi r1,0x801
8003cb4: 38 42 78 68 ori r2,r2,0x7868
8003cb8: 38 21 78 b4 ori r1,r1,0x78b4
8003cbc: 58 41 00 48 sw (r2+72),r1
head->previous = NULL;
tail->previous = head;
8003cc0: 78 01 08 01 mvhi r1,0x801
8003cc4: 38 21 78 b0 ori r1,r1,0x78b0
8003cc8: 58 41 00 50 sw (r2+80),r1
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
8003ccc: 78 01 08 01 mvhi r1,0x801
8003cd0: 38 21 78 c0 ori r1,r1,0x78c0
8003cd4: 58 41 00 54 sw (r2+84),r1
head->previous = NULL;
tail->previous = head;
8003cd8: 78 01 08 01 mvhi r1,0x801
8003cdc: 38 21 78 bc ori r1,r1,0x78bc
8003ce0: 58 41 00 5c sw (r2+92),r1
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
8003ce4: 38 01 b0 0b mvu r1,0xb00b
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
8003ce8: 58 40 00 4c sw (r2+76),r0
8003cec: 58 40 00 58 sw (r2+88),r0
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
8003cf0: 58 40 00 64 sw (r2+100),r0
aio_request_queue.idle_threads = 0;
8003cf4: 58 40 00 68 sw (r2+104),r0
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
8003cf8: 58 41 00 60 sw (r2+96),r1
return result;
}
8003cfc: b9 60 08 00 mv r1,r11
8003d00: 2b 9d 00 04 lw ra,(sp+4)
8003d04: 2b 8b 00 0c lw r11,(sp+12)
8003d08: 2b 8c 00 08 lw r12,(sp+8)
8003d0c: 37 9c 00 0c addi sp,sp,12
8003d10: c3 a0 00 00 ret
080040c0 <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
80040c0: 37 9c ff fc addi sp,sp,-4
80040c4: 5b 9d 00 04 sw (sp+4),ra
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
80040c8: 28 23 00 00 lw r3,(r1+0)
80040cc: 34 25 00 04 addi r5,r1,4
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
80040d0: b8 40 20 00 mv r4,r2
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
80040d4: 44 65 00 0d be r3,r5,8004108 <rtems_aio_insert_prio+0x48> <== NEVER TAKEN
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
80040d8: 28 61 00 14 lw r1,(r3+20)
while (req->aiocbp->aio_reqprio > prio &&
80040dc: 28 42 00 14 lw r2,(r2+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;
80040e0: 28 21 00 10 lw r1,(r1+16)
while (req->aiocbp->aio_reqprio > prio &&
80040e4: 28 42 00 10 lw r2,(r2+16)
80040e8: e0 00 00 04 bi 80040f8 <rtems_aio_insert_prio+0x38>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
80040ec: 28 63 00 00 lw r3,(r3+0) <== 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;
80040f0: 28 61 00 14 lw r1,(r3+20) <== NOT EXECUTED
80040f4: 28 21 00 10 lw r1,(r1+16) <== 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 &&
80040f8: 4c 22 00 02 bge r1,r2,8004100 <rtems_aio_insert_prio+0x40> <== ALWAYS TAKEN
80040fc: 5c 65 ff fc bne r3,r5,80040ec <rtems_aio_insert_prio+0x2c> <== 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 );
8004100: 28 61 00 04 lw r1,(r3+4)
8004104: b8 80 10 00 mv r2,r4
8004108: f8 00 08 e3 calli 8006494 <_Chain_Insert>
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
800410c: 2b 9d 00 04 lw ra,(sp+4)
8004110: 37 9c 00 04 addi sp,sp,4
8004114: c3 a0 00 00 ret
08003dec <rtems_aio_move_to_work>:
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
8003dec: 37 9c ff fc addi sp,sp,-4
8003df0: 5b 9d 00 04 sw (sp+4),ra
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
8003df4: 78 03 08 01 mvhi r3,0x801
8003df8: 38 63 78 68 ori r3,r3,0x7868
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
8003dfc: 78 04 08 01 mvhi r4,0x801
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
8003e00: b8 20 10 00 mv r2,r1
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
8003e04: 28 63 00 48 lw r3,(r3+72)
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
8003e08: 28 21 00 14 lw r1,(r1+20)
8003e0c: 38 84 78 b4 ori r4,r4,0x78b4
8003e10: e0 00 00 02 bi 8003e18 <rtems_aio_move_to_work+0x2c>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
8003e14: 28 63 00 00 lw r3,(r3+0)
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
8003e18: 28 65 00 14 lw r5,(r3+20)
8003e1c: 4c a1 00 02 bge r5,r1,8003e24 <rtems_aio_move_to_work+0x38>
8003e20: 5c 64 ff fd bne r3,r4,8003e14 <rtems_aio_move_to_work+0x28><== ALWAYS TAKEN
8003e24: 28 61 00 04 lw r1,(r3+4)
8003e28: f8 00 09 9b calli 8006494 <_Chain_Insert>
node = rtems_chain_next (node);
temp = (rtems_aio_request_chain *) node;
}
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
}
8003e2c: 2b 9d 00 04 lw ra,(sp+4)
8003e30: 37 9c 00 04 addi sp,sp,4
8003e34: c3 a0 00 00 ret
08004190 <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)
{
8004190: 37 9c ff f8 addi sp,sp,-8
8004194: 5b 8b 00 08 sw (sp+8),r11
8004198: 5b 9d 00 04 sw (sp+4),ra
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
800419c: 28 2b 00 00 lw r11,(r1+0)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
80041a0: 34 23 00 04 addi r3,r1,4
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
80041a4: 34 01 00 02 mvi r1,2
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
80041a8: 5d 63 00 04 bne r11,r3,80041b8 <rtems_aio_remove_req+0x28>
80041ac: e0 00 00 11 bi 80041f0 <rtems_aio_remove_req+0x60>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
80041b0: 28 2b 00 00 lw r11,(r1+0) <== 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) {
80041b4: 45 63 00 0e be r11,r3,80041ec <rtems_aio_remove_req+0x5c> <== NOT EXECUTED
80041b8: 29 64 00 14 lw r4,(r11+20)
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
80041bc: b9 60 08 00 mv r1,r11
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) {
80041c0: 5c 82 ff fc bne r4,r2,80041b0 <rtems_aio_remove_req+0x20> <== NEVER TAKEN
80041c4: f8 00 08 9b calli 8006430 <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
80041c8: 29 61 00 14 lw r1,(r11+20)
80041cc: 34 02 00 8c mvi r2,140
80041d0: 58 22 00 2c sw (r1+44),r2
current->aiocbp->return_value = -1;
80041d4: 34 02 ff ff mvi r2,-1
80041d8: 58 22 00 30 sw (r1+48),r2
free (current);
80041dc: b9 60 08 00 mv r1,r11
80041e0: fb ff f7 e0 calli 8002160 <free>
}
return AIO_CANCELED;
80041e4: 34 01 00 00 mvi r1,0
80041e8: e0 00 00 02 bi 80041f0 <rtems_aio_remove_req+0x60>
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
80041ec: 34 01 00 01 mvi r1,1 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
80041f0: 2b 9d 00 04 lw ra,(sp+4)
80041f4: 2b 8b 00 08 lw r11,(sp+8)
80041f8: 37 9c 00 08 addi sp,sp,8
80041fc: c3 a0 00 00 ret
08003898 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
8003898: 37 9c ff e4 addi sp,sp,-28
800389c: 5b 8b 00 18 sw (sp+24),r11
80038a0: 5b 8c 00 14 sw (sp+20),r12
80038a4: 5b 8d 00 10 sw (sp+16),r13
80038a8: 5b 8e 00 0c sw (sp+12),r14
80038ac: 5b 8f 00 08 sw (sp+8),r15
80038b0: 5b 9d 00 04 sw (sp+4),ra
80038b4: b8 20 78 00 mv r15,r1
80038b8: b8 40 70 00 mv r14,r2
80038bc: b8 60 68 00 mv r13,r3
80038c0: b8 80 60 00 mv r12,r4
80038c4: e0 00 00 08 bi 80038e4 <rtems_chain_get_with_wait+0x4c>
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
80038c8: b9 c0 08 00 mv r1,r14
80038cc: 34 02 00 00 mvi r2,0
80038d0: b9 a0 18 00 mv r3,r13
80038d4: 37 84 00 1c addi r4,sp,28
80038d8: fb ff fd d2 calli 8003020 <rtems_event_receive>
80038dc: b8 20 28 00 mv r5,r1
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
80038e0: 5c 2b 00 06 bne r1,r11,80038f8 <rtems_chain_get_with_wait+0x60><== ALWAYS TAKEN
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
80038e4: b9 e0 08 00 mv r1,r15
80038e8: f8 00 01 a1 calli 8003f6c <_Chain_Get>
80038ec: b8 20 58 00 mv r11,r1
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
80038f0: 44 20 ff f6 be r1,r0,80038c8 <rtems_chain_get_with_wait+0x30>
80038f4: 34 05 00 00 mvi r5,0
}
*node_ptr = node;
return sc;
}
80038f8: b8 a0 08 00 mv r1,r5
timeout,
&out
);
}
*node_ptr = node;
80038fc: 59 8b 00 00 sw (r12+0),r11
return sc;
}
8003900: 2b 9d 00 04 lw ra,(sp+4)
8003904: 2b 8b 00 18 lw r11,(sp+24)
8003908: 2b 8c 00 14 lw r12,(sp+20)
800390c: 2b 8d 00 10 lw r13,(sp+16)
8003910: 2b 8e 00 0c lw r14,(sp+12)
8003914: 2b 8f 00 08 lw r15,(sp+8)
8003918: 37 9c 00 1c addi sp,sp,28
800391c: c3 a0 00 00 ret
08010ad0 <rtems_clock_set_nanoseconds_extension>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_set_nanoseconds_extension(
rtems_nanoseconds_extension_routine routine
)
{
8010ad0: b8 20 18 00 mv r3,r1
if ( !routine )
return RTEMS_INVALID_ADDRESS;
8010ad4: 34 01 00 09 mvi r1,9
*/
rtems_status_code rtems_clock_set_nanoseconds_extension(
rtems_nanoseconds_extension_routine routine
)
{
if ( !routine )
8010ad8: 44 60 00 05 be r3,r0,8010aec <rtems_clock_set_nanoseconds_extension+0x1c><== ALWAYS TAKEN
return RTEMS_INVALID_ADDRESS;
_Watchdog_Nanoseconds_since_tick_handler = routine;
8010adc: 78 02 08 03 mvhi r2,0x803 <== NOT EXECUTED
8010ae0: 38 42 c1 6c ori r2,r2,0xc16c <== NOT EXECUTED
8010ae4: 58 43 00 00 sw (r2+0),r3 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
8010ae8: 34 01 00 00 mvi r1,0 <== NOT EXECUTED
}
8010aec: c3 a0 00 00 ret
08001a40 <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
8001a40: 37 9c ff 74 addi sp,sp,-140
8001a44: 5b 8b 00 44 sw (sp+68),r11
8001a48: 5b 8c 00 40 sw (sp+64),r12
8001a4c: 5b 8d 00 3c sw (sp+60),r13
8001a50: 5b 8e 00 38 sw (sp+56),r14
8001a54: 5b 8f 00 34 sw (sp+52),r15
8001a58: 5b 90 00 30 sw (sp+48),r16
8001a5c: 5b 91 00 2c sw (sp+44),r17
8001a60: 5b 92 00 28 sw (sp+40),r18
8001a64: 5b 93 00 24 sw (sp+36),r19
8001a68: 5b 94 00 20 sw (sp+32),r20
8001a6c: 5b 95 00 1c sw (sp+28),r21
8001a70: 5b 96 00 18 sw (sp+24),r22
8001a74: 5b 97 00 14 sw (sp+20),r23
8001a78: 5b 98 00 10 sw (sp+16),r24
8001a7c: 5b 99 00 0c sw (sp+12),r25
8001a80: 5b 9b 00 08 sw (sp+8),fp
8001a84: 5b 9d 00 04 sw (sp+4),ra
8001a88: b8 20 90 00 mv r18,r1
8001a8c: b8 40 70 00 mv r14,r2
Timestamp_Control uptime, total, ran, uptime_at_last_reset;
#else
uint32_t total_units = 0;
#endif
if ( !print )
8001a90: 44 40 00 6b be r2,r0,8001c3c <rtems_cpu_usage_report_with_plugin+0x1fc><== NEVER TAKEN
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
8001a94: 78 03 08 02 mvhi r3,0x802
8001a98: 38 63 22 60 ori r3,r3,0x2260
8001a9c: 28 62 00 00 lw r2,(r3+0)
}
}
}
#endif
(*print)(
8001aa0: 78 0c 08 02 mvhi r12,0x802
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
8001aa4: 78 14 08 01 mvhi r20,0x801
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
8001aa8: 5b 82 00 68 sw (sp+104),r2
8001aac: 28 62 00 04 lw r2,(r3+4)
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
8001ab0: 78 10 08 02 mvhi r16,0x802
/*
* Print the information
*/
(*print)( context,
8001ab4: 78 13 08 01 mvhi r19,0x801
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
8001ab8: 5b 82 00 6c sw (sp+108),r2
}
}
}
#endif
(*print)(
8001abc: 78 02 08 01 mvhi r2,0x801
8001ac0: 38 42 e9 90 ori r2,r2,0xe990
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
Timestamp_Control used;
Timestamp_Control last = _Thread_Time_of_last_context_switch;
8001ac4: 78 0d 08 02 mvhi r13,0x802
* When not using nanosecond CPU usage resolution, we have to count
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
8001ac8: 5b 80 00 78 sw (sp+120),r0
8001acc: 5b 80 00 7c sw (sp+124),r0
}
}
}
#endif
(*print)(
8001ad0: 39 8c 1c c8 ori r12,r12,0x1cc8
8001ad4: d9 c0 00 00 call r14
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
8001ad8: 3a 94 eb 04 ori r20,r20,0xeb04
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
8001adc: 37 9b 00 48 addi fp,sp,72
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
8001ae0: 3a 10 22 14 ori r16,r16,0x2214
8001ae4: 37 8f 00 80 addi r15,sp,128
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
8001ae8: 37 99 00 78 addi r25,sp,120
_Timestamp_Divide( &ran, &total, &ival, &fval );
8001aec: 37 98 00 70 addi r24,sp,112
/*
* Print the information
*/
(*print)( context,
8001af0: 3a 73 eb 18 ori r19,r19,0xeb18
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
Timestamp_Control used;
Timestamp_Control last = _Thread_Time_of_last_context_switch;
8001af4: 39 ad 1d d4 ori r13,r13,0x1dd4
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract( &last, &uptime, &used );
8001af8: 37 97 00 60 addi r23,sp,96
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
8001afc: 29 81 00 00 lw r1,(r12+0)
if ( information ) {
8001b00: 34 16 00 04 mvi r22,4
8001b04: 34 15 00 01 mvi r21,1
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
8001b08: 28 31 00 04 lw r17,(r1+4)
if ( information ) {
8001b0c: 5e 20 00 3c bne r17,r0,8001bfc <rtems_cpu_usage_report_with_plugin+0x1bc><== ALWAYS TAKEN
8001b10: e0 00 00 3d bi 8001c04 <rtems_cpu_usage_report_with_plugin+0x1c4><== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
8001b14: 2a 21 00 1c lw r1,(r17+28)
8001b18: b4 36 08 00 add r1,r1,r22
8001b1c: 28 2b 00 00 lw r11,(r1+0)
if ( !the_thread )
8001b20: 45 60 00 35 be r11,r0,8001bf4 <rtems_cpu_usage_report_with_plugin+0x1b4><== NEVER TAKEN
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
8001b24: 29 61 00 08 lw r1,(r11+8)
8001b28: 34 02 00 0d mvi r2,13
8001b2c: bb 60 18 00 mv r3,fp
8001b30: f8 00 0a 1b calli 800439c <rtems_object_get_name>
(*print)(
8001b34: 29 63 00 08 lw r3,(r11+8)
8001b38: ba 80 10 00 mv r2,r20
8001b3c: ba 40 08 00 mv r1,r18
8001b40: bb 60 20 00 mv r4,fp
8001b44: d9 c0 00 00 call r14
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
8001b48: 29 61 00 84 lw r1,(r11+132)
8001b4c: 5b 81 00 70 sw (sp+112),r1
8001b50: 29 61 00 88 lw r1,(r11+136)
8001b54: 5b 81 00 74 sw (sp+116),r1
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
8001b58: 2a 01 00 0c lw r1,(r16+12)
8001b5c: 28 22 00 08 lw r2,(r1+8)
8001b60: 29 61 00 08 lw r1,(r11+8)
8001b64: 5c 41 00 0f bne r2,r1,8001ba0 <rtems_cpu_usage_report_with_plugin+0x160>
Timestamp_Control used;
Timestamp_Control last = _Thread_Time_of_last_context_switch;
8001b68: 29 a1 00 00 lw r1,(r13+0)
8001b6c: 5b 81 00 58 sw (sp+88),r1
8001b70: 29 a1 00 04 lw r1,(r13+4)
8001b74: 5b 81 00 5c sw (sp+92),r1
_TOD_Get_uptime( &uptime );
8001b78: b9 e0 08 00 mv r1,r15
8001b7c: f8 00 0f 4c calli 80058ac <_TOD_Get_uptime>
_Timestamp_Subtract( &last, &uptime, &used );
8001b80: 37 81 00 58 addi r1,sp,88
8001b84: b9 e0 10 00 mv r2,r15
8001b88: ba e0 18 00 mv r3,r23
8001b8c: f8 00 1a 88 calli 80085ac <_Timespec_Subtract>
_Timestamp_Add_to( &ran, &used );
8001b90: bb 00 08 00 mv r1,r24
8001b94: ba e0 10 00 mv r2,r23
8001b98: f8 00 1a 14 calli 80083e8 <_Timespec_Add_to>
8001b9c: e0 00 00 03 bi 8001ba8 <rtems_cpu_usage_report_with_plugin+0x168>
} else {
_TOD_Get_uptime( &uptime );
8001ba0: b9 e0 08 00 mv r1,r15
8001ba4: f8 00 0f 42 calli 80058ac <_TOD_Get_uptime>
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
8001ba8: 37 81 00 68 addi r1,sp,104
8001bac: b9 e0 10 00 mv r2,r15
8001bb0: bb 20 18 00 mv r3,r25
8001bb4: f8 00 1a 7e calli 80085ac <_Timespec_Subtract>
_Timestamp_Divide( &ran, &total, &ival, &fval );
8001bb8: 37 83 00 8c addi r3,sp,140
8001bbc: 37 84 00 88 addi r4,sp,136
8001bc0: bb 00 08 00 mv r1,r24
8001bc4: bb 20 10 00 mv r2,r25
8001bc8: f8 00 1a 21 calli 800844c <_Timespec_Divide>
/*
* Print the information
*/
(*print)( context,
8001bcc: 2b 81 00 74 lw r1,(sp+116)
8001bd0: 34 02 03 e8 mvi r2,1000
8001bd4: f8 00 6d ba calli 801d2bc <__udivsi3>
8001bd8: 2b 83 00 70 lw r3,(sp+112)
8001bdc: 2b 85 00 8c lw r5,(sp+140)
8001be0: 2b 86 00 88 lw r6,(sp+136)
8001be4: b8 20 20 00 mv r4,r1
8001be8: ba 60 10 00 mv r2,r19
8001bec: ba 40 08 00 mv r1,r18
8001bf0: d9 c0 00 00 call r14
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
8001bf4: 36 b5 00 01 addi r21,r21,1
8001bf8: 36 d6 00 04 addi r22,r22,4
8001bfc: 2e 21 00 10 lhu r1,(r17+16)
8001c00: 50 35 ff c5 bgeu r1,r21,8001b14 <rtems_cpu_usage_report_with_plugin+0xd4>
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
8001c04: 78 01 08 02 mvhi r1,0x802
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
8001c08: 35 8c 00 04 addi r12,r12,4
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
8001c0c: 38 21 1c d4 ori r1,r1,0x1cd4
8001c10: 5d 81 ff bb bne r12,r1,8001afc <rtems_cpu_usage_report_with_plugin+0xbc>
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
8001c14: 2b 81 00 7c lw r1,(sp+124)
8001c18: 34 02 03 e8 mvi r2,1000
8001c1c: 78 0b 08 01 mvhi r11,0x801
8001c20: f8 00 6d a7 calli 801d2bc <__udivsi3>
8001c24: 2b 83 00 78 lw r3,(sp+120)
8001c28: 39 6b eb 30 ori r11,r11,0xeb30
8001c2c: b8 20 20 00 mv r4,r1
8001c30: b9 60 10 00 mv r2,r11
8001c34: ba 40 08 00 mv r1,r18
8001c38: d9 c0 00 00 call r14
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
8001c3c: 2b 9d 00 04 lw ra,(sp+4)
8001c40: 2b 8b 00 44 lw r11,(sp+68)
8001c44: 2b 8c 00 40 lw r12,(sp+64)
8001c48: 2b 8d 00 3c lw r13,(sp+60)
8001c4c: 2b 8e 00 38 lw r14,(sp+56)
8001c50: 2b 8f 00 34 lw r15,(sp+52)
8001c54: 2b 90 00 30 lw r16,(sp+48)
8001c58: 2b 91 00 2c lw r17,(sp+44)
8001c5c: 2b 92 00 28 lw r18,(sp+40)
8001c60: 2b 93 00 24 lw r19,(sp+36)
8001c64: 2b 94 00 20 lw r20,(sp+32)
8001c68: 2b 95 00 1c lw r21,(sp+28)
8001c6c: 2b 96 00 18 lw r22,(sp+24)
8001c70: 2b 97 00 14 lw r23,(sp+20)
8001c74: 2b 98 00 10 lw r24,(sp+16)
8001c78: 2b 99 00 0c lw r25,(sp+12)
8001c7c: 2b 9b 00 08 lw fp,(sp+8)
8001c80: 37 9c 00 8c addi sp,sp,140
8001c84: c3 a0 00 00 ret
080112b0 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
80112b0: 37 9c ff f8 addi sp,sp,-8
80112b4: 5b 8b 00 08 sw (sp+8),r11
80112b8: 5b 9d 00 04 sw (sp+4),ra
if (sc == RTEMS_SUCCESSFUL) {
return 0;
80112bc: 34 02 00 00 mvi r2,0
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
80112c0: 44 20 00 0d be r1,r0,80112f4 <rtems_deviceio_errno+0x44>
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
80112c4: 34 02 00 1c mvi r2,28
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
80112c8: 34 0b 00 16 mvi r11,22
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
80112cc: 54 22 00 07 bgu r1,r2,80112e8 <rtems_deviceio_errno+0x38> <== NEVER TAKEN
eno = status_code_to_errno [sc];
80112d0: 78 0b 08 01 mvhi r11,0x801
80112d4: 34 02 00 02 mvi r2,2
80112d8: 39 6b 86 cc ori r11,r11,0x86cc
80112dc: f8 00 17 0d calli 8016f10 <__ashlsi3>
80112e0: b5 61 08 00 add r1,r11,r1
80112e4: 28 2b 00 00 lw r11,(r1+0)
}
errno = eno;
80112e8: f8 00 00 62 calli 8011470 <__errno>
80112ec: 58 2b 00 00 sw (r1+0),r11
return -1;
80112f0: 34 02 ff ff mvi r2,-1
}
}
80112f4: b8 40 08 00 mv r1,r2
80112f8: 2b 9d 00 04 lw ra,(sp+4)
80112fc: 2b 8b 00 08 lw r11,(sp+8)
8011300: 37 9c 00 08 addi sp,sp,8
8011304: c3 a0 00 00 ret
0800cbb8 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
800cbb8: 37 9c ff f4 addi sp,sp,-12
800cbbc: 5b 9d 00 04 sw (sp+4),ra
find_arg fa = {
800cbc0: 5b 81 00 08 sw (sp+8),r1
800cbc4: 5b 80 00 0c sw (sp+12),r0
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
800cbc8: 44 20 00 05 be r1,r0,800cbdc <rtems_filesystem_get_mount_handler+0x24><== NEVER TAKEN
rtems_filesystem_iterate( find_handler, &fa );
800cbcc: 78 01 08 00 mvhi r1,0x800
800cbd0: 38 21 ca 54 ori r1,r1,0xca54
800cbd4: 37 82 00 08 addi r2,sp,8
800cbd8: fb ff ff c7 calli 800caf4 <rtems_filesystem_iterate>
}
return fa.mount_h;
}
800cbdc: 2b 81 00 0c lw r1,(sp+12)
800cbe0: 2b 9d 00 04 lw ra,(sp+4)
800cbe4: 37 9c 00 0c addi sp,sp,12
800cbe8: c3 a0 00 00 ret
08002334 <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 )
{
8002334: 37 9c ff dc addi sp,sp,-36
8002338: 5b 8b 00 10 sw (sp+16),r11
800233c: 5b 8c 00 0c sw (sp+12),r12
8002340: 5b 8d 00 08 sw (sp+8),r13
8002344: 5b 9d 00 04 sw (sp+4),ra
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
8002348: 78 0b 08 01 mvhi r11,0x801
800234c: 39 6b 91 34 ori r11,r11,0x9134
8002350: 29 62 00 00 lw r2,(r11+0)
8002354: 34 01 00 12 mvi r1,18
8002358: 58 41 00 2c sw (r2+44),r1
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
800235c: 78 01 08 01 mvhi r1,0x801
8002360: 38 21 7e 30 ori r1,r1,0x7e30
8002364: 28 21 00 00 lw r1,(r1+0)
rtems_fatal_error_occurred( 0xABCD0001 );
8002368: 78 02 08 01 mvhi r2,0x801
800236c: 38 42 7f 3c ori r2,r2,0x7f3c
rtems_filesystem_umask = 022;
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
8002370: 44 20 00 0e be r1,r0,80023a8 <rtems_filesystem_initialize+0x74><== NEVER TAKEN
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
8002374: 78 01 08 01 mvhi r1,0x801
8002378: 38 21 90 18 ori r1,r1,0x9018
800237c: 28 24 00 00 lw r4,(r1+0)
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
8002380: 34 05 00 00 mvi r5,0
8002384: 28 82 00 0c lw r2,(r4+12)
8002388: 28 81 00 08 lw r1,(r4+8)
800238c: 28 83 00 00 lw r3,(r4+0)
8002390: 28 84 00 04 lw r4,(r4+4)
8002394: f8 00 02 83 calli 8002da0 <mount>
if ( status == -1 )
8002398: 34 02 ff ff mvi r2,-1
800239c: 5c 22 00 05 bne r1,r2,80023b0 <rtems_filesystem_initialize+0x7c><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0002 );
80023a0: 78 02 08 01 mvhi r2,0x801 <== NOT EXECUTED
80023a4: 38 42 7f 40 ori r2,r2,0x7f40 <== NOT EXECUTED
80023a8: 28 41 00 00 lw r1,(r2+0) <== NOT EXECUTED
80023ac: f8 00 08 5c calli 800451c <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_filesystem_link_counts = 0;
80023b0: 29 61 00 00 lw r1,(r11+0)
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
80023b4: 78 0c 08 01 mvhi r12,0x801
80023b8: 39 8c 7f 30 ori r12,r12,0x7f30
80023bc: 37 8d 00 14 addi r13,sp,20
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;
80023c0: 0c 20 00 30 sh (r1+48),r0
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
80023c4: 34 02 00 01 mvi r2,1
80023c8: 34 03 00 00 mvi r3,0
80023cc: b9 a0 20 00 mv r4,r13
80023d0: 34 05 00 00 mvi r5,0
80023d4: b9 80 08 00 mv r1,r12
80023d8: f8 00 00 6b calli 8002584 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
80023dc: 29 61 00 00 lw r1,(r11+0)
80023e0: 2b 82 00 14 lw r2,(sp+20)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
80023e4: 34 03 00 00 mvi r3,0
80023e8: b9 a0 20 00 mv r4,r13
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
80023ec: 58 22 00 18 sw (r1+24),r2
80023f0: 2b 82 00 18 lw r2,(sp+24)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
80023f4: 34 05 00 00 mvi r5,0
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
80023f8: 58 22 00 1c sw (r1+28),r2
80023fc: 2b 82 00 1c lw r2,(sp+28)
8002400: 58 22 00 20 sw (r1+32),r2
8002404: 2b 82 00 20 lw r2,(sp+32)
8002408: 58 22 00 24 sw (r1+36),r2
800240c: 2b 82 00 24 lw r2,(sp+36)
8002410: 58 22 00 28 sw (r1+40),r2
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
8002414: 34 02 00 01 mvi r2,1
8002418: b9 80 08 00 mv r1,r12
800241c: f8 00 00 5a calli 8002584 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
8002420: 29 61 00 00 lw r1,(r11+0)
8002424: 2b 82 00 14 lw r2,(sp+20)
8002428: 58 22 00 04 sw (r1+4),r2
800242c: 2b 82 00 18 lw r2,(sp+24)
8002430: 58 22 00 08 sw (r1+8),r2
8002434: 2b 82 00 1c lw r2,(sp+28)
8002438: 58 22 00 0c sw (r1+12),r2
800243c: 2b 82 00 20 lw r2,(sp+32)
8002440: 58 22 00 10 sw (r1+16),r2
8002444: 2b 82 00 24 lw r2,(sp+36)
8002448: 58 22 00 14 sw (r1+20),r2
*
* 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);
800244c: 78 01 08 01 mvhi r1,0x801
8002450: 34 02 01 ff mvi r2,511
8002454: 38 21 7f 34 ori r1,r1,0x7f34
8002458: f8 00 01 d4 calli 8002ba8 <mkdir>
if ( status != 0 )
rtems_fatal_error_occurred( 0xABCD0003 );
800245c: 78 02 08 01 mvhi r2,0x801
8002460: 38 42 7f 44 ori r2,r2,0x7f44
* 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);
if ( status != 0 )
8002464: 5c 20 ff d1 bne r1,r0,80023a8 <rtems_filesystem_initialize+0x74><== NEVER TAKEN
* 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.
*/
}
8002468: 2b 9d 00 04 lw ra,(sp+4)
800246c: 2b 8b 00 10 lw r11,(sp+16)
8002470: 2b 8c 00 0c lw r12,(sp+12)
8002474: 2b 8d 00 08 lw r13,(sp+8)
8002478: 37 9c 00 24 addi sp,sp,36
800247c: c3 a0 00 00 ret
0800caf4 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
800caf4: 37 9c ff e8 addi sp,sp,-24
800caf8: 5b 8b 00 18 sw (sp+24),r11
800cafc: 5b 8c 00 14 sw (sp+20),r12
800cb00: 5b 8d 00 10 sw (sp+16),r13
800cb04: 5b 8e 00 0c sw (sp+12),r14
800cb08: 5b 8f 00 08 sw (sp+8),r15
800cb0c: 5b 9d 00 04 sw (sp+4),ra
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
800cb10: 78 0b 08 01 mvhi r11,0x801
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
800cb14: b8 20 70 00 mv r14,r1
800cb18: b8 40 78 00 mv r15,r2
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
800cb1c: 34 03 00 00 mvi r3,0
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
800cb20: 39 6b 7e 10 ori r11,r11,0x7e10
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
800cb24: e0 00 00 06 bi 800cb3c <rtems_filesystem_iterate+0x48>
stop = (*routine)( table_entry, routine_arg );
800cb28: b9 60 08 00 mv r1,r11
800cb2c: b9 e0 10 00 mv r2,r15
800cb30: d9 c0 00 00 call r14
800cb34: b8 20 18 00 mv r3,r1
++table_entry;
800cb38: 35 6b 00 08 addi r11,r11,8
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
800cb3c: 29 61 00 00 lw r1,(r11+0)
800cb40: 44 20 00 03 be r1,r0,800cb4c <rtems_filesystem_iterate+0x58>
800cb44: 44 60 ff f9 be r3,r0,800cb28 <rtems_filesystem_iterate+0x34>
800cb48: e0 00 00 13 bi 800cb94 <rtems_filesystem_iterate+0xa0>
800cb4c: b8 60 58 00 mv r11,r3
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
800cb50: 5c 23 00 11 bne r1,r3,800cb94 <rtems_filesystem_iterate+0xa0>
rtems_libio_lock();
800cb54: fb ff ff d4 calli 800caa4 <rtems_libio_lock>
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
800cb58: 78 03 08 01 mvhi r3,0x801
800cb5c: 38 63 91 78 ori r3,r3,0x9178
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
800cb60: 78 0d 08 01 mvhi r13,0x801
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
800cb64: 28 6c 00 00 lw r12,(r3+0)
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
800cb68: 39 ad 91 7c ori r13,r13,0x917c
800cb6c: e0 00 00 06 bi 800cb84 <rtems_filesystem_iterate+0x90>
!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 );
800cb70: 35 81 00 08 addi r1,r12,8
800cb74: b9 e0 10 00 mv r2,r15
800cb78: d9 c0 00 00 call r14
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
800cb7c: 29 8c 00 00 lw r12,(r12+0)
!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 );
800cb80: b8 20 58 00 mv r11,r1
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
800cb84: 45 8d 00 02 be r12,r13,800cb8c <rtems_filesystem_iterate+0x98>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
800cb88: 45 60 ff fa be r11,r0,800cb70 <rtems_filesystem_iterate+0x7c><== ALWAYS TAKEN
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
800cb8c: fb ff ff d1 calli 800cad0 <rtems_libio_unlock>
800cb90: b9 60 18 00 mv r3,r11
}
return stop;
}
800cb94: b8 60 08 00 mv r1,r3
800cb98: 2b 9d 00 04 lw ra,(sp+4)
800cb9c: 2b 8b 00 18 lw r11,(sp+24)
800cba0: 2b 8c 00 14 lw r12,(sp+20)
800cba4: 2b 8d 00 10 lw r13,(sp+16)
800cba8: 2b 8e 00 0c lw r14,(sp+12)
800cbac: 2b 8f 00 08 lw r15,(sp+8)
800cbb0: 37 9c 00 18 addi sp,sp,24
800cbb4: c3 a0 00 00 ret
08002d18 <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
8002d18: 37 9c ff e8 addi sp,sp,-24
8002d1c: 5b 8b 00 18 sw (sp+24),r11
8002d20: 5b 8c 00 14 sw (sp+20),r12
8002d24: 5b 8d 00 10 sw (sp+16),r13
8002d28: 5b 8e 00 0c sw (sp+12),r14
8002d2c: 5b 8f 00 08 sw (sp+8),r15
8002d30: 5b 9d 00 04 sw (sp+4),ra
8002d34: b8 20 78 00 mv r15,r1
8002d38: b8 40 70 00 mv r14,r2
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
8002d3c: fb ff ff e3 calli 8002cc8 <rtems_libio_lock>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
8002d40: 78 03 08 01 mvhi r3,0x801
8002d44: 38 63 91 28 ori r3,r3,0x9128
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
8002d48: 78 0d 08 01 mvhi r13,0x801
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
8002d4c: 28 6b 00 00 lw r11,(r3+0)
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
rtems_chain_node *node = NULL;
bool stop = false;
8002d50: 34 0c 00 00 mvi r12,0
rtems_libio_lock();
for (
8002d54: 39 ad 91 2c ori r13,r13,0x912c
8002d58: e0 00 00 06 bi 8002d70 <rtems_filesystem_mount_iterate+0x58>
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 );
8002d5c: b9 60 08 00 mv r1,r11
8002d60: b9 c0 10 00 mv r2,r14
8002d64: d9 e0 00 00 call r15
}
rtems_libio_unlock();
return stop;
}
8002d68: 29 6b 00 00 lw r11,(r11+0)
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 );
8002d6c: b8 20 60 00 mv r12,r1
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
8002d70: 45 6d 00 02 be r11,r13,8002d78 <rtems_filesystem_mount_iterate+0x60>
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
8002d74: 45 80 ff fa be r12,r0,8002d5c <rtems_filesystem_mount_iterate+0x44><== ALWAYS TAKEN
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
8002d78: fb ff ff df calli 8002cf4 <rtems_libio_unlock>
return stop;
}
8002d7c: b9 80 08 00 mv r1,r12
8002d80: 2b 9d 00 04 lw ra,(sp+4)
8002d84: 2b 8b 00 18 lw r11,(sp+24)
8002d88: 2b 8c 00 14 lw r12,(sp+20)
8002d8c: 2b 8d 00 10 lw r13,(sp+16)
8002d90: 2b 8e 00 0c lw r14,(sp+12)
8002d94: 2b 8f 00 08 lw r15,(sp+8)
8002d98: 37 9c 00 18 addi sp,sp,24
8002d9c: c3 a0 00 00 ret
08002640 <rtems_filesystem_prefix_separators>:
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
8002640: 37 9c ff f0 addi sp,sp,-16
8002644: 5b 8b 00 10 sw (sp+16),r11
8002648: 5b 8c 00 0c sw (sp+12),r12
800264c: 5b 8d 00 08 sw (sp+8),r13
8002650: 5b 9d 00 04 sw (sp+4),ra
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
8002654: 34 0b 00 00 mvi r11,0
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
8002658: b8 20 68 00 mv r13,r1
800265c: b8 40 60 00 mv r12,r2
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
8002660: e0 00 00 02 bi 8002668 <rtems_filesystem_prefix_separators+0x28>
{
pathname++;
pathnamelen--;
stripped++;
8002664: 35 6b 00 01 addi r11,r11,1
}
return len;
}
int rtems_filesystem_prefix_separators(
8002668: b5 ab 08 00 add r1,r13,r11
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
800266c: 40 21 00 00 lbu r1,(r1+0)
8002670: fd 8b 18 00 cmpne r3,r12,r11
8002674: 7c 22 00 00 cmpnei r2,r1,0
8002678: a0 62 10 00 and r2,r3,r2
800267c: 44 40 00 03 be r2,r0,8002688 <rtems_filesystem_prefix_separators+0x48><== NEVER TAKEN
8002680: f8 00 04 89 calli 80038a4 <rtems_filesystem_is_separator>
8002684: 5c 20 ff f8 bne r1,r0,8002664 <rtems_filesystem_prefix_separators+0x24>
pathname++;
pathnamelen--;
stripped++;
}
return stripped;
}
8002688: b9 60 08 00 mv r1,r11
800268c: 2b 9d 00 04 lw ra,(sp+4)
8002690: 2b 8b 00 10 lw r11,(sp+16)
8002694: 2b 8c 00 0c lw r12,(sp+12)
8002698: 2b 8d 00 08 lw r13,(sp+8)
800269c: 37 9c 00 10 addi sp,sp,16
80026a0: c3 a0 00 00 ret
0800ccb8 <rtems_filesystem_unregister>:
int
rtems_filesystem_unregister(
const char *type
)
{
800ccb8: 37 9c ff f0 addi sp,sp,-16
800ccbc: 5b 8b 00 10 sw (sp+16),r11
800ccc0: 5b 8c 00 0c sw (sp+12),r12
800ccc4: 5b 8d 00 08 sw (sp+8),r13
800ccc8: 5b 9d 00 04 sw (sp+4),ra
800cccc: b8 20 68 00 mv r13,r1
rtems_chain_node *node = NULL;
if ( type == NULL ) {
800ccd0: 5c 20 00 04 bne r1,r0,800cce0 <rtems_filesystem_unregister+0x28>
rtems_set_errno_and_return_minus_one( EINVAL );
800ccd4: f8 00 11 e7 calli 8011470 <__errno>
800ccd8: 34 02 00 16 mvi r2,22
800ccdc: e0 00 00 18 bi 800cd3c <rtems_filesystem_unregister+0x84>
}
rtems_libio_lock();
800cce0: fb ff ff 71 calli 800caa4 <rtems_libio_lock>
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
800cce4: 78 03 08 01 mvhi r3,0x801
800cce8: 38 63 91 78 ori r3,r3,0x9178
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
800ccec: 78 0c 08 01 mvhi r12,0x801
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
800ccf0: 28 6b 00 00 lw r11,(r3+0)
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
800ccf4: 39 8c 91 7c ori r12,r12,0x917c
800ccf8: e0 00 00 0d bi 800cd2c <rtems_filesystem_unregister+0x74>
!rtems_chain_is_tail( &filesystem_chain, node );
node = rtems_chain_next( node )
) {
filesystem_node *fsn = (filesystem_node *) node;
if ( strcmp( fsn->entry.type, type ) == 0 ) {
800ccfc: 29 61 00 08 lw r1,(r11+8)
800cd00: b9 a0 10 00 mv r2,r13
800cd04: f8 00 15 c5 calli 8012418 <strcmp>
800cd08: 5c 20 00 08 bne r1,r0,800cd28 <rtems_filesystem_unregister+0x70><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
800cd0c: b9 60 08 00 mv r1,r11
800cd10: fb ff df 9a calli 8004b78 <_Chain_Extract>
rtems_chain_extract( node );
free( fsn );
800cd14: b9 60 08 00 mv r1,r11
800cd18: fb ff d6 6b calli 80026c4 <free>
rtems_libio_unlock();
800cd1c: fb ff ff 6d calli 800cad0 <rtems_libio_unlock>
return 0;
800cd20: 34 01 00 00 mvi r1,0
800cd24: e0 00 00 08 bi 800cd44 <rtems_filesystem_unregister+0x8c>
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
800cd28: 29 6b 00 00 lw r11,(r11+0)
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
800cd2c: 5d 6c ff f4 bne r11,r12,800ccfc <rtems_filesystem_unregister+0x44><== NEVER TAKEN
rtems_libio_unlock();
return 0;
}
}
rtems_libio_unlock();
800cd30: fb ff ff 68 calli 800cad0 <rtems_libio_unlock>
rtems_set_errno_and_return_minus_one( ENOENT );
800cd34: f8 00 11 cf calli 8011470 <__errno>
800cd38: 34 02 00 02 mvi r2,2
800cd3c: 58 22 00 00 sw (r1+0),r2
800cd40: 34 01 ff ff mvi r1,-1
}
800cd44: 2b 9d 00 04 lw ra,(sp+4)
800cd48: 2b 8b 00 10 lw r11,(sp+16)
800cd4c: 2b 8c 00 0c lw r12,(sp+12)
800cd50: 2b 8d 00 08 lw r13,(sp+8)
800cd54: 37 9c 00 10 addi sp,sp,16
800cd58: c3 a0 00 00 ret
08001f10 <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
8001f10: 37 9c ff f0 addi sp,sp,-16
8001f14: 5b 8b 00 10 sw (sp+16),r11
8001f18: 5b 8c 00 0c sw (sp+12),r12
8001f1c: 5b 8d 00 08 sw (sp+8),r13
8001f20: 5b 9d 00 04 sw (sp+4),ra
8001f24: b8 20 68 00 mv r13,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 ) );
8001f28: 34 01 00 08 mvi r1,8
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
8001f2c: b8 40 60 00 mv r12,r2
* 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 ) );
8001f30: f8 00 01 4a calli 8002458 <malloc>
*key = new_key;
8001f34: 59 a1 00 00 sw (r13+0),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 ) );
8001f38: b8 20 58 00 mv r11,r1
*key = new_key;
new_key->val = NULL;
8001f3c: 58 20 00 00 sw (r1+0),r0
new_key->dtor = dtor;
8001f40: 58 2c 00 04 sw (r1+4),r12
"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 );
8001f44: b9 60 10 00 mv r2,r11
8001f48: 34 01 00 00 mvi r1,0
8001f4c: b9 80 18 00 mv r3,r12
8001f50: f8 00 07 65 calli 8003ce4 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL )
return 0;
8001f54: 34 02 00 00 mvi r2,0
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
if ( status == RTEMS_SUCCESSFUL )
8001f58: 44 20 00 04 be r1,r0,8001f68 <rtems_gxx_key_create+0x58> <== ALWAYS TAKEN
return 0;
free( new_key );
8001f5c: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
8001f60: fb ff ff 72 calli 8001d28 <free> <== NOT EXECUTED
return -1;
8001f64: 34 02 ff ff mvi r2,-1 <== NOT EXECUTED
}
8001f68: b8 40 08 00 mv r1,r2
8001f6c: 2b 9d 00 04 lw ra,(sp+4)
8001f70: 2b 8b 00 10 lw r11,(sp+16)
8001f74: 2b 8c 00 0c lw r12,(sp+12)
8001f78: 2b 8d 00 08 lw r13,(sp+8)
8001f7c: 37 9c 00 10 addi sp,sp,16
8001f80: c3 a0 00 00 ret
08001f90 <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
8001f90: 37 9c ff f8 addi sp,sp,-8
8001f94: 5b 8b 00 08 sw (sp+8),r11
8001f98: 5b 9d 00 04 sw (sp+4),ra
8001f9c: b8 20 58 00 mv r11,r1
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: delete key=%x\n", key );
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_delete( RTEMS_SELF, (void **)key );
8001fa0: b9 60 10 00 mv r2,r11
8001fa4: 34 01 00 00 mvi r1,0
8001fa8: f8 00 07 7e calli 8003da0 <rtems_task_variable_delete>
if ( status == RTEMS_SUCCESSFUL ) {
8001fac: 5c 20 00 04 bne r1,r0,8001fbc <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
8001fb0: 45 61 00 03 be r11,r1,8001fbc <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
8001fb4: 29 61 00 00 lw r1,(r11+0)
8001fb8: fb ff ff 5c calli 8001d28 <free>
return 0;
}
key = NULL;
return 0;
}
8001fbc: 34 01 00 00 mvi r1,0
8001fc0: 2b 9d 00 04 lw ra,(sp+4)
8001fc4: 2b 8b 00 08 lw r11,(sp+8)
8001fc8: 37 9c 00 08 addi sp,sp,8
8001fcc: c3 a0 00 00 ret
08001e90 <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))
{
8001e90: 37 9c ff e8 addi sp,sp,-24
8001e94: 5b 8b 00 14 sw (sp+20),r11
8001e98: 5b 8c 00 10 sw (sp+16),r12
8001e9c: 5b 8d 00 0c sw (sp+12),r13
8001ea0: 5b 8e 00 08 sw (sp+8),r14
8001ea4: 5b 9d 00 04 sw (sp+4),ra
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
8001ea8: 28 2d 00 00 lw r13,(r1+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))
{
8001eac: b8 20 58 00 mv r11,r1
8001eb0: b8 40 70 00 mv r14,r2
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
8001eb4: 5d a0 00 0f bne r13,r0,8001ef0 <rtems_gxx_once+0x60>
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
8001eb8: 34 01 01 00 mvi r1,256
8001ebc: 34 02 01 00 mvi r2,256
8001ec0: 37 83 00 18 addi r3,sp,24
8001ec4: f8 00 06 ff calli 8003ac0 <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
8001ec8: 29 6c 00 00 lw r12,(r11+0)
8001ecc: 5d 8d 00 03 bne r12,r13,8001ed8 <rtems_gxx_once+0x48> <== NEVER TAKEN
*(volatile __gthread_once_t *)once = 1;
8001ed0: 34 01 00 01 mvi r1,1
8001ed4: 59 61 00 00 sw (r11+0),r1
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
8001ed8: 2b 81 00 18 lw r1,(sp+24)
8001edc: 34 02 01 00 mvi r2,256
8001ee0: 37 83 00 18 addi r3,sp,24
8001ee4: f8 00 06 f7 calli 8003ac0 <rtems_task_mode>
if ( o == 0 )
8001ee8: 5d 80 00 02 bne r12,r0,8001ef0 <rtems_gxx_once+0x60> <== NEVER TAKEN
(*func)();
8001eec: d9 c0 00 00 call r14
}
return 0;
}
8001ef0: 34 01 00 00 mvi r1,0
8001ef4: 2b 9d 00 04 lw ra,(sp+4)
8001ef8: 2b 8b 00 14 lw r11,(sp+20)
8001efc: 2b 8c 00 10 lw r12,(sp+16)
8001f00: 2b 8d 00 0c lw r13,(sp+12)
8001f04: 2b 8e 00 08 lw r14,(sp+8)
8001f08: 37 9c 00 18 addi sp,sp,24
8001f0c: c3 a0 00 00 ret
08002040 <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
8002040: 37 9c ff f4 addi sp,sp,-12
8002044: 5b 8b 00 0c sw (sp+12),r11
8002048: 5b 8c 00 08 sw (sp+8),r12
800204c: 5b 9d 00 04 sw (sp+4),ra
8002050: b8 20 58 00 mv r11,r1
rtems_task_self()
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
8002054: 29 63 00 04 lw r3,(r11+4)
#endif
return p;
}
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
8002058: b8 40 60 00 mv r12,r2
rtems_task_self()
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
800205c: 34 01 00 00 mvi r1,0
8002060: b9 60 10 00 mv r2,r11
8002064: f8 00 07 20 calli 8003ce4 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL ) {
/* now let's set the proper value */
key->val = (void *)ptr;
return 0;
}
return -1;
8002068: 34 03 ff ff mvi r3,-1
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
if ( status == RTEMS_SUCCESSFUL ) {
800206c: 5c 20 00 03 bne r1,r0,8002078 <rtems_gxx_setspecific+0x38> <== NEVER TAKEN
/* now let's set the proper value */
key->val = (void *)ptr;
8002070: 59 6c 00 00 sw (r11+0),r12
return 0;
8002074: 34 03 00 00 mvi r3,0
}
return -1;
}
8002078: b8 60 08 00 mv r1,r3
800207c: 2b 9d 00 04 lw ra,(sp+4)
8002080: 2b 8b 00 0c lw r11,(sp+12)
8002084: 2b 8c 00 08 lw r12,(sp+8)
8002088: 37 9c 00 0c addi sp,sp,12
800208c: c3 a0 00 00 ret
08006d24 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
8006d24: 37 9c ff f0 addi sp,sp,-16
8006d28: 5b 8b 00 10 sw (sp+16),r11
8006d2c: 5b 8c 00 0c sw (sp+12),r12
8006d30: 5b 8d 00 08 sw (sp+8),r13
8006d34: 5b 9d 00 04 sw (sp+4),ra
if (
8006d38: 78 05 08 02 mvhi r5,0x802
8006d3c: 38 a5 63 80 ori r5,r5,0x6380
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
8006d40: b8 40 60 00 mv r12,r2
if (
8006d44: 28 a2 00 00 lw r2,(r5+0)
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
8006d48: b8 20 68 00 mv r13,r1
if (
8006d4c: 34 01 00 03 mvi r1,3
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
8006d50: b8 60 58 00 mv r11,r3
if (
8006d54: 5c 41 00 04 bne r2,r1,8006d64 <rtems_heap_allocate_aligned_with_boundary+0x40><== NEVER TAKEN
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
8006d58: fb ff fb 06 calli 8005970 <malloc_is_system_state_OK>
) {
return NULL;
8006d5c: 34 05 00 00 mvi r5,0
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
8006d60: 44 20 00 0a be r1,r0,8006d88 <rtems_heap_allocate_aligned_with_boundary+0x64>
) {
return NULL;
}
malloc_deferred_frees_process();
8006d64: fb ff fb 15 calli 80059b8 <malloc_deferred_frees_process>
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
8006d68: 78 05 08 02 mvhi r5,0x802
8006d6c: 38 a5 50 4c ori r5,r5,0x504c
8006d70: 28 a1 00 00 lw r1,(r5+0)
8006d74: b9 a0 10 00 mv r2,r13
8006d78: b9 80 18 00 mv r3,r12
8006d7c: b9 60 20 00 mv r4,r11
8006d80: f8 00 0e 09 calli 800a5a4 <_Protected_heap_Allocate_aligned_with_boundary>
8006d84: b8 20 28 00 mv r5,r1
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
8006d88: b8 a0 08 00 mv r1,r5
8006d8c: 2b 9d 00 04 lw ra,(sp+4)
8006d90: 2b 8b 00 10 lw r11,(sp+16)
8006d94: 2b 8c 00 0c lw r12,(sp+12)
8006d98: 2b 8d 00 08 lw r13,(sp+8)
8006d9c: 37 9c 00 10 addi sp,sp,16
8006da0: c3 a0 00 00 ret
0800605c <rtems_iterate_over_all_threads>:
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
{
800605c: 37 9c ff e4 addi sp,sp,-28
8006060: 5b 8b 00 1c sw (sp+28),r11
8006064: 5b 8c 00 18 sw (sp+24),r12
8006068: 5b 8d 00 14 sw (sp+20),r13
800606c: 5b 8e 00 10 sw (sp+16),r14
8006070: 5b 8f 00 0c sw (sp+12),r15
8006074: 5b 90 00 08 sw (sp+8),r16
8006078: 5b 9d 00 04 sw (sp+4),ra
800607c: b8 20 78 00 mv r15,r1
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
8006080: 44 20 00 17 be r1,r0,80060dc <rtems_iterate_over_all_threads+0x80><== NEVER TAKEN
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
8006084: 78 02 08 02 mvhi r2,0x802
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
8006088: 78 0b 08 02 mvhi r11,0x802
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
800608c: 38 42 1c c4 ori r2,r2,0x1cc4
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
8006090: 39 6b 1c c8 ori r11,r11,0x1cc8
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
8006094: 34 50 00 10 addi r16,r2,16
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
8006098: 29 61 00 00 lw r1,(r11+0)
if ( !information )
800609c: 34 0e 00 04 mvi r14,4
80060a0: 34 0d 00 01 mvi r13,1
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
80060a4: 28 2c 00 04 lw r12,(r1+4)
if ( !information )
80060a8: 5d 80 00 09 bne r12,r0,80060cc <rtems_iterate_over_all_threads+0x70>
80060ac: e0 00 00 0a bi 80060d4 <rtems_iterate_over_all_threads+0x78>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
80060b0: 29 81 00 1c lw r1,(r12+28)
80060b4: b4 2e 08 00 add r1,r1,r14
80060b8: 28 21 00 00 lw r1,(r1+0)
if ( !the_thread )
80060bc: 44 20 00 02 be r1,r0,80060c4 <rtems_iterate_over_all_threads+0x68>
continue;
(*routine)(the_thread);
80060c0: d9 e0 00 00 call r15
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
80060c4: 35 ad 00 01 addi r13,r13,1
80060c8: 35 ce 00 04 addi r14,r14,4
80060cc: 2d 81 00 10 lhu r1,(r12+16)
80060d0: 50 2d ff f8 bgeu r1,r13,80060b0 <rtems_iterate_over_all_threads+0x54>
80060d4: 35 6b 00 04 addi r11,r11,4
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
80060d8: 5d 70 ff f0 bne r11,r16,8006098 <rtems_iterate_over_all_threads+0x3c>
(*routine)(the_thread);
}
}
}
80060dc: 2b 9d 00 04 lw ra,(sp+4)
80060e0: 2b 8b 00 1c lw r11,(sp+28)
80060e4: 2b 8c 00 18 lw r12,(sp+24)
80060e8: 2b 8d 00 14 lw r13,(sp+20)
80060ec: 2b 8e 00 10 lw r14,(sp+16)
80060f0: 2b 8f 00 0c lw r15,(sp+12)
80060f4: 2b 90 00 08 lw r16,(sp+8)
80060f8: 37 9c 00 1c addi sp,sp,28
80060fc: c3 a0 00 00 ret
0800c90c <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
800c90c: 37 9c ff f8 addi sp,sp,-8
800c910: 5b 8b 00 08 sw (sp+8),r11
800c914: 5b 9d 00 04 sw (sp+4),ra
800c918: b8 20 58 00 mv r11,r1
rtems_libio_lock();
800c91c: fb ff ff 90 calli 800c75c <rtems_libio_lock>
if (iop->sem)
800c920: 29 61 00 30 lw r1,(r11+48)
800c924: 44 20 00 02 be r1,r0,800c92c <rtems_libio_free+0x20> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
800c928: fb ff dd 9f calli 8003fa4 <rtems_semaphore_delete>
iop->flags &= ~LIBIO_FLAGS_OPEN;
800c92c: 29 62 00 18 lw r2,(r11+24)
800c930: 34 01 fe ff mvi r1,-257
800c934: a0 41 08 00 and r1,r2,r1
800c938: 59 61 00 18 sw (r11+24),r1
iop->data1 = rtems_libio_iop_freelist;
800c93c: 78 01 08 01 mvhi r1,0x801
800c940: 38 21 98 5c ori r1,r1,0x985c
800c944: 28 22 00 00 lw r2,(r1+0)
rtems_libio_iop_freelist = iop;
800c948: 58 2b 00 00 sw (r1+0),r11
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
800c94c: 59 62 00 38 sw (r11+56),r2
rtems_libio_iop_freelist = iop;
rtems_libio_unlock();
800c950: fb ff ff 8e calli 800c788 <rtems_libio_unlock>
}
800c954: 2b 9d 00 04 lw ra,(sp+4)
800c958: 2b 8b 00 08 lw r11,(sp+8)
800c95c: 37 9c 00 08 addi sp,sp,8
800c960: c3 a0 00 00 ret
0800282c <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
800282c: 37 9c ff f4 addi sp,sp,-12
8002830: 5b 8b 00 0c sw (sp+12),r11
8002834: 5b 8c 00 08 sw (sp+8),r12
8002838: 5b 9d 00 04 sw (sp+4),ra
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
800283c: 78 01 08 01 mvhi r1,0x801
8002840: 38 21 90 10 ori r1,r1,0x9010
8002844: 28 2c 00 00 lw r12,(r1+0)
8002848: 45 80 00 19 be r12,r0,80028ac <rtems_libio_init+0x80> <== NEVER TAKEN
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
800284c: b9 80 08 00 mv r1,r12
8002850: 34 02 00 40 mvi r2,64
8002854: fb ff ff 0b calli 8002480 <calloc>
8002858: b8 20 58 00 mv r11,r1
800285c: 78 01 08 01 mvhi r1,0x801
8002860: 38 21 98 58 ori r1,r1,0x9858
8002864: 58 2b 00 00 sw (r1+0),r11
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
8002868: 34 01 00 1a mvi r1,26
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)
800286c: 45 60 00 1b be r11,r0,80028d8 <rtems_libio_init+0xac>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
8002870: 78 01 08 01 mvhi r1,0x801
8002874: 38 21 98 5c ori r1,r1,0x985c
8002878: 58 2b 00 00 sw (r1+0),r11
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
800287c: 34 02 00 00 mvi r2,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);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
8002880: b9 60 08 00 mv r1,r11
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
8002884: e0 00 00 02 bi 800288c <rtems_libio_init+0x60>
iop->data1 = iop + 1;
8002888: 58 21 ff f8 sw (r1+-8),r1
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++)
800288c: 34 42 00 01 addi r2,r2,1
8002890: 34 21 00 40 addi r1,r1,64
8002894: 55 82 ff fd bgu r12,r2,8002888 <rtems_libio_init+0x5c>
iop->data1 = iop + 1;
iop->data1 = NULL;
8002898: b9 80 08 00 mv r1,r12
800289c: 34 02 00 06 mvi r2,6
80028a0: f8 00 51 9c calli 8016f10 <__ashlsi3>
80028a4: b5 61 08 00 add r1,r11,r1
80028a8: 58 20 ff f8 sw (r1+-8),r0
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
80028ac: 78 02 08 01 mvhi r2,0x801
80028b0: 38 42 7f 80 ori r2,r2,0x7f80
80028b4: 28 41 00 00 lw r1,(r2+0)
80028b8: 78 05 08 01 mvhi r5,0x801
80028bc: 34 03 00 54 mvi r3,84
80028c0: 34 02 00 01 mvi r2,1
80028c4: 34 04 00 00 mvi r4,0
80028c8: 38 a5 98 60 ori r5,r5,0x9860
80028cc: f8 00 05 39 calli 8003db0 <rtems_semaphore_create>
80028d0: b8 20 18 00 mv r3,r1
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
80028d4: 44 20 00 02 be r1,r0,80028dc <rtems_libio_init+0xb0> <== ALWAYS TAKEN
rtems_fatal_error_occurred( rc );
80028d8: f8 00 07 11 calli 800451c <rtems_fatal_error_occurred>
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
80028dc: 78 02 08 01 mvhi r2,0x801
80028e0: 38 42 90 0c ori r2,r2,0x900c
80028e4: 28 41 00 00 lw r1,(r2+0)
80028e8: 44 23 00 02 be r1,r3,80028f0 <rtems_libio_init+0xc4> <== NEVER TAKEN
(* rtems_fs_init_helper)();
80028ec: d8 20 00 00 call r1
}
80028f0: 2b 9d 00 04 lw ra,(sp+4)
80028f4: 2b 8b 00 0c lw r11,(sp+12)
80028f8: 2b 8c 00 08 lw r12,(sp+8)
80028fc: 37 9c 00 0c addi sp,sp,12
8002900: c3 a0 00 00 ret
08002ac0 <rtems_libio_set_private_env>:
rtems_status_code rtems_libio_set_private_env(void)
{
8002ac0: 37 9c ff c8 addi sp,sp,-56
8002ac4: 5b 8b 00 10 sw (sp+16),r11
8002ac8: 5b 8c 00 0c sw (sp+12),r12
8002acc: 5b 8d 00 08 sw (sp+8),r13
8002ad0: 5b 9d 00 04 sw (sp+4),ra
rtems_filesystem_location_info_t root_loc;
rtems_filesystem_location_info_t current_loc;
rtems_user_env_t *new_env = NULL;
int rv = 0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
8002ad4: 78 0b 08 01 mvhi r11,0x801
}
rtems_status_code rtems_libio_set_private_env(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id task_id = rtems_task_self();
8002ad8: f8 00 03 1b calli 8003744 <rtems_task_self>
rtems_filesystem_location_info_t root_loc;
rtems_filesystem_location_info_t current_loc;
rtems_user_env_t *new_env = NULL;
int rv = 0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
8002adc: 39 6b 32 34 ori r11,r11,0x3234
8002ae0: 34 02 00 01 mvi r2,1
}
rtems_status_code rtems_libio_set_private_env(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id task_id = rtems_task_self();
8002ae4: b8 20 68 00 mv r13,r1
rtems_filesystem_location_info_t root_loc;
rtems_filesystem_location_info_t current_loc;
rtems_user_env_t *new_env = NULL;
int rv = 0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
8002ae8: 34 03 00 00 mvi r3,0
8002aec: b9 60 08 00 mv r1,r11
8002af0: 37 84 00 28 addi r4,sp,40
8002af4: 34 05 00 00 mvi r5,0
8002af8: fb ff fa cb calli 8001624 <rtems_filesystem_evaluate_path>
8002afc: b8 20 60 00 mv r12,r1
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
8002b00: 34 02 00 1a mvi r2,26
rtems_filesystem_location_info_t current_loc;
rtems_user_env_t *new_env = NULL;
int rv = 0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
if (rv != 0)
8002b04: 5c 20 00 43 bne r1,r0,8002c10 <rtems_libio_set_private_env+0x150><== NEVER TAKEN
goto error_0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, ¤t_loc, 0);
8002b08: b9 60 08 00 mv r1,r11
8002b0c: 34 02 00 01 mvi r2,1
8002b10: 34 03 00 00 mvi r3,0
8002b14: 37 84 00 14 addi r4,sp,20
8002b18: 34 05 00 00 mvi r5,0
8002b1c: fb ff fa c2 calli 8001624 <rtems_filesystem_evaluate_path>
if (rv != 0)
8002b20: 5c 2c 00 39 bne r1,r12,8002c04 <rtems_libio_set_private_env+0x144><== NEVER TAKEN
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
rtems_current_user_env == &rtems_global_user_env
8002b24: 78 02 08 01 mvhi r2,0x801
8002b28: 38 42 41 34 ori r2,r2,0x4134
8002b2c: 28 41 00 00 lw r1,(r2+0)
/*
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
8002b30: 78 02 08 01 mvhi r2,0x801
8002b34: 38 42 47 c0 ori r2,r2,0x47c0
8002b38: 44 22 00 03 be r1,r2,8002b44 <rtems_libio_set_private_env+0x84>
rtems_current_user_env == &rtems_global_user_env
|| rtems_current_user_env->task_id != task_id
8002b3c: 28 21 00 00 lw r1,(r1+0)
8002b40: 44 2d 00 0e be r1,r13,8002b78 <rtems_libio_set_private_env+0xb8>
) {
new_env = malloc(sizeof(rtems_user_env_t));
8002b44: 34 01 00 48 mvi r1,72
8002b48: fb ff fc ca calli 8001e70 <malloc>
8002b4c: b8 20 60 00 mv r12,r1
if (new_env == NULL)
8002b50: 44 20 00 2b be r1,r0,8002bfc <rtems_libio_set_private_env+0x13c>
#ifdef HAVE_USERENV_REFCNT
new_env->refcnt = 1;
#endif
sc = rtems_task_variable_add(
8002b54: 78 0b 08 01 mvhi r11,0x801
8002b58: 39 6b 41 34 ori r11,r11,0x4134
8002b5c: 78 03 08 00 mvhi r3,0x800
8002b60: 34 01 00 00 mvi r1,0
8002b64: b9 60 10 00 mv r2,r11
8002b68: 38 63 2a 7c ori r3,r3,0x2a7c
8002b6c: f8 00 03 1b calli 80037d8 <rtems_task_variable_add>
RTEMS_SELF,
(void*)&rtems_current_user_env,
(void(*)(void *))free_user_env
);
if (sc != RTEMS_SUCCESSFUL)
8002b70: 5c 20 00 21 bne r1,r0,8002bf4 <rtems_libio_set_private_env+0x134>
goto error_3;
rtems_current_user_env = new_env;
8002b74: 59 6c 00 00 sw (r11+0),r12
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
8002b78: 78 02 08 01 mvhi r2,0x801
8002b7c: 38 42 41 34 ori r2,r2,0x4134
8002b80: 28 4b 00 00 lw r11,(r2+0)
8002b84: 78 02 08 01 mvhi r2,0x801
8002b88: 38 42 47 c0 ori r2,r2,0x47c0
8002b8c: b9 60 08 00 mv r1,r11
8002b90: 34 03 00 48 mvi r3,72
8002b94: f8 00 2a 95 calli 800d5e8 <memcpy>
* Clone the pathlocs. In contrast to most other code we must _not_ free the
* original locs because what we are trying to do here is forking off clones.
* The reason is a pathloc can be allocated by the file system and needs to
* be freed when deleting the environment.
*/
rtems_filesystem_root = root_loc;
8002b98: 2b 81 00 28 lw r1,(sp+40)
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
rtems_current_user_env->task_id = task_id;
8002b9c: 59 6d 00 00 sw (r11+0),r13
* be freed when deleting the environment.
*/
rtems_filesystem_root = root_loc;
rtems_filesystem_current = current_loc;
return RTEMS_SUCCESSFUL;
8002ba0: 34 02 00 00 mvi r2,0
* Clone the pathlocs. In contrast to most other code we must _not_ free the
* original locs because what we are trying to do here is forking off clones.
* The reason is a pathloc can be allocated by the file system and needs to
* be freed when deleting the environment.
*/
rtems_filesystem_root = root_loc;
8002ba4: 59 61 00 18 sw (r11+24),r1
8002ba8: 2b 81 00 2c lw r1,(sp+44)
8002bac: 59 61 00 1c sw (r11+28),r1
8002bb0: 2b 81 00 30 lw r1,(sp+48)
8002bb4: 59 61 00 20 sw (r11+32),r1
8002bb8: 2b 81 00 34 lw r1,(sp+52)
8002bbc: 59 61 00 24 sw (r11+36),r1
8002bc0: 2b 81 00 38 lw r1,(sp+56)
8002bc4: 59 61 00 28 sw (r11+40),r1
rtems_filesystem_current = current_loc;
8002bc8: 2b 81 00 14 lw r1,(sp+20)
8002bcc: 59 61 00 04 sw (r11+4),r1
8002bd0: 2b 81 00 18 lw r1,(sp+24)
8002bd4: 59 61 00 08 sw (r11+8),r1
8002bd8: 2b 81 00 1c lw r1,(sp+28)
8002bdc: 59 61 00 0c sw (r11+12),r1
8002be0: 2b 81 00 20 lw r1,(sp+32)
8002be4: 59 61 00 10 sw (r11+16),r1
8002be8: 2b 81 00 24 lw r1,(sp+36)
8002bec: 59 61 00 14 sw (r11+20),r1
return RTEMS_SUCCESSFUL;
8002bf0: e0 00 00 08 bi 8002c10 <rtems_libio_set_private_env+0x150>
error_3:
free(new_env);
8002bf4: b9 80 08 00 mv r1,r12
8002bf8: fb ff fa db calli 8001764 <free>
error_2:
rtems_filesystem_freenode(¤t_loc);
8002bfc: 37 81 00 14 addi r1,sp,20
8002c00: fb ff fa d1 calli 8001744 <rtems_filesystem_freenode>
error_1:
rtems_filesystem_freenode(&root_loc);
8002c04: 37 81 00 28 addi r1,sp,40
8002c08: fb ff fa cf calli 8001744 <rtems_filesystem_freenode>
error_0:
return RTEMS_NO_MEMORY;
8002c0c: 34 02 00 1a mvi r2,26
}
8002c10: b8 40 08 00 mv r1,r2
8002c14: 2b 9d 00 04 lw ra,(sp+4)
8002c18: 2b 8b 00 10 lw r11,(sp+16)
8002c1c: 2b 8c 00 0c lw r12,(sp+12)
8002c20: 2b 8d 00 08 lw r13,(sp+8)
8002c24: 37 9c 00 38 addi sp,sp,56
8002c28: c3 a0 00 00 ret
08002c2c <rtems_libio_share_private_env>:
* b) mutex access to rtems_filesystem_current, rtems_filesytem_root
* while changing any of those (chdir(), chroot()).
*/
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
8002c2c: 37 9c ff e8 addi sp,sp,-24
8002c30: 5b 8b 00 14 sw (sp+20),r11
8002c34: 5b 8c 00 10 sw (sp+16),r12
8002c38: 5b 8d 00 0c sw (sp+12),r13
8002c3c: 5b 8e 00 08 sw (sp+8),r14
8002c40: 5b 9d 00 04 sw (sp+4),ra
8002c44: b8 20 70 00 mv r14,r1
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
8002c48: f8 00 02 bf calli 8003744 <rtems_task_self>
8002c4c: b8 20 68 00 mv r13,r1
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
return RTEMS_SUCCESSFUL;
8002c50: 34 0c 00 00 mvi r12,0
/*
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
8002c54: 45 c1 00 11 be r14,r1,8002c98 <rtems_libio_share_private_env+0x6c><== NEVER TAKEN
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
8002c58: 78 0b 08 01 mvhi r11,0x801
8002c5c: 39 6b 41 34 ori r11,r11,0x4134
8002c60: b9 c0 08 00 mv r1,r14
8002c64: b9 60 10 00 mv r2,r11
8002c68: 37 83 00 18 addi r3,sp,24
8002c6c: f8 00 03 0a calli 8003894 <rtems_task_variable_get>
8002c70: b8 20 60 00 mv r12,r1
(void*)&shared_user_env );
/*
* If it was not successful, return the error code
*/
if (sc != RTEMS_SUCCESSFUL)
8002c74: 5c 20 00 09 bne r1,r0,8002c98 <rtems_libio_share_private_env+0x6c>
* If we have a current environment in place, we need to
* free it, since we will be sharing the variable with the
* shared_user_env
*/
if (rtems_current_user_env->task_id==current_task_id) {
8002c78: 29 61 00 00 lw r1,(r11+0)
8002c7c: 28 22 00 00 lw r2,(r1+0)
8002c80: 5c 4d 00 02 bne r2,r13,8002c88 <rtems_libio_share_private_env+0x5c>
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
8002c84: fb ff ff 7e calli 8002a7c <free_user_env>
}
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
8002c88: 2b 82 00 18 lw r2,(sp+24)
8002c8c: 78 01 08 01 mvhi r1,0x801
8002c90: 38 21 41 34 ori r1,r1,0x4134
8002c94: 58 22 00 00 sw (r1+0),r2
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
8002c98: b9 80 08 00 mv r1,r12
8002c9c: 2b 9d 00 04 lw ra,(sp+4)
8002ca0: 2b 8b 00 14 lw r11,(sp+20)
8002ca4: 2b 8c 00 10 lw r12,(sp+16)
8002ca8: 2b 8d 00 0c lw r13,(sp+12)
8002cac: 2b 8e 00 08 lw r14,(sp+8)
8002cb0: 37 9c 00 18 addi sp,sp,24
8002cb4: c3 a0 00 00 ret
0800c804 <rtems_libio_to_fcntl_flags>:
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
800c804: 20 24 00 06 andi r4,r1,0x6
800c808: 34 03 00 06 mvi r3,6
fcntl_flags |= O_RDWR;
800c80c: 34 02 00 02 mvi r2,2
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
800c810: 44 83 00 06 be r4,r3,800c828 <rtems_libio_to_fcntl_flags+0x24>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
800c814: 20 23 00 02 andi r3,r1,0x2
fcntl_flags |= O_RDONLY;
800c818: 34 02 00 00 mvi r2,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) {
800c81c: 5c 60 00 03 bne r3,r0,800c828 <rtems_libio_to_fcntl_flags+0x24><== ALWAYS TAKEN
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
800c820: 20 22 00 04 andi r2,r1,0x4 <== NOT EXECUTED
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
800c824: 7c 42 00 00 cmpnei r2,r2,0 <== NOT EXECUTED
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
800c828: 20 23 00 01 andi r3,r1,0x1
800c82c: 44 60 00 02 be r3,r0,800c834 <rtems_libio_to_fcntl_flags+0x30>
fcntl_flags |= O_NONBLOCK;
800c830: 38 42 40 00 ori r2,r2,0x4000
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
800c834: 20 23 02 00 andi r3,r1,0x200
800c838: 44 60 00 02 be r3,r0,800c840 <rtems_libio_to_fcntl_flags+0x3c>
fcntl_flags |= O_APPEND;
800c83c: 38 42 00 08 ori r2,r2,0x8
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
800c840: 20 21 04 00 andi r1,r1,0x400
800c844: 44 20 00 02 be r1,r0,800c84c <rtems_libio_to_fcntl_flags+0x48>
fcntl_flags |= O_CREAT;
800c848: 38 42 02 00 ori r2,r2,0x200
}
return fcntl_flags;
}
800c84c: b8 40 08 00 mv r1,r2
800c850: c3 a0 00 00 ret
08005e54 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
8005e54: 37 9c ff f8 addi sp,sp,-8
8005e58: 5b 9d 00 04 sw (sp+4),ra
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
8005e5c: 78 03 08 02 mvhi r3,0x802
8005e60: 38 63 50 4c ori r3,r3,0x504c
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
8005e64: b8 20 10 00 mv r2,r1
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
8005e68: 28 61 00 00 lw r1,(r3+0)
8005e6c: 37 83 00 08 addi r3,sp,8
8005e70: f8 00 12 16 calli 800a6c8 <_Protected_heap_Get_block_size>
8005e74: 44 20 00 0b be r1,r0,8005ea0 <rtems_malloc_statistics_at_free+0x4c><== NEVER TAKEN
MSBUMP(lifetime_freed, size);
8005e78: 78 01 08 02 mvhi r1,0x802
8005e7c: 38 21 60 c8 ori r1,r1,0x60c8
8005e80: 2b 83 00 08 lw r3,(sp+8)
8005e84: 28 22 00 2c lw r2,(r1+44)
8005e88: 28 24 00 28 lw r4,(r1+40)
8005e8c: b4 62 10 00 add r2,r3,r2
8005e90: f4 62 18 00 cmpgu r3,r3,r2
8005e94: 58 22 00 2c sw (r1+44),r2
8005e98: b4 64 18 00 add r3,r3,r4
8005e9c: 58 23 00 28 sw (r1+40),r3
}
}
8005ea0: 2b 9d 00 04 lw ra,(sp+4)
8005ea4: 37 9c 00 08 addi sp,sp,8
8005ea8: c3 a0 00 00 ret
08005eac <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
8005eac: 37 9c ff f8 addi sp,sp,-8
8005eb0: 5b 9d 00 04 sw (sp+4),ra
uintptr_t actual_size = 0;
8005eb4: 5b 80 00 08 sw (sp+8),r0
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
8005eb8: b8 20 10 00 mv r2,r1
uintptr_t actual_size = 0;
uint32_t current_depth;
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
8005ebc: 44 20 00 15 be r1,r0,8005f10 <rtems_malloc_statistics_at_malloc+0x64><== NEVER TAKEN
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
8005ec0: 78 03 08 02 mvhi r3,0x802
8005ec4: 38 63 50 4c ori r3,r3,0x504c
8005ec8: 28 61 00 00 lw r1,(r3+0)
8005ecc: 37 83 00 08 addi r3,sp,8
8005ed0: f8 00 11 fe calli 800a6c8 <_Protected_heap_Get_block_size>
MSBUMP(lifetime_allocated, actual_size);
8005ed4: 78 01 08 02 mvhi r1,0x802
8005ed8: 38 21 60 c8 ori r1,r1,0x60c8
8005edc: 2b 83 00 08 lw r3,(sp+8)
8005ee0: 28 22 00 24 lw r2,(r1+36)
8005ee4: 28 24 00 20 lw r4,(r1+32)
8005ee8: b4 62 10 00 add r2,r3,r2
8005eec: f4 62 18 00 cmpgu r3,r3,r2
8005ef0: 58 22 00 24 sw (r1+36),r2
8005ef4: b4 64 18 00 add r3,r3,r4
8005ef8: 58 23 00 20 sw (r1+32),r3
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
8005efc: 28 23 00 2c lw r3,(r1+44)
8005f00: c8 43 10 00 sub r2,r2,r3
if (current_depth > s->max_depth)
8005f04: 28 23 00 18 lw r3,(r1+24)
8005f08: 50 62 00 02 bgeu r3,r2,8005f10 <rtems_malloc_statistics_at_malloc+0x64>
s->max_depth = current_depth;
8005f0c: 58 22 00 18 sw (r1+24),r2
}
8005f10: 2b 9d 00 04 lw ra,(sp+4)
8005f14: 37 9c 00 08 addi sp,sp,8
8005f18: c3 a0 00 00 ret
0800cd5c <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
800cd5c: 37 9c ff ec addi sp,sp,-20
800cd60: 5b 8b 00 14 sw (sp+20),r11
800cd64: 5b 8c 00 10 sw (sp+16),r12
800cd68: 5b 8d 00 0c sw (sp+12),r13
800cd6c: 5b 8e 00 08 sw (sp+8),r14
800cd70: 5b 9d 00 04 sw (sp+4),ra
/*
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
800cd74: 34 0c 00 16 mvi r12,22
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
800cd78: b8 20 58 00 mv r11,r1
800cd7c: b8 40 68 00 mv r13,r2
800cd80: b8 60 70 00 mv r14,r3
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
800cd84: 44 20 00 1d be r1,r0,800cdf8 <rtems_memalign+0x9c>
return EINVAL;
*pointer = NULL;
800cd88: 58 20 00 00 sw (r1+0),r0
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
800cd8c: 78 01 08 01 mvhi r1,0x801
800cd90: 38 21 9a e8 ori r1,r1,0x9ae8
800cd94: 28 22 00 00 lw r2,(r1+0)
800cd98: 34 01 00 03 mvi r1,3
800cd9c: 5c 41 00 03 bne r2,r1,800cda8 <rtems_memalign+0x4c> <== NEVER TAKEN
!malloc_is_system_state_OK() )
800cda0: fb ff d6 d9 calli 8002904 <malloc_is_system_state_OK>
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
800cda4: 44 20 00 15 be r1,r0,800cdf8 <rtems_memalign+0x9c> <== NEVER TAKEN
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
800cda8: fb ff d6 e9 calli 800294c <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
800cdac: 78 01 08 01 mvhi r1,0x801
800cdb0: 38 21 90 4c ori r1,r1,0x904c
800cdb4: 28 21 00 00 lw r1,(r1+0)
800cdb8: b9 a0 18 00 mv r3,r13
800cdbc: b9 c0 10 00 mv r2,r14
800cdc0: 34 04 00 00 mvi r4,0
800cdc4: fb ff e4 59 calli 8005f28 <_Protected_heap_Allocate_aligned_with_boundary>
800cdc8: b8 20 68 00 mv r13,r1
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
return ENOMEM;
800cdcc: 34 0c 00 0c mvi r12,12
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
800cdd0: 44 20 00 0a be r1,r0,800cdf8 <rtems_memalign+0x9c>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
800cdd4: 78 02 08 01 mvhi r2,0x801
800cdd8: 38 42 96 f0 ori r2,r2,0x96f0
800cddc: 28 41 00 00 lw r1,(r2+0)
800cde0: 44 20 00 04 be r1,r0,800cdf0 <rtems_memalign+0x94>
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
800cde4: 28 22 00 04 lw r2,(r1+4)
800cde8: b9 60 08 00 mv r1,r11
800cdec: d8 40 00 00 call r2
*pointer = return_this;
800cdf0: 59 6d 00 00 sw (r11+0),r13
return 0;
800cdf4: 34 0c 00 00 mvi r12,0
}
800cdf8: b9 80 08 00 mv r1,r12
800cdfc: 2b 9d 00 04 lw ra,(sp+4)
800ce00: 2b 8b 00 14 lw r11,(sp+20)
800ce04: 2b 8c 00 10 lw r12,(sp+16)
800ce08: 2b 8d 00 0c lw r13,(sp+12)
800ce0c: 2b 8e 00 08 lw r14,(sp+8)
800ce10: 37 9c 00 14 addi sp,sp,20
800ce14: c3 a0 00 00 ret
0800acf4 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
800acf4: 37 9c ff 84 addi sp,sp,-124
800acf8: 5b 8b 00 34 sw (sp+52),r11
800acfc: 5b 8c 00 30 sw (sp+48),r12
800ad00: 5b 8d 00 2c sw (sp+44),r13
800ad04: 5b 8e 00 28 sw (sp+40),r14
800ad08: 5b 8f 00 24 sw (sp+36),r15
800ad0c: 5b 90 00 20 sw (sp+32),r16
800ad10: 5b 91 00 1c sw (sp+28),r17
800ad14: 5b 92 00 18 sw (sp+24),r18
800ad18: 5b 93 00 14 sw (sp+20),r19
800ad1c: 5b 94 00 10 sw (sp+16),r20
800ad20: 5b 95 00 0c sw (sp+12),r21
800ad24: 5b 96 00 08 sw (sp+8),r22
800ad28: 5b 9d 00 04 sw (sp+4),ra
800ad2c: b8 40 b0 00 mv r22,r2
int success = 0;
char *dup_path = strdup(path);
800ad30: f8 00 12 48 calli 800f650 <strdup>
800ad34: b8 20 60 00 mv r12,r1
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
800ad38: 34 01 ff ff mvi r1,-1
rtems_mkdir(const char *path, mode_t mode)
{
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
800ad3c: 45 80 00 4d be r12,r0,800ae70 <rtems_mkdir+0x17c> <== NEVER TAKEN
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
800ad40: 41 8b 00 00 lbu r11,(r12+0)
800ad44: 34 0e 00 00 mvi r14,0
800ad48: 34 01 00 01 mvi r1,1
++p;
800ad4c: 65 6b 00 2f cmpei r11,r11,47
retval = 0;
break;
}
}
if (!last)
*p = '/';
800ad50: 34 15 00 2f mvi r21,47
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
800ad54: b5 8b 58 00 add r11,r12,r11
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
800ad58: 34 14 00 11 mvi r20,17
if (stat(path, &sb) < 0) {
800ad5c: 37 93 00 38 addi r19,sp,56
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
800ad60: 34 12 40 00 mvi r18,16384
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
800ad64: 34 11 00 15 mvi r17,21
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
800ad68: 34 10 ff 3f mvi r16,-193
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
800ad6c: 34 0f 00 2f mvi r15,47
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
800ad70: 41 64 00 00 lbu r4,(r11+0)
last = 1;
800ad74: 34 03 00 01 mvi r3,1
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
800ad78: 44 80 00 03 be r4,r0,800ad84 <rtems_mkdir+0x90>
last = 1;
else if (p[0] != '/')
800ad7c: 5c 8f 00 33 bne r4,r15,800ae48 <rtems_mkdir+0x154>
800ad80: 34 03 00 00 mvi r3,0
continue;
*p = '\0';
800ad84: 31 60 00 00 sb (r11+0),r0
if (!last && p[1] == '\0')
800ad88: 34 0d 00 01 mvi r13,1
800ad8c: 5c 60 00 03 bne r3,r0,800ad98 <rtems_mkdir+0xa4>
800ad90: 41 6d 00 01 lbu r13,(r11+1)
800ad94: 65 ad 00 00 cmpei r13,r13,0
last = 1;
if (first) {
800ad98: 44 20 00 06 be r1,r0,800adb0 <rtems_mkdir+0xbc>
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
800ad9c: 34 01 00 00 mvi r1,0
800ada0: f8 00 00 79 calli 800af84 <umask>
800ada4: b8 20 70 00 mv r14,r1
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
800ada8: a0 30 08 00 and r1,r1,r16
800adac: f8 00 00 76 calli 800af84 <umask>
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
800adb0: 34 03 01 ff mvi r3,511
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
800adb4: 45 a0 00 04 be r13,r0,800adc4 <rtems_mkdir+0xd0>
(void)umask(oumask);
800adb8: b9 c0 08 00 mv r1,r14
800adbc: f8 00 00 72 calli 800af84 <umask>
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
800adc0: ba c0 18 00 mv r3,r22
800adc4: b9 80 08 00 mv r1,r12
800adc8: b8 60 10 00 mv r2,r3
800adcc: fb ff e0 b4 calli 800309c <mkdir>
800add0: 4c 20 00 1b bge r1,r0,800ae3c <rtems_mkdir+0x148>
if (errno == EEXIST || errno == EISDIR) {
800add4: f8 00 0d a1 calli 800e458 <__errno>
800add8: 28 21 00 00 lw r1,(r1+0)
800addc: 44 34 00 04 be r1,r20,800adec <rtems_mkdir+0xf8>
800ade0: f8 00 0d 9e calli 800e458 <__errno>
800ade4: 28 21 00 00 lw r1,(r1+0)
800ade8: 5c 31 00 1a bne r1,r17,800ae50 <rtems_mkdir+0x15c> <== ALWAYS TAKEN
if (stat(path, &sb) < 0) {
800adec: b9 80 08 00 mv r1,r12
800adf0: ba 60 10 00 mv r2,r19
800adf4: f8 00 00 32 calli 800aebc <stat>
800adf8: 48 01 00 16 bg r0,r1,800ae50 <rtems_mkdir+0x15c> <== NEVER TAKEN
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
800adfc: 2b 81 00 44 lw r1,(sp+68)
800ae00: 20 21 f0 00 andi r1,r1,0xf000
800ae04: 44 32 00 0c be r1,r18,800ae34 <rtems_mkdir+0x140>
if (last)
800ae08: 45 a0 00 06 be r13,r0,800ae20 <rtems_mkdir+0x12c>
errno = EEXIST;
800ae0c: f8 00 0d 93 calli 800e458 <__errno>
800ae10: 34 02 00 11 mvi r2,17
800ae14: 58 22 00 00 sw (r1+0),r2
else
errno = ENOTDIR;
retval = 0;
800ae18: 34 0b 00 00 mvi r11,0
800ae1c: e0 00 00 11 bi 800ae60 <rtems_mkdir+0x16c>
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
errno = EEXIST;
else
errno = ENOTDIR;
800ae20: f8 00 0d 8e calli 800e458 <__errno>
800ae24: 34 02 00 14 mvi r2,20
800ae28: 58 22 00 00 sw (r1+0),r2
retval = 0;
800ae2c: 34 0b 00 00 mvi r11,0
800ae30: e0 00 00 0a bi 800ae58 <rtems_mkdir+0x164>
break;
}
if (last)
800ae34: 5d a0 00 1e bne r13,r0,800aeac <rtems_mkdir+0x1b8>
800ae38: e0 00 00 02 bi 800ae40 <rtems_mkdir+0x14c>
} else {
retval = 0;
break;
}
}
if (!last)
800ae3c: 5d a0 00 1e bne r13,r0,800aeb4 <rtems_mkdir+0x1c0>
*p = '/';
800ae40: 31 75 00 00 sb (r11+0),r21
800ae44: 34 01 00 00 mvi r1,0
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
800ae48: 35 6b 00 01 addi r11,r11,1
800ae4c: e3 ff ff c9 bi 800ad70 <rtems_mkdir+0x7c>
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
retval = 0;
800ae50: 34 0b 00 00 mvi r11,0
}
}
if (!last)
*p = '/';
}
if (!first && !last)
800ae54: 5d a0 00 03 bne r13,r0,800ae60 <rtems_mkdir+0x16c> <== ALWAYS TAKEN
(void)umask(oumask);
800ae58: b9 c0 08 00 mv r1,r14
800ae5c: f8 00 00 4a calli 800af84 <umask>
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
800ae60: b9 80 08 00 mv r1,r12
800ae64: fb ff de 82 calli 800286c <free>
}
return success != 0 ? 0 : -1;
800ae68: 7d 61 00 00 cmpnei r1,r11,0
800ae6c: 34 21 ff ff addi r1,r1,-1
}
800ae70: 2b 9d 00 04 lw ra,(sp+4)
800ae74: 2b 8b 00 34 lw r11,(sp+52)
800ae78: 2b 8c 00 30 lw r12,(sp+48)
800ae7c: 2b 8d 00 2c lw r13,(sp+44)
800ae80: 2b 8e 00 28 lw r14,(sp+40)
800ae84: 2b 8f 00 24 lw r15,(sp+36)
800ae88: 2b 90 00 20 lw r16,(sp+32)
800ae8c: 2b 91 00 1c lw r17,(sp+28)
800ae90: 2b 92 00 18 lw r18,(sp+24)
800ae94: 2b 93 00 14 lw r19,(sp+20)
800ae98: 2b 94 00 10 lw r20,(sp+16)
800ae9c: 2b 95 00 0c lw r21,(sp+12)
800aea0: 2b 96 00 08 lw r22,(sp+8)
800aea4: 37 9c 00 7c addi sp,sp,124
800aea8: c3 a0 00 00 ret
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
retval = 2;
800aeac: 34 0b 00 02 mvi r11,2
800aeb0: e3 ff ff ec bi 800ae60 <rtems_mkdir+0x16c>
} else {
retval = 0;
break;
}
}
if (!last)
800aeb4: 34 0b 00 01 mvi r11,1
800aeb8: e3 ff ff ea bi 800ae60 <rtems_mkdir+0x16c>
080119ec <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
80119ec: 37 9c ff d8 addi sp,sp,-40
80119f0: 5b 8b 00 28 sw (sp+40),r11
80119f4: 5b 8c 00 24 sw (sp+36),r12
80119f8: 5b 8d 00 20 sw (sp+32),r13
80119fc: 5b 8e 00 1c sw (sp+28),r14
8011a00: 5b 8f 00 18 sw (sp+24),r15
8011a04: 5b 90 00 14 sw (sp+20),r16
8011a08: 5b 91 00 10 sw (sp+16),r17
8011a0c: 5b 92 00 0c sw (sp+12),r18
8011a10: 5b 93 00 08 sw (sp+8),r19
8011a14: 5b 9d 00 04 sw (sp+4),ra
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
8011a18: 34 07 00 03 mvi r7,3
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
8011a1c: b8 20 88 00 mv r17,r1
8011a20: b8 40 70 00 mv r14,r2
8011a24: b8 60 78 00 mv r15,r3
8011a28: b8 80 60 00 mv r12,r4
8011a2c: b8 a0 98 00 mv r19,r5
8011a30: b8 c0 80 00 mv r16,r6
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
8011a34: 44 20 00 36 be r1,r0,8011b0c <rtems_partition_create+0x120>
return RTEMS_INVALID_NAME;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
8011a38: 34 07 00 09 mvi r7,9
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
8011a3c: 44 40 00 34 be r2,r0,8011b0c <rtems_partition_create+0x120>
return RTEMS_INVALID_ADDRESS;
if ( !id )
8011a40: 44 c0 00 33 be r6,r0,8011b0c <rtems_partition_create+0x120><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
8011a44: 64 82 00 00 cmpei r2,r4,0
8011a48: 64 61 00 00 cmpei r1,r3,0
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
8011a4c: 34 07 00 08 mvi r7,8
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
8011a50: b8 41 08 00 or r1,r2,r1
8011a54: 5c 20 00 2e bne r1,r0,8011b0c <rtems_partition_create+0x120>
8011a58: 54 83 00 2d bgu r4,r3,8011b0c <rtems_partition_create+0x120>
*/
RTEMS_INLINE_ROUTINE bool _Partition_Is_buffer_size_aligned (
uint32_t buffer_size
)
{
return ((buffer_size % CPU_PARTITION_ALIGNMENT) == 0);
8011a5c: 20 81 00 07 andi r1,r4,0x7
8011a60: 5c 20 00 2b bne r1,r0,8011b0c <rtems_partition_create+0x120>
)
{
#if (CPU_ALIGNMENT == 0)
return true;
#else
return (((uintptr_t)address % CPU_ALIGNMENT) == 0);
8011a64: 21 d2 00 07 andi r18,r14,0x7
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
return RTEMS_INVALID_ADDRESS;
8011a68: 34 07 00 09 mvi r7,9
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
8011a6c: 5e 41 00 28 bne r18,r1,8011b0c <rtems_partition_create+0x120>
8011a70: 78 02 08 04 mvhi r2,0x804
8011a74: 38 42 0d 10 ori r2,r2,0xd10
8011a78: 28 41 00 00 lw r1,(r2+0)
8011a7c: 34 21 00 01 addi r1,r1,1
8011a80: 58 41 00 00 sw (r2+0),r1
* This function allocates a partition control block from
* the inactive chain of free partition control blocks.
*/
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void )
{
return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
8011a84: 78 0d 08 04 mvhi r13,0x804
8011a88: 39 ad 0b 68 ori r13,r13,0xb68
8011a8c: b9 a0 08 00 mv r1,r13
8011a90: f8 00 16 13 calli 80172dc <_Objects_Allocate>
8011a94: b8 20 58 00 mv r11,r1
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
8011a98: 5c 32 00 04 bne r1,r18,8011aa8 <rtems_partition_create+0xbc>
_Thread_Enable_dispatch();
8011a9c: f8 00 1b f6 calli 8018a74 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
8011aa0: 34 07 00 05 mvi r7,5
8011aa4: e0 00 00 1a bi 8011b0c <rtems_partition_create+0x120>
}
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
8011aa8: 58 2c 00 18 sw (r1+24),r12
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
_Chain_Initialize( &the_partition->Memory, starting_address,
length / buffer_size, buffer_size );
8011aac: b9 80 10 00 mv r2,r12
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
8011ab0: 58 2e 00 10 sw (r1+16),r14
the_partition->length = length;
8011ab4: 58 2f 00 14 sw (r1+20),r15
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
8011ab8: 58 33 00 1c sw (r1+28),r19
the_partition->number_of_used_blocks = 0;
8011abc: 58 20 00 20 sw (r1+32),r0
_Chain_Initialize( &the_partition->Memory, starting_address,
8011ac0: 34 32 00 24 addi r18,r1,36
length / buffer_size, buffer_size );
8011ac4: b9 e0 08 00 mv r1,r15
8011ac8: f8 00 7f 87 calli 80318e4 <__udivsi3>
8011acc: b8 20 18 00 mv r3,r1
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
_Chain_Initialize( &the_partition->Memory, starting_address,
8011ad0: b9 80 20 00 mv r4,r12
8011ad4: ba 40 08 00 mv r1,r18
8011ad8: b9 c0 10 00 mv r2,r14
8011adc: f8 00 0e fb calli 80156c8 <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
8011ae0: 29 6c 00 08 lw r12,(r11+8)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8011ae4: 29 ad 00 1c lw r13,(r13+28)
8011ae8: 34 02 00 02 mvi r2,2
8011aec: 21 81 ff ff andi r1,r12,0xffff
8011af0: fb ff f1 01 calli 800def4 <__ashlsi3>
8011af4: b5 a1 08 00 add r1,r13,r1
8011af8: 58 2b 00 00 sw (r1+0),r11
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
8011afc: 59 71 00 0c sw (r11+12),r17
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
8011b00: 5a 0c 00 00 sw (r16+0),r12
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
8011b04: f8 00 1b dc calli 8018a74 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8011b08: 34 07 00 00 mvi r7,0
}
8011b0c: b8 e0 08 00 mv r1,r7
8011b10: 2b 9d 00 04 lw ra,(sp+4)
8011b14: 2b 8b 00 28 lw r11,(sp+40)
8011b18: 2b 8c 00 24 lw r12,(sp+36)
8011b1c: 2b 8d 00 20 lw r13,(sp+32)
8011b20: 2b 8e 00 1c lw r14,(sp+28)
8011b24: 2b 8f 00 18 lw r15,(sp+24)
8011b28: 2b 90 00 14 lw r16,(sp+20)
8011b2c: 2b 91 00 10 lw r17,(sp+16)
8011b30: 2b 92 00 0c lw r18,(sp+12)
8011b34: 2b 93 00 08 lw r19,(sp+8)
8011b38: 37 9c 00 28 addi sp,sp,40
8011b3c: c3 a0 00 00 ret
08010fd8 <rtems_port_internal_to_external>:
rtems_status_code rtems_port_internal_to_external(
rtems_id id,
void *internal,
void **external
)
{
8010fd8: 37 9c ff f0 addi sp,sp,-16
8010fdc: 5b 8b 00 0c sw (sp+12),r11
8010fe0: 5b 8c 00 08 sw (sp+8),r12
8010fe4: 5b 9d 00 04 sw (sp+4),ra
8010fe8: b8 20 20 00 mv r4,r1
8010fec: b8 40 60 00 mv r12,r2
8010ff0: b8 60 58 00 mv r11,r3
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
return RTEMS_INVALID_ADDRESS;
8010ff4: 34 01 00 09 mvi r1,9
{
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
8010ff8: 44 60 00 15 be r3,r0,801104c <rtems_port_internal_to_external+0x74><== NEVER TAKEN
8010ffc: 78 01 08 04 mvhi r1,0x804
8011000: b8 80 10 00 mv r2,r4
8011004: 38 21 0b 28 ori r1,r1,0xb28
8011008: 37 83 00 10 addi r3,sp,16
801100c: f8 00 1a 6d calli 80179c0 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
8011010: 2b 82 00 10 lw r2,(sp+16)
8011014: 5c 40 00 0d bne r2,r0,8011048 <rtems_port_internal_to_external+0x70>
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
8011018: 28 23 00 10 lw r3,(r1+16)
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
801101c: 28 22 00 18 lw r2,(r1+24)
8011020: c9 83 18 00 sub r3,r12,r3
8011024: 50 43 00 03 bgeu r2,r3,8011030 <rtems_port_internal_to_external+0x58>
*external = internal;
8011028: 59 6c 00 00 sw (r11+0),r12
801102c: e0 00 00 04 bi 801103c <rtems_port_internal_to_external+0x64>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
8011030: 28 21 00 14 lw r1,(r1+20)
8011034: b4 23 18 00 add r3,r1,r3
else
*external = _Addresses_Add_offset( the_port->external_base,
8011038: 59 63 00 00 sw (r11+0),r3
ending );
_Thread_Enable_dispatch();
801103c: f8 00 1e 8e calli 8018a74 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8011040: 34 01 00 00 mvi r1,0
8011044: e0 00 00 02 bi 801104c <rtems_port_internal_to_external+0x74>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8011048: 34 01 00 04 mvi r1,4
}
801104c: 2b 9d 00 04 lw ra,(sp+4)
8011050: 2b 8b 00 0c lw r11,(sp+12)
8011054: 2b 8c 00 08 lw r12,(sp+8)
8011058: 37 9c 00 10 addi sp,sp,16
801105c: c3 a0 00 00 ret
0800b85c <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
800b85c: 37 9c ff f4 addi sp,sp,-12
800b860: 5b 8b 00 08 sw (sp+8),r11
800b864: 5b 9d 00 04 sw (sp+4),ra
800b868: b8 20 18 00 mv r3,r1
800b86c: b8 40 58 00 mv r11,r2
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
return RTEMS_INVALID_ADDRESS;
800b870: 34 01 00 09 mvi r1,9
Objects_Locations location;
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
800b874: 44 40 00 28 be r2,r0,800b914 <rtems_rate_monotonic_get_statistics+0xb8><== NEVER TAKEN
800b878: 78 01 08 02 mvhi r1,0x802
800b87c: b8 60 10 00 mv r2,r3
800b880: 38 21 19 00 ori r1,r1,0x1900
800b884: 37 83 00 0c addi r3,sp,12
800b888: fb ff ec 4f calli 80069c4 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
800b88c: 2b 82 00 0c lw r2,(sp+12)
800b890: 5c 40 00 20 bne r2,r0,800b910 <rtems_rate_monotonic_get_statistics+0xb4>
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
800b894: 28 22 00 54 lw r2,(r1+84)
800b898: 59 62 00 00 sw (r11+0),r2
dst->missed_count = src->missed_count;
800b89c: 28 22 00 58 lw r2,(r1+88)
800b8a0: 59 62 00 04 sw (r11+4),r2
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec( &src->min_cpu_time, &dst->min_cpu_time );
800b8a4: 28 22 00 5c lw r2,(r1+92)
800b8a8: 59 62 00 08 sw (r11+8),r2
800b8ac: 28 22 00 60 lw r2,(r1+96)
800b8b0: 59 62 00 0c sw (r11+12),r2
_Timestamp_To_timespec( &src->max_cpu_time, &dst->max_cpu_time );
800b8b4: 28 22 00 64 lw r2,(r1+100)
800b8b8: 59 62 00 10 sw (r11+16),r2
800b8bc: 28 22 00 68 lw r2,(r1+104)
800b8c0: 59 62 00 14 sw (r11+20),r2
_Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
800b8c4: 28 22 00 6c lw r2,(r1+108)
800b8c8: 59 62 00 18 sw (r11+24),r2
800b8cc: 28 22 00 70 lw r2,(r1+112)
800b8d0: 59 62 00 1c sw (r11+28),r2
_Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time );
800b8d4: 28 22 00 74 lw r2,(r1+116)
800b8d8: 59 62 00 20 sw (r11+32),r2
800b8dc: 28 22 00 78 lw r2,(r1+120)
800b8e0: 59 62 00 24 sw (r11+36),r2
_Timestamp_To_timespec( &src->max_wall_time, &dst->max_wall_time );
800b8e4: 28 22 00 7c lw r2,(r1+124)
800b8e8: 59 62 00 28 sw (r11+40),r2
800b8ec: 28 22 00 80 lw r2,(r1+128)
800b8f0: 59 62 00 2c sw (r11+44),r2
_Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time );
800b8f4: 28 22 00 84 lw r2,(r1+132)
800b8f8: 28 21 00 88 lw r1,(r1+136)
800b8fc: 59 62 00 30 sw (r11+48),r2
800b900: 59 61 00 34 sw (r11+52),r1
dst->min_wall_time = src->min_wall_time;
dst->max_wall_time = src->max_wall_time;
dst->total_wall_time = src->total_wall_time;
#endif
_Thread_Enable_dispatch();
800b904: fb ff f0 02 calli 800790c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
800b908: 34 01 00 00 mvi r1,0
800b90c: e0 00 00 02 bi 800b914 <rtems_rate_monotonic_get_statistics+0xb8>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
800b910: 34 01 00 04 mvi r1,4
}
800b914: 2b 9d 00 04 lw ra,(sp+4)
800b918: 2b 8b 00 08 lw r11,(sp+8)
800b91c: 37 9c 00 0c addi sp,sp,12
800b920: c3 a0 00 00 ret
080040f4 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
80040f4: 37 9c ff e8 addi sp,sp,-24
80040f8: 5b 8b 00 14 sw (sp+20),r11
80040fc: 5b 8c 00 10 sw (sp+16),r12
8004100: 5b 8d 00 0c sw (sp+12),r13
8004104: 5b 8e 00 08 sw (sp+8),r14
8004108: 5b 9d 00 04 sw (sp+4),ra
800410c: b8 20 60 00 mv r12,r1
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
8004110: 78 01 08 02 mvhi r1,0x802
8004114: b8 40 68 00 mv r13,r2
8004118: 38 21 19 00 ori r1,r1,0x1900
800411c: b9 80 10 00 mv r2,r12
8004120: 37 83 00 18 addi r3,sp,24
8004124: f8 00 0a 28 calli 80069c4 <_Objects_Get>
8004128: b8 20 58 00 mv r11,r1
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
800412c: 2b 81 00 18 lw r1,(sp+24)
8004130: 5c 20 00 5f bne r1,r0,80042ac <rtems_rate_monotonic_period+0x1b8>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
8004134: 78 03 08 02 mvhi r3,0x802
8004138: 38 63 1e d4 ori r3,r3,0x1ed4
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
800413c: 29 62 00 40 lw r2,(r11+64)
8004140: 28 61 00 0c lw r1,(r3+12)
8004144: 44 41 00 04 be r2,r1,8004154 <rtems_rate_monotonic_period+0x60>
_Thread_Enable_dispatch();
8004148: f8 00 0d f1 calli 800790c <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
800414c: 34 0c 00 17 mvi r12,23
8004150: e0 00 00 58 bi 80042b0 <rtems_rate_monotonic_period+0x1bc>
}
if ( length == RTEMS_PERIOD_STATUS ) {
8004154: 5d a0 00 0d bne r13,r0,8004188 <rtems_rate_monotonic_period+0x94>
switch ( the_period->state ) {
8004158: 29 61 00 38 lw r1,(r11+56)
800415c: 34 02 00 04 mvi r2,4
8004160: 34 0c 00 00 mvi r12,0
8004164: 54 22 00 07 bgu r1,r2,8004180 <rtems_rate_monotonic_period+0x8c><== NEVER TAKEN
8004168: 78 0b 08 01 mvhi r11,0x801
800416c: 34 02 00 02 mvi r2,2
8004170: fb ff f4 47 calli 800128c <__ashlsi3>
8004174: 39 6b ea 48 ori r11,r11,0xea48
8004178: b5 61 08 00 add r1,r11,r1
800417c: 28 2c 00 00 lw r12,(r1+0)
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
8004180: f8 00 0d e3 calli 800790c <_Thread_Enable_dispatch>
return( return_value );
8004184: e0 00 00 4b bi 80042b0 <rtems_rate_monotonic_period+0x1bc>
}
_ISR_Disable( level );
8004188: 90 00 70 00 rcsr r14,IE
800418c: 34 01 ff fe mvi r1,-2
8004190: a1 c1 08 00 and r1,r14,r1
8004194: d0 01 00 00 wcsr IE,r1
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
8004198: 29 63 00 38 lw r3,(r11+56)
800419c: 5c 60 00 13 bne r3,r0,80041e8 <rtems_rate_monotonic_period+0xf4>
_ISR_Enable( level );
80041a0: d0 0e 00 00 wcsr IE,r14
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
80041a4: b9 60 08 00 mv r1,r11
80041a8: fb ff ff 6e calli 8003f60 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
80041ac: 34 01 00 02 mvi r1,2
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
80041b0: 78 03 08 00 mvhi r3,0x800
80041b4: 59 61 00 38 sw (r11+56),r1
80041b8: 38 63 46 34 ori r3,r3,0x4634
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
80041bc: 78 01 08 02 mvhi r1,0x802
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
80041c0: 59 60 00 18 sw (r11+24),r0
the_watchdog->routine = routine;
80041c4: 59 63 00 2c sw (r11+44),r3
the_watchdog->id = id;
80041c8: 59 6c 00 30 sw (r11+48),r12
the_watchdog->user_data = user_data;
80041cc: 59 60 00 34 sw (r11+52),r0
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
80041d0: 59 6d 00 3c sw (r11+60),r13
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
80041d4: 59 6d 00 1c sw (r11+28),r13
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
80041d8: 38 21 1a e8 ori r1,r1,0x1ae8
80041dc: 35 62 00 10 addi r2,r11,16
80041e0: f8 00 12 73 calli 8008bac <_Watchdog_Insert>
80041e4: e0 00 00 1f bi 8004260 <rtems_rate_monotonic_period+0x16c>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
80041e8: 34 01 00 02 mvi r1,2
80041ec: 5c 61 00 20 bne r3,r1,800426c <rtems_rate_monotonic_period+0x178>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
80041f0: b9 60 08 00 mv r1,r11
80041f4: fb ff ff 80 calli 8003ff4 <_Rate_monotonic_Update_statistics>
/*
* This tells the _Rate_monotonic_Timeout that this task is
* in the process of blocking on the period and that we
* may be changing the length of the next period.
*/
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
80041f8: 34 01 00 01 mvi r1,1
80041fc: 59 61 00 38 sw (r11+56),r1
the_period->next_length = length;
8004200: 59 6d 00 3c sw (r11+60),r13
_ISR_Enable( level );
8004204: d0 0e 00 00 wcsr IE,r14
_Thread_Executing->Wait.id = the_period->Object.id;
8004208: 78 01 08 02 mvhi r1,0x802
800420c: 38 21 1e d4 ori r1,r1,0x1ed4
8004210: 29 62 00 08 lw r2,(r11+8)
8004214: 28 21 00 0c lw r1,(r1+12)
8004218: 58 22 00 20 sw (r1+32),r2
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
800421c: 34 02 40 00 mvi r2,16384
8004220: f8 00 10 56 calli 8008378 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
8004224: 90 00 08 00 rcsr r1,IE
8004228: 34 02 ff fe mvi r2,-2
800422c: a0 22 10 00 and r2,r1,r2
8004230: d0 02 00 00 wcsr IE,r2
local_state = the_period->state;
the_period->state = RATE_MONOTONIC_ACTIVE;
8004234: 34 03 00 02 mvi r3,2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
8004238: 29 62 00 38 lw r2,(r11+56)
the_period->state = RATE_MONOTONIC_ACTIVE;
800423c: 59 63 00 38 sw (r11+56),r3
_ISR_Enable( level );
8004240: d0 01 00 00 wcsr IE,r1
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
8004244: 34 01 00 03 mvi r1,3
8004248: 5c 41 00 06 bne r2,r1,8004260 <rtems_rate_monotonic_period+0x16c><== ALWAYS TAKEN
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
800424c: 78 01 08 02 mvhi r1,0x802 <== NOT EXECUTED
8004250: 38 21 1e d4 ori r1,r1,0x1ed4 <== NOT EXECUTED
8004254: 28 21 00 0c lw r1,(r1+12) <== NOT EXECUTED
8004258: 34 02 40 00 mvi r2,16384 <== NOT EXECUTED
800425c: f8 00 0c e8 calli 80075fc <_Thread_Clear_state> <== NOT EXECUTED
_Thread_Enable_dispatch();
8004260: f8 00 0d ab calli 800790c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8004264: 34 0c 00 00 mvi r12,0
8004268: e0 00 00 12 bi 80042b0 <rtems_rate_monotonic_period+0x1bc>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
800426c: 34 0c 00 04 mvi r12,4
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
8004270: 5c 6c 00 10 bne r3,r12,80042b0 <rtems_rate_monotonic_period+0x1bc><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
8004274: b9 60 08 00 mv r1,r11
8004278: fb ff ff 5f calli 8003ff4 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
800427c: d0 0e 00 00 wcsr IE,r14
the_period->state = RATE_MONOTONIC_ACTIVE;
8004280: 34 01 00 02 mvi r1,2
8004284: 59 61 00 38 sw (r11+56),r1
8004288: 78 01 08 02 mvhi r1,0x802
800428c: 38 21 1a e8 ori r1,r1,0x1ae8
8004290: 35 62 00 10 addi r2,r11,16
the_period->next_length = length;
8004294: 59 6d 00 3c sw (r11+60),r13
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
8004298: 59 6d 00 1c sw (r11+28),r13
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
800429c: f8 00 12 44 calli 8008bac <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_TIMEOUT;
80042a0: 34 0c 00 06 mvi r12,6
the_period->state = RATE_MONOTONIC_ACTIVE;
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
80042a4: f8 00 0d 9a calli 800790c <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
80042a8: e0 00 00 02 bi 80042b0 <rtems_rate_monotonic_period+0x1bc>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
80042ac: 34 0c 00 04 mvi r12,4
}
80042b0: b9 80 08 00 mv r1,r12
80042b4: 2b 9d 00 04 lw ra,(sp+4)
80042b8: 2b 8b 00 14 lw r11,(sp+20)
80042bc: 2b 8c 00 10 lw r12,(sp+16)
80042c0: 2b 8d 00 0c lw r13,(sp+12)
80042c4: 2b 8e 00 08 lw r14,(sp+8)
80042c8: 37 9c 00 18 addi sp,sp,24
80042cc: c3 a0 00 00 ret
080042d0 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
80042d0: 37 9c ff 5c addi sp,sp,-164
80042d4: 5b 8b 00 44 sw (sp+68),r11
80042d8: 5b 8c 00 40 sw (sp+64),r12
80042dc: 5b 8d 00 3c sw (sp+60),r13
80042e0: 5b 8e 00 38 sw (sp+56),r14
80042e4: 5b 8f 00 34 sw (sp+52),r15
80042e8: 5b 90 00 30 sw (sp+48),r16
80042ec: 5b 91 00 2c sw (sp+44),r17
80042f0: 5b 92 00 28 sw (sp+40),r18
80042f4: 5b 93 00 24 sw (sp+36),r19
80042f8: 5b 94 00 20 sw (sp+32),r20
80042fc: 5b 95 00 1c sw (sp+28),r21
8004300: 5b 96 00 18 sw (sp+24),r22
8004304: 5b 97 00 14 sw (sp+20),r23
8004308: 5b 98 00 10 sw (sp+16),r24
800430c: 5b 99 00 0c sw (sp+12),r25
8004310: 5b 9b 00 08 sw (sp+8),fp
8004314: 5b 9d 00 04 sw (sp+4),ra
8004318: b8 20 60 00 mv r12,r1
800431c: b8 40 58 00 mv r11,r2
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
8004320: 44 40 00 72 be r2,r0,80044e8 <rtems_rate_monotonic_report_statistics_with_plugin+0x218><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
8004324: 78 02 08 01 mvhi r2,0x801
8004328: 38 42 ea 5c ori r2,r2,0xea5c
800432c: d9 60 00 00 call r11
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
8004330: 78 02 08 01 mvhi r2,0x801
8004334: 38 42 ea 7c ori r2,r2,0xea7c
8004338: b9 80 08 00 mv r1,r12
800433c: d9 60 00 00 call r11
(*print)( context, "--- Wall times are in seconds ---\n" );
8004340: 78 02 08 01 mvhi r2,0x801
8004344: 38 42 ea a0 ori r2,r2,0xeaa0
8004348: b9 80 08 00 mv r1,r12
800434c: d9 60 00 00 call r11
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
8004350: 78 02 08 01 mvhi r2,0x801
8004354: 38 42 ea c4 ori r2,r2,0xeac4
8004358: b9 80 08 00 mv r1,r12
800435c: d9 60 00 00 call r11
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
8004360: 78 02 08 01 mvhi r2,0x801
8004364: b9 80 08 00 mv r1,r12
8004368: 38 42 eb 10 ori r2,r2,0xeb10
800436c: d9 60 00 00 call r11
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
8004370: 78 01 08 02 mvhi r1,0x802
8004374: 38 21 19 00 ori r1,r1,0x1900
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
8004378: 78 11 08 01 mvhi r17,0x801
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
(*print)( context,
800437c: 78 10 08 01 mvhi r16,0x801
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
(*print)( context,
8004380: 78 0f 08 01 mvhi r15,0x801
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
8004384: 78 0e 08 01 mvhi r14,0x801
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
8004388: 28 2d 00 08 lw r13,(r1+8)
id <= _Rate_monotonic_Information.maximum_id ;
800438c: b8 20 a0 00 mv r20,r1
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
8004390: 37 99 00 48 addi r25,sp,72
#if defined(RTEMS_DEBUG)
status = rtems_rate_monotonic_get_status( id, &the_status );
if ( status != RTEMS_SUCCESSFUL )
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
8004394: 37 98 00 80 addi r24,sp,128
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
8004398: 37 93 00 a0 addi r19,sp,160
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
800439c: 3a 31 eb 5c ori r17,r17,0xeb5c
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
80043a0: 37 97 00 60 addi r23,sp,96
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
80043a4: 37 92 00 98 addi r18,sp,152
(*print)( context,
80043a8: 3a 10 eb 74 ori r16,r16,0xeb74
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
80043ac: 37 96 00 78 addi r22,sp,120
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
(*print)( context,
80043b0: 39 ef eb 94 ori r15,r15,0xeb94
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
80043b4: 39 ce e0 a0 ori r14,r14,0xe0a0
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
80043b8: e0 00 00 4a bi 80044e0 <rtems_rate_monotonic_report_statistics_with_plugin+0x210>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
80043bc: b9 a0 08 00 mv r1,r13
80043c0: bb 20 10 00 mv r2,r25
80043c4: f8 00 1d 26 calli 800b85c <rtems_rate_monotonic_get_statistics>
80043c8: b8 20 a8 00 mv r21,r1
if ( status != RTEMS_SUCCESSFUL )
80043cc: 5c 20 00 44 bne r1,r0,80044dc <rtems_rate_monotonic_report_statistics_with_plugin+0x20c>
#if defined(RTEMS_DEBUG)
status = rtems_rate_monotonic_get_status( id, &the_status );
if ( status != RTEMS_SUCCESSFUL )
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
80043d0: bb 00 10 00 mv r2,r24
80043d4: b9 a0 08 00 mv r1,r13
80043d8: f8 00 1d 53 calli 800b924 <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
80043dc: 2b 81 00 80 lw r1,(sp+128)
80043e0: 34 02 00 05 mvi r2,5
80043e4: ba 60 18 00 mv r3,r19
80043e8: f8 00 00 c3 calli 80046f4 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
80043ec: 2b 85 00 48 lw r5,(sp+72)
80043f0: 2b 86 00 4c lw r6,(sp+76)
80043f4: ba 20 10 00 mv r2,r17
80043f8: b9 80 08 00 mv r1,r12
80043fc: b9 a0 18 00 mv r3,r13
8004400: ba 60 20 00 mv r4,r19
8004404: d9 60 00 00 call r11
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
8004408: 2b 82 00 48 lw r2,(sp+72)
800440c: 5c 55 00 05 bne r2,r21,8004420 <rtems_rate_monotonic_report_statistics_with_plugin+0x150>
(*print)( context, "\n" );
8004410: b9 80 08 00 mv r1,r12
8004414: b9 c0 10 00 mv r2,r14
8004418: d9 60 00 00 call r11
continue;
800441c: e0 00 00 30 bi 80044dc <rtems_rate_monotonic_report_statistics_with_plugin+0x20c>
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
8004420: ba 40 18 00 mv r3,r18
8004424: ba e0 08 00 mv r1,r23
8004428: f8 00 10 97 calli 8008684 <_Timespec_Divide_by_integer>
(*print)( context,
800442c: 2b 81 00 54 lw r1,(sp+84)
8004430: 34 02 03 e8 mvi r2,1000
8004434: f8 00 62 1a calli 801cc9c <__divsi3>
8004438: b8 20 d8 00 mv fp,r1
800443c: 2b 81 00 5c lw r1,(sp+92)
8004440: 34 02 03 e8 mvi r2,1000
8004444: f8 00 62 16 calli 801cc9c <__divsi3>
8004448: b8 20 a8 00 mv r21,r1
800444c: 2b 81 00 9c lw r1,(sp+156)
8004450: 34 02 03 e8 mvi r2,1000
8004454: f8 00 62 12 calli 801cc9c <__divsi3>
8004458: 2b 85 00 58 lw r5,(sp+88)
800445c: 2b 87 00 98 lw r7,(sp+152)
8004460: 2b 83 00 50 lw r3,(sp+80)
8004464: b8 20 40 00 mv r8,r1
8004468: bb 60 20 00 mv r4,fp
800446c: ba a0 30 00 mv r6,r21
8004470: ba 00 10 00 mv r2,r16
8004474: b9 80 08 00 mv r1,r12
8004478: d9 60 00 00 call r11
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
800447c: 2b 82 00 48 lw r2,(sp+72)
8004480: ba 40 18 00 mv r3,r18
8004484: ba c0 08 00 mv r1,r22
8004488: f8 00 10 7f calli 8008684 <_Timespec_Divide_by_integer>
(*print)( context,
800448c: 2b 81 00 6c lw r1,(sp+108)
8004490: 34 02 03 e8 mvi r2,1000
8004494: f8 00 62 02 calli 801cc9c <__divsi3>
8004498: b8 20 d8 00 mv fp,r1
800449c: 2b 81 00 74 lw r1,(sp+116)
80044a0: 34 02 03 e8 mvi r2,1000
80044a4: f8 00 61 fe calli 801cc9c <__divsi3>
80044a8: b8 20 a8 00 mv r21,r1
80044ac: 2b 81 00 9c lw r1,(sp+156)
80044b0: 34 02 03 e8 mvi r2,1000
80044b4: f8 00 61 fa calli 801cc9c <__divsi3>
80044b8: 2b 83 00 68 lw r3,(sp+104)
80044bc: 2b 85 00 70 lw r5,(sp+112)
80044c0: 2b 87 00 98 lw r7,(sp+152)
80044c4: b8 20 40 00 mv r8,r1
80044c8: b9 e0 10 00 mv r2,r15
80044cc: b9 80 08 00 mv r1,r12
80044d0: bb 60 20 00 mv r4,fp
80044d4: ba a0 30 00 mv r6,r21
80044d8: d9 60 00 00 call r11
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
80044dc: 35 ad 00 01 addi r13,r13,1
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
80044e0: 2a 81 00 0c lw r1,(r20+12)
80044e4: 50 2d ff b6 bgeu r1,r13,80043bc <rtems_rate_monotonic_report_statistics_with_plugin+0xec>
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
80044e8: 2b 9d 00 04 lw ra,(sp+4)
80044ec: 2b 8b 00 44 lw r11,(sp+68)
80044f0: 2b 8c 00 40 lw r12,(sp+64)
80044f4: 2b 8d 00 3c lw r13,(sp+60)
80044f8: 2b 8e 00 38 lw r14,(sp+56)
80044fc: 2b 8f 00 34 lw r15,(sp+52)
8004500: 2b 90 00 30 lw r16,(sp+48)
8004504: 2b 91 00 2c lw r17,(sp+44)
8004508: 2b 92 00 28 lw r18,(sp+40)
800450c: 2b 93 00 24 lw r19,(sp+36)
8004510: 2b 94 00 20 lw r20,(sp+32)
8004514: 2b 95 00 1c lw r21,(sp+28)
8004518: 2b 96 00 18 lw r22,(sp+24)
800451c: 2b 97 00 14 lw r23,(sp+20)
8004520: 2b 98 00 10 lw r24,(sp+16)
8004524: 2b 99 00 0c lw r25,(sp+12)
8004528: 2b 9b 00 08 lw fp,(sp+8)
800452c: 37 9c 00 a4 addi sp,sp,164
8004530: c3 a0 00 00 ret
08003db0 <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
8003db0: 37 9c ff c8 addi sp,sp,-56
8003db4: 5b 8b 00 20 sw (sp+32),r11
8003db8: 5b 8c 00 1c sw (sp+28),r12
8003dbc: 5b 8d 00 18 sw (sp+24),r13
8003dc0: 5b 8e 00 14 sw (sp+20),r14
8003dc4: 5b 8f 00 10 sw (sp+16),r15
8003dc8: 5b 90 00 0c sw (sp+12),r16
8003dcc: 5b 91 00 08 sw (sp+8),r17
8003dd0: 5b 9d 00 04 sw (sp+4),ra
8003dd4: b8 20 80 00 mv r16,r1
8003dd8: b8 40 70 00 mv r14,r2
8003ddc: b8 60 60 00 mv r12,r3
8003de0: b8 80 88 00 mv r17,r4
8003de4: b8 a0 78 00 mv r15,r5
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
8003de8: 34 01 00 03 mvi r1,3
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
8003dec: 46 00 00 64 be r16,r0,8003f7c <rtems_semaphore_create+0x1cc><== NEVER TAKEN
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
8003df0: 34 01 00 09 mvi r1,9
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
8003df4: 44 a0 00 62 be r5,r0,8003f7c <rtems_semaphore_create+0x1cc><== NEVER TAKEN
* id - semaphore id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_semaphore_create(
8003df8: 20 62 00 c0 andi r2,r3,0xc0
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
8003dfc: 44 40 00 09 be r2,r0,8003e20 <rtems_semaphore_create+0x70>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE);
8003e00: 20 64 00 30 andi r4,r3,0x30
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
8003e04: 34 03 00 10 mvi r3,16
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
8003e08: 34 01 00 0b mvi r1,11
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
8003e0c: 5c 83 00 5c bne r4,r3,8003f7c <rtems_semaphore_create+0x1cc><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_priority(
rtems_attribute attribute_set
)
{
return ( attribute_set & RTEMS_PRIORITY ) ? true : false;
8003e10: 21 83 00 04 andi r3,r12,0x4
8003e14: 44 60 00 5a be r3,r0,8003f7c <rtems_semaphore_create+0x1cc><== NEVER TAKEN
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
8003e18: 34 03 00 c0 mvi r3,192
8003e1c: 44 43 00 58 be r2,r3,8003f7c <rtems_semaphore_create+0x1cc><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
8003e20: 21 8d 00 30 andi r13,r12,0x30
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
8003e24: 45 a0 00 04 be r13,r0,8003e34 <rtems_semaphore_create+0x84>
8003e28: 34 02 00 01 mvi r2,1
return RTEMS_INVALID_NUMBER;
8003e2c: 34 01 00 0a mvi r1,10
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
8003e30: 55 c2 00 53 bgu r14,r2,8003f7c <rtems_semaphore_create+0x1cc><== NEVER TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
8003e34: 78 06 08 01 mvhi r6,0x801
8003e38: 38 c6 99 90 ori r6,r6,0x9990
8003e3c: 28 c1 00 00 lw r1,(r6+0)
8003e40: 34 21 00 01 addi r1,r1,1
8003e44: 58 c1 00 00 sw (r6+0),r1
* This function allocates a semaphore control block from
* the inactive chain of free semaphore control blocks.
*/
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void )
{
return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information );
8003e48: 78 01 08 01 mvhi r1,0x801
8003e4c: 38 21 98 e8 ori r1,r1,0x98e8
8003e50: f8 00 06 0b calli 800567c <_Objects_Allocate>
8003e54: b8 20 58 00 mv r11,r1
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
8003e58: 5c 20 00 04 bne r1,r0,8003e68 <rtems_semaphore_create+0xb8>
_Thread_Enable_dispatch();
8003e5c: f8 00 0b 33 calli 8006b28 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
8003e60: 34 01 00 05 mvi r1,5
8003e64: e0 00 00 46 bi 8003f7c <rtems_semaphore_create+0x1cc>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
8003e68: 58 2c 00 10 sw (r1+16),r12
8003e6c: 21 81 00 04 andi r1,r12,0x4
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
8003e70: 5d a0 00 0f bne r13,r0,8003eac <rtems_semaphore_create+0xfc>
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
8003e74: 34 02 ff ff mvi r2,-1
8003e78: 5b 82 00 34 sw (sp+52),r2
if ( _Attributes_Is_priority( attribute_set ) )
8003e7c: 44 2d 00 04 be r1,r13,8003e8c <rtems_semaphore_create+0xdc>
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
8003e80: 34 01 00 01 mvi r1,1
8003e84: 5b 81 00 38 sw (sp+56),r1
8003e88: e0 00 00 02 bi 8003e90 <rtems_semaphore_create+0xe0>
else
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
8003e8c: 5b 80 00 38 sw (sp+56),r0
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
_CORE_semaphore_Initialize(
8003e90: 35 61 00 14 addi r1,r11,20
8003e94: 37 82 00 34 addi r2,sp,52
8003e98: b9 c0 18 00 mv r3,r14
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
8003e9c: 5b 80 00 24 sw (sp+36),r0
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
8003ea0: 5b 80 00 30 sw (sp+48),r0
_CORE_semaphore_Initialize(
8003ea4: f8 00 04 2e calli 8004f5c <_CORE_semaphore_Initialize>
8003ea8: e0 00 00 28 bi 8003f48 <rtems_semaphore_create+0x198>
} else {
/*
* It is either simple binary semaphore or a more powerful mutex
* style binary semaphore. This is the mutex style.
*/
if ( _Attributes_Is_priority( attribute_set ) )
8003eac: 44 20 00 04 be r1,r0,8003ebc <rtems_semaphore_create+0x10c>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
8003eb0: 34 01 00 01 mvi r1,1
8003eb4: 5b 81 00 2c sw (sp+44),r1
8003eb8: e0 00 00 02 bi 8003ec0 <rtems_semaphore_create+0x110>
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
8003ebc: 5b 80 00 2c sw (sp+44),r0
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
8003ec0: 34 01 00 10 mvi r1,16
8003ec4: 5d a1 00 11 bne r13,r1,8003f08 <rtems_semaphore_create+0x158>
the_mutex_attr.priority_ceiling = priority_ceiling;
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attr.only_owner_release = false;
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
8003ec8: 2b 82 00 2c lw r2,(sp+44)
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attr.priority_ceiling = priority_ceiling;
8003ecc: 5b 91 00 30 sw (sp+48),r17
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
8003ed0: 5b 80 00 24 sw (sp+36),r0
the_mutex_attr.only_owner_release = false;
8003ed4: 33 80 00 28 sb (sp+40),r0
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
8003ed8: 34 01 00 01 mvi r1,1
8003edc: 5c 41 00 0e bne r2,r1,8003f14 <rtems_semaphore_create+0x164>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_inherit_priority(
rtems_attribute attribute_set
)
{
return ( attribute_set & RTEMS_INHERIT_PRIORITY ) ? true : false;
8003ee0: 21 81 00 40 andi r1,r12,0x40
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
8003ee4: 44 20 00 03 be r1,r0,8003ef0 <rtems_semaphore_create+0x140>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
8003ee8: 34 01 00 02 mvi r1,2
8003eec: e0 00 00 04 bi 8003efc <rtems_semaphore_create+0x14c>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_priority_ceiling(
rtems_attribute attribute_set
)
{
return ( attribute_set & RTEMS_PRIORITY_CEILING ) ? true : false;
8003ef0: 21 8c 00 80 andi r12,r12,0x80
the_mutex_attr.only_owner_release = true;
} else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) {
8003ef4: 45 81 00 08 be r12,r1,8003f14 <rtems_semaphore_create+0x164>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
8003ef8: 34 01 00 03 mvi r1,3
8003efc: 5b 81 00 2c sw (sp+44),r1
the_mutex_attr.only_owner_release = true;
8003f00: 33 82 00 28 sb (sp+40),r2
8003f04: e0 00 00 04 bi 8003f14 <rtems_semaphore_create+0x164>
}
}
} else /* must be simple binary semaphore */ {
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
8003f08: 34 01 00 02 mvi r1,2
8003f0c: 5b 81 00 24 sw (sp+36),r1
the_mutex_attr.only_owner_release = false;
8003f10: 33 80 00 28 sb (sp+40),r0
}
mutex_status = _CORE_mutex_Initialize(
8003f14: 65 c3 00 01 cmpei r3,r14,1
8003f18: 37 82 00 24 addi r2,sp,36
8003f1c: 35 61 00 14 addi r1,r11,20
8003f20: f8 00 03 35 calli 8004bf4 <_CORE_mutex_Initialize>
&the_semaphore->Core_control.mutex,
&the_mutex_attr,
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
8003f24: 34 02 00 06 mvi r2,6
8003f28: 5c 22 00 08 bne r1,r2,8003f48 <rtems_semaphore_create+0x198>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
8003f2c: 78 01 08 01 mvhi r1,0x801
8003f30: 38 21 98 e8 ori r1,r1,0x98e8
8003f34: b9 60 10 00 mv r2,r11
8003f38: f8 00 06 e2 calli 8005ac0 <_Objects_Free>
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
8003f3c: f8 00 0a fb calli 8006b28 <_Thread_Enable_dispatch>
return RTEMS_INVALID_PRIORITY;
8003f40: 34 01 00 13 mvi r1,19
8003f44: e0 00 00 0e bi 8003f7c <rtems_semaphore_create+0x1cc>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
8003f48: 29 6c 00 08 lw r12,(r11+8)
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
8003f4c: 78 02 08 01 mvhi r2,0x801
8003f50: 38 42 98 e8 ori r2,r2,0x98e8
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8003f54: 28 4d 00 1c lw r13,(r2+28)
8003f58: 21 81 ff ff andi r1,r12,0xffff
8003f5c: 34 02 00 02 mvi r2,2
8003f60: f8 00 4b ec calli 8016f10 <__ashlsi3>
8003f64: b5 a1 08 00 add r1,r13,r1
8003f68: 58 2b 00 00 sw (r1+0),r11
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
8003f6c: 59 70 00 0c sw (r11+12),r16
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
8003f70: 59 ec 00 00 sw (r15+0),r12
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
8003f74: f8 00 0a ed calli 8006b28 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8003f78: 34 01 00 00 mvi r1,0
}
8003f7c: 2b 9d 00 04 lw ra,(sp+4)
8003f80: 2b 8b 00 20 lw r11,(sp+32)
8003f84: 2b 8c 00 1c lw r12,(sp+28)
8003f88: 2b 8d 00 18 lw r13,(sp+24)
8003f8c: 2b 8e 00 14 lw r14,(sp+20)
8003f90: 2b 8f 00 10 lw r15,(sp+16)
8003f94: 2b 90 00 0c lw r16,(sp+12)
8003f98: 2b 91 00 08 lw r17,(sp+8)
8003f9c: 37 9c 00 38 addi sp,sp,56
8003fa0: c3 a0 00 00 ret
08013414 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
8013414: 37 9c ff f4 addi sp,sp,-12
8013418: 5b 8b 00 08 sw (sp+8),r11
801341c: 5b 9d 00 04 sw (sp+4),ra
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
8013420: 34 03 00 0a mvi r3,10
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
8013424: b8 40 58 00 mv r11,r2
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
8013428: 44 40 00 29 be r2,r0,80134cc <rtems_signal_send+0xb8>
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
801342c: 37 82 00 0c addi r2,sp,12
8013430: f8 00 15 9e calli 8018aa8 <_Thread_Get>
switch ( location ) {
8013434: 2b 82 00 0c lw r2,(sp+12)
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8013438: 34 03 00 04 mvi r3,4
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
801343c: 5c 40 00 24 bne r2,r0,80134cc <rtems_signal_send+0xb8>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
8013440: 28 23 01 1c lw r3,(r1+284)
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
8013444: 28 64 00 0c lw r4,(r3+12)
8013448: 44 82 00 1f be r4,r2,80134c4 <rtems_signal_send+0xb0>
if ( asr->is_enabled ) {
801344c: 40 62 00 08 lbu r2,(r3+8)
8013450: 44 40 00 12 be r2,r0,8013498 <rtems_signal_send+0x84>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
8013454: 90 00 10 00 rcsr r2,IE
8013458: 34 04 ff fe mvi r4,-2
801345c: a0 44 20 00 and r4,r2,r4
8013460: d0 04 00 00 wcsr IE,r4
*signal_set |= signals;
8013464: 28 64 00 14 lw r4,(r3+20)
8013468: b8 8b 58 00 or r11,r4,r11
801346c: 58 6b 00 14 sw (r3+20),r11
_ISR_Enable( _level );
8013470: d0 02 00 00 wcsr IE,r2
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
8013474: 78 02 08 04 mvhi r2,0x804
8013478: 38 42 11 c4 ori r2,r2,0x11c4
801347c: 28 43 00 08 lw r3,(r2+8)
8013480: 44 60 00 0e be r3,r0,80134b8 <rtems_signal_send+0xa4>
8013484: 28 43 00 0c lw r3,(r2+12)
8013488: 5c 23 00 0c bne r1,r3,80134b8 <rtems_signal_send+0xa4> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
801348c: 34 01 00 01 mvi r1,1
8013490: 30 41 00 18 sb (r2+24),r1
8013494: e0 00 00 09 bi 80134b8 <rtems_signal_send+0xa4>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
8013498: 90 00 08 00 rcsr r1,IE
801349c: 34 02 ff fe mvi r2,-2
80134a0: a0 22 10 00 and r2,r1,r2
80134a4: d0 02 00 00 wcsr IE,r2
*signal_set |= signals;
80134a8: 28 62 00 18 lw r2,(r3+24)
80134ac: b8 4b 58 00 or r11,r2,r11
80134b0: 58 6b 00 18 sw (r3+24),r11
_ISR_Enable( _level );
80134b4: d0 01 00 00 wcsr IE,r1
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
80134b8: f8 00 15 6f calli 8018a74 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
80134bc: 34 03 00 00 mvi r3,0
80134c0: e0 00 00 03 bi 80134cc <rtems_signal_send+0xb8>
}
_Thread_Enable_dispatch();
80134c4: f8 00 15 6c calli 8018a74 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
80134c8: 34 03 00 0b mvi r3,11
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
80134cc: b8 60 08 00 mv r1,r3
80134d0: 2b 9d 00 04 lw ra,(sp+4)
80134d4: 2b 8b 00 08 lw r11,(sp+8)
80134d8: 37 9c 00 0c addi sp,sp,12
80134dc: c3 a0 00 00 ret
08001328 <rtems_stack_checker_begin_extension>:
Thread_Control *the_thread
)
{
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
8001328: 28 22 00 08 lw r2,(r1+8)
800132c: 44 40 00 0c be r2,r0,800135c <rtems_stack_checker_begin_extension+0x34><== NEVER TAKEN
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
8001330: 28 22 00 bc lw r2,(r1+188)
8001334: 78 01 08 01 mvhi r1,0x801
8001338: 38 21 77 c0 ori r1,r1,0x77c0
800133c: 28 25 00 00 lw r5,(r1+0)
8001340: 28 24 00 04 lw r4,(r1+4)
8001344: 28 23 00 08 lw r3,(r1+8)
8001348: 28 21 00 0c lw r1,(r1+12)
800134c: 58 45 00 08 sw (r2+8),r5
8001350: 58 44 00 0c sw (r2+12),r4
8001354: 58 43 00 10 sw (r2+16),r3
8001358: 58 41 00 14 sw (r2+20),r1
800135c: c3 a0 00 00 ret
080012ec <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
80012ec: 37 9c ff f8 addi sp,sp,-8
80012f0: 5b 8b 00 08 sw (sp+8),r11
80012f4: 5b 9d 00 04 sw (sp+4),ra
80012f8: b8 40 58 00 mv r11,r2
Stack_check_Initialize();
80012fc: fb ff ff d0 calli 800123c <Stack_check_Initialize>
if (the_thread)
8001300: 45 60 00 05 be r11,r0,8001314 <rtems_stack_checker_create_extension+0x28><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
8001304: 29 61 00 bc lw r1,(r11+188)
8001308: 29 63 00 b8 lw r3,(r11+184)
800130c: 34 02 00 a5 mvi r2,165
8001310: f8 00 3b 97 calli 801016c <memset>
return true;
}
8001314: 34 01 00 01 mvi r1,1
8001318: 2b 9d 00 04 lw ra,(sp+4)
800131c: 2b 8b 00 08 lw r11,(sp+8)
8001320: 37 9c 00 08 addi sp,sp,8
8001324: c3 a0 00 00 ret
08001490 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
8001490: 37 9c ff f4 addi sp,sp,-12
8001494: 5b 9b 00 08 sw (sp+8),fp
8001498: 34 1b 00 0c mvi fp,12
800149c: b7 7c d8 00 add fp,fp,sp
80014a0: 5b 8b 00 0c sw (sp+12),r11
80014a4: 5b 9d 00 04 sw (sp+4),ra
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
80014a8: 78 01 08 01 mvhi r1,0x801
80014ac: 38 21 7e 28 ori r1,r1,0x7e28
80014b0: 28 22 00 0c lw r2,(r1+12)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
80014b4: 34 0b 00 00 mvi r11,0
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
80014b8: 28 41 00 bc lw r1,(r2+188)
80014bc: 54 3b 00 04 bgu r1,fp,80014cc <rtems_stack_checker_is_blown+0x3c><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
80014c0: 28 4b 00 b8 lw r11,(r2+184)
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
80014c4: b4 2b 58 00 add r11,r1,r11
80014c8: f1 7b 58 00 cmpgeu r11,r11,fp
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
80014cc: 78 02 08 01 mvhi r2,0x801
80014d0: 38 42 77 34 ori r2,r2,0x7734
80014d4: 28 43 00 00 lw r3,(r2+0)
*/
bool rtems_stack_checker_is_blown( void )
{
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
bool sp_ok;
bool pattern_ok = true;
80014d8: 34 02 00 01 mvi r2,1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
80014dc: 44 60 00 07 be r3,r0,80014f8 <rtems_stack_checker_is_blown+0x68><== NEVER TAKEN
pattern_ok = (!memcmp(
80014e0: 78 02 08 01 mvhi r2,0x801
80014e4: 38 42 77 c0 ori r2,r2,0x77c0
80014e8: 34 21 00 08 addi r1,r1,8
80014ec: 34 03 00 10 mvi r3,16
80014f0: f8 00 3a bd calli 800ffe4 <memcmp>
80014f4: 64 22 00 00 cmpei r2,r1,0
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
80014f8: 45 60 00 02 be r11,r0,8001500 <rtems_stack_checker_is_blown+0x70><== NEVER TAKEN
80014fc: 5c 40 00 05 bne r2,r0,8001510 <rtems_stack_checker_is_blown+0x80><== ALWAYS TAKEN
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
8001500: 78 01 08 01 mvhi r1,0x801 <== NOT EXECUTED
8001504: 38 21 7e 28 ori r1,r1,0x7e28 <== NOT EXECUTED
8001508: 28 21 00 0c lw r1,(r1+12) <== NOT EXECUTED
800150c: fb ff ff 95 calli 8001360 <Stack_check_report_blown_task> <== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
8001510: 34 01 00 00 mvi r1,0
8001514: 2b 9d 00 04 lw ra,(sp+4)
8001518: 2b 8b 00 0c lw r11,(sp+12)
800151c: 2b 9b 00 08 lw fp,(sp+8)
8001520: 37 9c 00 0c addi sp,sp,12
8001524: c3 a0 00 00 ret
08001528 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
8001528: 37 9c ff ec addi sp,sp,-20
800152c: 5b 8b 00 14 sw (sp+20),r11
8001530: 5b 8c 00 10 sw (sp+16),r12
8001534: 5b 8d 00 0c sw (sp+12),r13
8001538: 5b 8e 00 08 sw (sp+8),r14
800153c: 5b 9d 00 04 sw (sp+4),ra
8001540: b8 20 70 00 mv r14,r1
8001544: b8 40 68 00 mv r13,r2
if ( !print )
8001548: 44 40 00 15 be r2,r0,800159c <rtems_stack_checker_report_usage_with_plugin+0x74><== NEVER TAKEN
return;
print_context = context;
print_handler = print;
800154c: 78 0b 08 01 mvhi r11,0x801
8001550: 39 6b 77 30 ori r11,r11,0x7730
)
{
if ( !print )
return;
print_context = context;
8001554: 78 0c 08 01 mvhi r12,0x801
8001558: 39 8c 77 2c ori r12,r12,0x772c
print_handler = print;
800155c: 59 62 00 00 sw (r11+0),r2
(*print)( context, "Stack usage by thread\n");
8001560: 78 02 08 01 mvhi r2,0x801
8001564: 38 42 60 34 ori r2,r2,0x6034
)
{
if ( !print )
return;
print_context = context;
8001568: 59 81 00 00 sw (r12+0),r1
print_handler = print;
(*print)( context, "Stack usage by thread\n");
800156c: d9 a0 00 00 call r13
(*print)( context,
8001570: 78 02 08 01 mvhi r2,0x801
8001574: 38 42 60 4c ori r2,r2,0x604c
8001578: b9 c0 08 00 mv r1,r14
800157c: d9 a0 00 00 call r13
" 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 );
8001580: 78 01 08 00 mvhi r1,0x800
8001584: 38 21 10 74 ori r1,r1,0x1074
8001588: f8 00 16 aa calli 8007030 <rtems_iterate_over_all_threads>
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
800158c: 34 01 ff ff mvi r1,-1
8001590: fb ff fe b9 calli 8001074 <Stack_check_Dump_threads_usage>
#endif
print_context = NULL;
8001594: 59 80 00 00 sw (r12+0),r0
print_handler = NULL;
8001598: 59 60 00 00 sw (r11+0),r0
}
800159c: 2b 9d 00 04 lw ra,(sp+4)
80015a0: 2b 8b 00 14 lw r11,(sp+20)
80015a4: 2b 8c 00 10 lw r12,(sp+16)
80015a8: 2b 8d 00 0c lw r13,(sp+12)
80015ac: 2b 8e 00 08 lw r14,(sp+8)
80015b0: 37 9c 00 14 addi sp,sp,20
80015b4: c3 a0 00 00 ret
08001418 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
8001418: 37 9c ff f0 addi sp,sp,-16
800141c: 5b 9b 00 08 sw (sp+8),fp
8001420: 34 1b 00 10 mvi fp,16
8001424: b7 7c d8 00 add fp,fp,sp
8001428: 5b 8b 00 10 sw (sp+16),r11
800142c: 5b 8c 00 0c sw (sp+12),r12
8001430: 5b 9d 00 04 sw (sp+4),ra
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);
8001434: 28 22 00 bc lw r2,(r1+188)
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
8001438: b8 20 58 00 mv r11,r1
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
800143c: 34 0c 00 00 mvi r12,0
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);
8001440: 34 41 00 08 addi r1,r2,8
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
8001444: 54 5b 00 04 bgu r2,fp,8001454 <rtems_stack_checker_switch_extension+0x3c><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
8001448: 29 6c 00 b8 lw r12,(r11+184)
}
/*
* rtems_stack_checker_switch_extension
*/
void rtems_stack_checker_switch_extension(
800144c: b4 4c 10 00 add r2,r2,r12
8001450: f0 5b 60 00 cmpgeu r12,r2,fp
/*
* 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,
8001454: 78 02 08 01 mvhi r2,0x801
8001458: 38 42 77 c0 ori r2,r2,0x77c0
800145c: 34 03 00 10 mvi r3,16
8001460: f8 00 3a e1 calli 800ffe4 <memcmp>
8001464: 64 22 00 00 cmpei r2,r1,0
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
8001468: 45 80 00 02 be r12,r0,8001470 <rtems_stack_checker_switch_extension+0x58>
800146c: 5c 40 00 03 bne r2,r0,8001478 <rtems_stack_checker_switch_extension+0x60>
Stack_check_report_blown_task( running, pattern_ok );
8001470: b9 60 08 00 mv r1,r11
8001474: fb ff ff bb calli 8001360 <Stack_check_report_blown_task>
}
}
8001478: 2b 9d 00 04 lw ra,(sp+4)
800147c: 2b 8b 00 10 lw r11,(sp+16)
8001480: 2b 8c 00 0c lw r12,(sp+12)
8001484: 2b 9b 00 08 lw fp,(sp+8)
8001488: 37 9c 00 10 addi sp,sp,16
800148c: c3 a0 00 00 ret
080091b8 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
80091b8: 37 9c ff e0 addi sp,sp,-32
80091bc: 5b 8b 00 1c sw (sp+28),r11
80091c0: 5b 8c 00 18 sw (sp+24),r12
80091c4: 5b 8d 00 14 sw (sp+20),r13
80091c8: 5b 8e 00 10 sw (sp+16),r14
80091cc: 5b 8f 00 0c sw (sp+12),r15
80091d0: 5b 90 00 08 sw (sp+8),r16
80091d4: 5b 9d 00 04 sw (sp+4),ra
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
80091d8: 34 0c 00 09 mvi r12,9
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
80091dc: b8 20 78 00 mv r15,r1
80091e0: b8 40 58 00 mv r11,r2
80091e4: b8 60 80 00 mv r16,r3
double result;
char *end;
if ( !n )
80091e8: 44 40 00 2e be r2,r0,80092a0 <rtems_string_to_double+0xe8>
return RTEMS_INVALID_ADDRESS;
errno = 0;
80091ec: f8 00 10 b4 calli 800d4bc <__errno>
80091f0: 58 20 00 00 sw (r1+0),r0
*n = 0;
80091f4: 59 60 00 00 sw (r11+0),r0
80091f8: 59 60 00 04 sw (r11+4),r0
result = strtod( s, &end );
80091fc: b9 e0 08 00 mv r1,r15
8009200: 37 82 00 20 addi r2,sp,32
8009204: f8 00 1b b9 calli 80100e8 <strtod>
8009208: b8 20 70 00 mv r14,r1
800920c: b8 40 68 00 mv r13,r2
if ( endptr )
8009210: 46 00 00 03 be r16,r0,800921c <rtems_string_to_double+0x64>
*endptr = end;
8009214: 2b 81 00 20 lw r1,(sp+32)
8009218: 5a 01 00 00 sw (r16+0),r1
if ( end == s )
800921c: 2b 81 00 20 lw r1,(sp+32)
return RTEMS_NOT_DEFINED;
8009220: 34 0c 00 0b mvi r12,11
result = strtod( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
8009224: 44 2f 00 1f be r1,r15,80092a0 <rtems_string_to_double+0xe8>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
8009228: f8 00 10 a5 calli 800d4bc <__errno>
800922c: 28 22 00 00 lw r2,(r1+0)
8009230: 34 01 00 22 mvi r1,34
8009234: 5c 41 00 18 bne r2,r1,8009294 <rtems_string_to_double+0xdc>
8009238: b9 c0 08 00 mv r1,r14
800923c: b9 a0 10 00 mv r2,r13
8009240: 34 03 00 00 mvi r3,0
8009244: 34 04 00 00 mvi r4,0
8009248: fb ff e6 ef calli 8002e04 <__eqdf2>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
800924c: 34 0c 00 0a mvi r12,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
8009250: 44 20 00 14 be r1,r0,80092a0 <rtems_string_to_double+0xe8> <== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
8009254: 78 04 08 02 mvhi r4,0x802
8009258: 38 84 10 84 ori r4,r4,0x1084
800925c: 28 83 00 00 lw r3,(r4+0)
8009260: b9 c0 08 00 mv r1,r14
8009264: b9 a0 10 00 mv r2,r13
8009268: 34 04 ff ff mvi r4,-1
800926c: f8 00 4b 17 calli 801bec8 <__gedf2>
8009270: 48 20 00 0c bg r1,r0,80092a0 <rtems_string_to_double+0xe8> <== ALWAYS TAKEN
8009274: 78 04 08 02 mvhi r4,0x802 <== NOT EXECUTED
8009278: 38 84 10 88 ori r4,r4,0x1088 <== NOT EXECUTED
800927c: 28 83 00 00 lw r3,(r4+0) <== NOT EXECUTED
8009280: b9 c0 08 00 mv r1,r14 <== NOT EXECUTED
8009284: b9 a0 10 00 mv r2,r13 <== NOT EXECUTED
8009288: 34 04 ff ff mvi r4,-1 <== NOT EXECUTED
800928c: f8 00 4b 78 calli 801c06c <__ledf2> <== NOT EXECUTED
8009290: 48 01 00 04 bg r0,r1,80092a0 <rtems_string_to_double+0xe8> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
*n = result;
8009294: 59 6e 00 00 sw (r11+0),r14
8009298: 59 6d 00 04 sw (r11+4),r13
return RTEMS_SUCCESSFUL;
800929c: 34 0c 00 00 mvi r12,0
}
80092a0: b9 80 08 00 mv r1,r12
80092a4: 2b 9d 00 04 lw ra,(sp+4)
80092a8: 2b 8b 00 1c lw r11,(sp+28)
80092ac: 2b 8c 00 18 lw r12,(sp+24)
80092b0: 2b 8d 00 14 lw r13,(sp+20)
80092b4: 2b 8e 00 10 lw r14,(sp+16)
80092b8: 2b 8f 00 0c lw r15,(sp+12)
80092bc: 2b 90 00 08 lw r16,(sp+8)
80092c0: 37 9c 00 20 addi sp,sp,32
80092c4: c3 a0 00 00 ret
080092c8 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
80092c8: 37 9c ff e4 addi sp,sp,-28
80092cc: 5b 8b 00 18 sw (sp+24),r11
80092d0: 5b 8c 00 14 sw (sp+20),r12
80092d4: 5b 8d 00 10 sw (sp+16),r13
80092d8: 5b 8e 00 0c sw (sp+12),r14
80092dc: 5b 8f 00 08 sw (sp+8),r15
80092e0: 5b 9d 00 04 sw (sp+4),ra
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
80092e4: 34 0b 00 09 mvi r11,9
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
80092e8: b8 20 70 00 mv r14,r1
80092ec: b8 40 68 00 mv r13,r2
80092f0: b8 60 78 00 mv r15,r3
float result;
char *end;
if ( !n )
80092f4: 44 40 00 25 be r2,r0,8009388 <rtems_string_to_float+0xc0>
return RTEMS_INVALID_ADDRESS;
errno = 0;
80092f8: f8 00 10 71 calli 800d4bc <__errno>
80092fc: 58 20 00 00 sw (r1+0),r0
*n = 0;
8009300: 59 a0 00 00 sw (r13+0),r0
result = strtof( s, &end );
8009304: b9 c0 08 00 mv r1,r14
8009308: 37 82 00 1c addi r2,sp,28
800930c: f8 00 1b 83 calli 8010118 <strtof>
8009310: b8 20 60 00 mv r12,r1
if ( endptr )
8009314: 45 e0 00 03 be r15,r0,8009320 <rtems_string_to_float+0x58>
*endptr = end;
8009318: 2b 81 00 1c lw r1,(sp+28)
800931c: 59 e1 00 00 sw (r15+0),r1
if ( end == s )
8009320: 2b 81 00 1c lw r1,(sp+28)
return RTEMS_NOT_DEFINED;
8009324: 34 0b 00 0b mvi r11,11
result = strtof( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
8009328: 44 2e 00 18 be r1,r14,8009388 <rtems_string_to_float+0xc0>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
800932c: f8 00 10 64 calli 800d4bc <__errno>
8009330: 28 22 00 00 lw r2,(r1+0)
8009334: 34 01 00 22 mvi r1,34
8009338: 5c 41 00 12 bne r2,r1,8009380 <rtems_string_to_float+0xb8>
800933c: b9 80 08 00 mv r1,r12
8009340: 34 02 00 00 mvi r2,0
8009344: fb ff e6 78 calli 8002d24 <__eqsf2>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
8009348: 34 0b 00 0a mvi r11,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
800934c: 44 20 00 0f be r1,r0,8009388 <rtems_string_to_float+0xc0> <== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
8009350: 78 03 08 02 mvhi r3,0x802
8009354: 38 63 10 8c ori r3,r3,0x108c
8009358: 28 62 00 00 lw r2,(r3+0)
800935c: b9 80 08 00 mv r1,r12
8009360: f8 00 44 8f calli 801a59c <__gesf2>
8009364: 48 20 00 09 bg r1,r0,8009388 <rtems_string_to_float+0xc0> <== ALWAYS TAKEN
8009368: 78 03 08 02 mvhi r3,0x802 <== NOT EXECUTED
800936c: 38 63 10 90 ori r3,r3,0x1090 <== NOT EXECUTED
8009370: 28 62 00 00 lw r2,(r3+0) <== NOT EXECUTED
8009374: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
8009378: f8 00 44 db calli 801a6e4 <__lesf2> <== NOT EXECUTED
800937c: 48 01 00 03 bg r0,r1,8009388 <rtems_string_to_float+0xc0> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
*n = result;
8009380: 59 ac 00 00 sw (r13+0),r12
return RTEMS_SUCCESSFUL;
8009384: 34 0b 00 00 mvi r11,0
}
8009388: b9 60 08 00 mv r1,r11
800938c: 2b 9d 00 04 lw ra,(sp+4)
8009390: 2b 8b 00 18 lw r11,(sp+24)
8009394: 2b 8c 00 14 lw r12,(sp+20)
8009398: 2b 8d 00 10 lw r13,(sp+16)
800939c: 2b 8e 00 0c lw r14,(sp+12)
80093a0: 2b 8f 00 08 lw r15,(sp+8)
80093a4: 37 9c 00 1c addi sp,sp,28
80093a8: c3 a0 00 00 ret
080093ac <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
80093ac: 37 9c ff e8 addi sp,sp,-24
80093b0: 5b 8b 00 14 sw (sp+20),r11
80093b4: 5b 8c 00 10 sw (sp+16),r12
80093b8: 5b 8d 00 0c sw (sp+12),r13
80093bc: 5b 8e 00 08 sw (sp+8),r14
80093c0: 5b 9d 00 04 sw (sp+4),ra
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
80093c4: 34 05 00 09 mvi r5,9
const char *s,
int *n,
char **endptr,
int base
)
{
80093c8: b8 20 68 00 mv r13,r1
80093cc: b8 40 60 00 mv r12,r2
80093d0: b8 60 70 00 mv r14,r3
80093d4: b8 80 58 00 mv r11,r4
long result;
char *end;
if ( !n )
80093d8: 44 40 00 1f be r2,r0,8009454 <rtems_string_to_int+0xa8>
return RTEMS_INVALID_ADDRESS;
errno = 0;
80093dc: f8 00 10 38 calli 800d4bc <__errno>
80093e0: 58 20 00 00 sw (r1+0),r0
*n = 0;
result = strtol( s, &end, base );
80093e4: b9 60 18 00 mv r3,r11
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
80093e8: 59 80 00 00 sw (r12+0),r0
result = strtol( s, &end, base );
80093ec: b9 a0 08 00 mv r1,r13
80093f0: 37 82 00 18 addi r2,sp,24
80093f4: f8 00 1b fc calli 80103e4 <strtol>
80093f8: b8 20 58 00 mv r11,r1
if ( endptr )
80093fc: 45 c0 00 03 be r14,r0,8009408 <rtems_string_to_int+0x5c>
*endptr = end;
8009400: 2b 81 00 18 lw r1,(sp+24)
8009404: 59 c1 00 00 sw (r14+0),r1
if ( end == s )
8009408: 2b 81 00 18 lw r1,(sp+24)
return RTEMS_NOT_DEFINED;
800940c: 34 05 00 0b mvi r5,11
result = strtol( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
8009410: 44 2d 00 11 be r1,r13,8009454 <rtems_string_to_int+0xa8>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
8009414: f8 00 10 2a calli 800d4bc <__errno>
8009418: 28 22 00 00 lw r2,(r1+0)
800941c: 34 01 00 22 mvi r1,34
8009420: 5c 41 00 0b bne r2,r1,800944c <rtems_string_to_int+0xa0>
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
8009424: 78 02 08 02 mvhi r2,0x802
8009428: 38 42 09 00 ori r2,r2,0x900
800942c: 28 41 00 00 lw r1,(r2+0)
8009430: 65 62 00 00 cmpei r2,r11,0
return RTEMS_INVALID_NUMBER;
8009434: 34 05 00 0a mvi r5,10
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
8009438: e5 61 08 00 cmpe r1,r11,r1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
800943c: b8 22 08 00 or r1,r1,r2
8009440: 5c 20 00 05 bne r1,r0,8009454 <rtems_string_to_int+0xa8> <== ALWAYS TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
8009444: 78 01 80 00 mvhi r1,0x8000 <== NOT EXECUTED
8009448: 45 61 00 03 be r11,r1,8009454 <rtems_string_to_int+0xa8> <== NOT EXECUTED
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
800944c: 59 8b 00 00 sw (r12+0),r11
return RTEMS_SUCCESSFUL;
8009450: 34 05 00 00 mvi r5,0
}
8009454: b8 a0 08 00 mv r1,r5
8009458: 2b 9d 00 04 lw ra,(sp+4)
800945c: 2b 8b 00 14 lw r11,(sp+20)
8009460: 2b 8c 00 10 lw r12,(sp+16)
8009464: 2b 8d 00 0c lw r13,(sp+12)
8009468: 2b 8e 00 08 lw r14,(sp+8)
800946c: 37 9c 00 18 addi sp,sp,24
8009470: c3 a0 00 00 ret
08009564 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
8009564: 37 9c ff e8 addi sp,sp,-24
8009568: 5b 8b 00 14 sw (sp+20),r11
800956c: 5b 8c 00 10 sw (sp+16),r12
8009570: 5b 8d 00 0c sw (sp+12),r13
8009574: 5b 8e 00 08 sw (sp+8),r14
8009578: 5b 9d 00 04 sw (sp+4),ra
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
800957c: 34 05 00 09 mvi r5,9
const char *s,
long *n,
char **endptr,
int base
)
{
8009580: b8 20 68 00 mv r13,r1
8009584: b8 40 60 00 mv r12,r2
8009588: b8 60 70 00 mv r14,r3
800958c: b8 80 58 00 mv r11,r4
long result;
char *end;
if ( !n )
8009590: 44 40 00 1f be r2,r0,800960c <rtems_string_to_long+0xa8>
return RTEMS_INVALID_ADDRESS;
errno = 0;
8009594: f8 00 0f ca calli 800d4bc <__errno>
8009598: 58 20 00 00 sw (r1+0),r0
*n = 0;
result = strtol( s, &end, base );
800959c: b9 60 18 00 mv r3,r11
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
80095a0: 59 80 00 00 sw (r12+0),r0
result = strtol( s, &end, base );
80095a4: b9 a0 08 00 mv r1,r13
80095a8: 37 82 00 18 addi r2,sp,24
80095ac: f8 00 1b 8e calli 80103e4 <strtol>
80095b0: b8 20 58 00 mv r11,r1
if ( endptr )
80095b4: 45 c0 00 03 be r14,r0,80095c0 <rtems_string_to_long+0x5c>
*endptr = end;
80095b8: 2b 81 00 18 lw r1,(sp+24)
80095bc: 59 c1 00 00 sw (r14+0),r1
if ( end == s )
80095c0: 2b 81 00 18 lw r1,(sp+24)
return RTEMS_NOT_DEFINED;
80095c4: 34 05 00 0b mvi r5,11
result = strtol( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
80095c8: 44 2d 00 11 be r1,r13,800960c <rtems_string_to_long+0xa8>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
80095cc: f8 00 0f bc calli 800d4bc <__errno>
80095d0: 28 22 00 00 lw r2,(r1+0)
80095d4: 34 01 00 22 mvi r1,34
80095d8: 5c 41 00 0b bne r2,r1,8009604 <rtems_string_to_long+0xa0>
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
80095dc: 78 02 08 02 mvhi r2,0x802
80095e0: 38 42 09 00 ori r2,r2,0x900
80095e4: 28 41 00 00 lw r1,(r2+0)
80095e8: 65 62 00 00 cmpei r2,r11,0
return RTEMS_INVALID_NUMBER;
80095ec: 34 05 00 0a mvi r5,10
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
80095f0: e5 61 08 00 cmpe r1,r11,r1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
80095f4: b8 22 08 00 or r1,r1,r2
80095f8: 5c 20 00 05 bne r1,r0,800960c <rtems_string_to_long+0xa8>
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
80095fc: 78 01 80 00 mvhi r1,0x8000
8009600: 45 61 00 03 be r11,r1,800960c <rtems_string_to_long+0xa8> <== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
8009604: 59 8b 00 00 sw (r12+0),r11
return RTEMS_SUCCESSFUL;
8009608: 34 05 00 00 mvi r5,0
}
800960c: b8 a0 08 00 mv r1,r5
8009610: 2b 9d 00 04 lw ra,(sp+4)
8009614: 2b 8b 00 14 lw r11,(sp+20)
8009618: 2b 8c 00 10 lw r12,(sp+16)
800961c: 2b 8d 00 0c lw r13,(sp+12)
8009620: 2b 8e 00 08 lw r14,(sp+8)
8009624: 37 9c 00 18 addi sp,sp,24
8009628: c3 a0 00 00 ret
08009474 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
8009474: 37 9c ff e4 addi sp,sp,-28
8009478: 5b 8b 00 18 sw (sp+24),r11
800947c: 5b 8c 00 14 sw (sp+20),r12
8009480: 5b 8d 00 10 sw (sp+16),r13
8009484: 5b 8e 00 0c sw (sp+12),r14
8009488: 5b 8f 00 08 sw (sp+8),r15
800948c: 5b 9d 00 04 sw (sp+4),ra
long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
8009490: 34 05 00 09 mvi r5,9
const char *s,
long long *n,
char **endptr,
int base
)
{
8009494: b8 20 70 00 mv r14,r1
8009498: b8 40 58 00 mv r11,r2
800949c: b8 60 78 00 mv r15,r3
80094a0: b8 80 60 00 mv r12,r4
long long result;
char *end;
if ( !n )
80094a4: 44 40 00 27 be r2,r0,8009540 <rtems_string_to_long_long+0xcc>
return RTEMS_INVALID_ADDRESS;
errno = 0;
80094a8: f8 00 10 05 calli 800d4bc <__errno>
80094ac: 58 20 00 00 sw (r1+0),r0
*n = 0;
result = strtoll( s, &end, base );
80094b0: b9 80 18 00 mv r3,r12
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
80094b4: 59 60 00 00 sw (r11+0),r0
80094b8: 59 60 00 04 sw (r11+4),r0
result = strtoll( s, &end, base );
80094bc: b9 c0 08 00 mv r1,r14
80094c0: 37 82 00 1c addi r2,sp,28
80094c4: f8 00 1b d6 calli 801041c <strtoll>
80094c8: b8 20 68 00 mv r13,r1
80094cc: b8 40 60 00 mv r12,r2
if ( endptr )
80094d0: 45 e0 00 03 be r15,r0,80094dc <rtems_string_to_long_long+0x68>
*endptr = end;
80094d4: 2b 81 00 1c lw r1,(sp+28)
80094d8: 59 e1 00 00 sw (r15+0),r1
if ( end == s )
80094dc: 2b 81 00 1c lw r1,(sp+28)
return RTEMS_NOT_DEFINED;
80094e0: 34 05 00 0b mvi r5,11
result = strtoll( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
80094e4: 44 2e 00 17 be r1,r14,8009540 <rtems_string_to_long_long+0xcc>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
80094e8: f8 00 0f f5 calli 800d4bc <__errno>
80094ec: 28 22 00 00 lw r2,(r1+0)
80094f0: 34 01 00 22 mvi r1,34
80094f4: 5c 41 00 10 bne r2,r1,8009534 <rtems_string_to_long_long+0xc0>
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
80094f8: 78 02 08 02 mvhi r2,0x802
80094fc: 38 42 09 00 ori r2,r2,0x900
8009500: 28 41 00 00 lw r1,(r2+0)
8009504: a5 80 10 00 not r2,r12
return RTEMS_INVALID_NUMBER;
8009508: 34 05 00 0a mvi r5,10
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
800950c: 99 a1 08 00 xor r1,r13,r1
8009510: b8 22 08 00 or r1,r1,r2
8009514: b9 ac 10 00 or r2,r13,r12
8009518: 64 21 00 00 cmpei r1,r1,0
800951c: 64 42 00 00 cmpei r2,r2,0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
8009520: b8 22 08 00 or r1,r1,r2
8009524: 5c 20 00 07 bne r1,r0,8009540 <rtems_string_to_long_long+0xcc>
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
8009528: 78 01 80 00 mvhi r1,0x8000
800952c: 5d a1 00 02 bne r13,r1,8009534 <rtems_string_to_long_long+0xc0><== NEVER TAKEN
8009530: 45 80 00 04 be r12,r0,8009540 <rtems_string_to_long_long+0xcc><== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
8009534: 59 6d 00 00 sw (r11+0),r13
8009538: 59 6c 00 04 sw (r11+4),r12
return RTEMS_SUCCESSFUL;
800953c: 34 05 00 00 mvi r5,0
}
8009540: b8 a0 08 00 mv r1,r5
8009544: 2b 9d 00 04 lw ra,(sp+4)
8009548: 2b 8b 00 18 lw r11,(sp+24)
800954c: 2b 8c 00 14 lw r12,(sp+20)
8009550: 2b 8d 00 10 lw r13,(sp+16)
8009554: 2b 8e 00 0c lw r14,(sp+12)
8009558: 2b 8f 00 08 lw r15,(sp+8)
800955c: 37 9c 00 1c addi sp,sp,28
8009560: c3 a0 00 00 ret
08009648 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
8009648: 37 9c ff e8 addi sp,sp,-24
800964c: 5b 8b 00 14 sw (sp+20),r11
8009650: 5b 8c 00 10 sw (sp+16),r12
8009654: 5b 8d 00 0c sw (sp+12),r13
8009658: 5b 8e 00 08 sw (sp+8),r14
800965c: 5b 9d 00 04 sw (sp+4),ra
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
8009660: 34 05 00 09 mvi r5,9
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
8009664: b8 20 68 00 mv r13,r1
8009668: b8 40 58 00 mv r11,r2
800966c: b8 60 70 00 mv r14,r3
8009670: b8 80 60 00 mv r12,r4
unsigned long result;
char *end;
if ( !n )
8009674: 44 40 00 20 be r2,r0,80096f4 <rtems_string_to_unsigned_char+0xac>
return RTEMS_INVALID_ADDRESS;
errno = 0;
8009678: f8 00 0f 91 calli 800d4bc <__errno>
800967c: 58 20 00 00 sw (r1+0),r0
*n = 0;
result = strtoul( s, &end, base );
8009680: b9 80 18 00 mv r3,r12
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
8009684: 31 60 00 00 sb (r11+0),r0
result = strtoul( s, &end, base );
8009688: b9 a0 08 00 mv r1,r13
800968c: 37 82 00 18 addi r2,sp,24
8009690: f8 00 1c ce calli 80109c8 <strtoul>
8009694: b8 20 60 00 mv r12,r1
if ( endptr )
8009698: 45 c0 00 03 be r14,r0,80096a4 <rtems_string_to_unsigned_char+0x5c>
*endptr = end;
800969c: 2b 81 00 18 lw r1,(sp+24)
80096a0: 59 c1 00 00 sw (r14+0),r1
if ( end == s )
80096a4: 2b 81 00 18 lw r1,(sp+24)
return RTEMS_NOT_DEFINED;
80096a8: 34 05 00 0b mvi r5,11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
80096ac: 44 2d 00 12 be r1,r13,80096f4 <rtems_string_to_unsigned_char+0xac>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
80096b0: f8 00 0f 83 calli 800d4bc <__errno>
80096b4: 28 22 00 00 lw r2,(r1+0)
80096b8: 34 01 00 22 mvi r1,34
80096bc: 5c 41 00 05 bne r2,r1,80096d0 <rtems_string_to_unsigned_char+0x88><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
80096c0: 35 82 ff ff addi r2,r12,-1 <== NOT EXECUTED
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
80096c4: 34 01 ff fd mvi r1,-3 <== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
80096c8: 34 05 00 0a mvi r5,10 <== NOT EXECUTED
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
80096cc: 54 41 00 0a bgu r2,r1,80096f4 <rtems_string_to_unsigned_char+0xac><== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
80096d0: 34 01 00 ff mvi r1,255
80096d4: 50 2c 00 06 bgeu r1,r12,80096ec <rtems_string_to_unsigned_char+0xa4><== ALWAYS TAKEN
errno = ERANGE;
80096d8: f8 00 0f 79 calli 800d4bc <__errno> <== NOT EXECUTED
80096dc: 34 02 00 22 mvi r2,34 <== NOT EXECUTED
80096e0: 58 22 00 00 sw (r1+0),r2 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
80096e4: 34 05 00 0a mvi r5,10 <== NOT EXECUTED
80096e8: e0 00 00 03 bi 80096f4 <rtems_string_to_unsigned_char+0xac><== NOT EXECUTED
}
#endif
*n = result;
80096ec: 31 6c 00 00 sb (r11+0),r12
return RTEMS_SUCCESSFUL;
80096f0: 34 05 00 00 mvi r5,0
}
80096f4: b8 a0 08 00 mv r1,r5
80096f8: 2b 9d 00 04 lw ra,(sp+4)
80096fc: 2b 8b 00 14 lw r11,(sp+20)
8009700: 2b 8c 00 10 lw r12,(sp+16)
8009704: 2b 8d 00 0c lw r13,(sp+12)
8009708: 2b 8e 00 08 lw r14,(sp+8)
800970c: 37 9c 00 18 addi sp,sp,24
8009710: c3 a0 00 00 ret
08009714 <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
8009714: 37 9c ff e8 addi sp,sp,-24
8009718: 5b 8b 00 14 sw (sp+20),r11
800971c: 5b 8c 00 10 sw (sp+16),r12
8009720: 5b 8d 00 0c sw (sp+12),r13
8009724: 5b 8e 00 08 sw (sp+8),r14
8009728: 5b 9d 00 04 sw (sp+4),ra
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
800972c: 34 05 00 09 mvi r5,9
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
8009730: b8 20 68 00 mv r13,r1
8009734: b8 40 58 00 mv r11,r2
8009738: b8 60 70 00 mv r14,r3
800973c: b8 80 60 00 mv r12,r4
unsigned long result;
char *end;
if ( !n )
8009740: 44 40 00 19 be r2,r0,80097a4 <rtems_string_to_unsigned_int+0x90>
return RTEMS_INVALID_ADDRESS;
errno = 0;
8009744: f8 00 0f 5e calli 800d4bc <__errno>
8009748: 58 20 00 00 sw (r1+0),r0
*n = 0;
result = strtoul( s, &end, base );
800974c: b9 80 18 00 mv r3,r12
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
8009750: 59 60 00 00 sw (r11+0),r0
result = strtoul( s, &end, base );
8009754: b9 a0 08 00 mv r1,r13
8009758: 37 82 00 18 addi r2,sp,24
800975c: f8 00 1c 9b calli 80109c8 <strtoul>
8009760: b8 20 60 00 mv r12,r1
if ( endptr )
8009764: 45 c0 00 03 be r14,r0,8009770 <rtems_string_to_unsigned_int+0x5c>
*endptr = end;
8009768: 2b 81 00 18 lw r1,(sp+24)
800976c: 59 c1 00 00 sw (r14+0),r1
if ( end == s )
8009770: 2b 81 00 18 lw r1,(sp+24)
return RTEMS_NOT_DEFINED;
8009774: 34 05 00 0b mvi r5,11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
8009778: 44 2d 00 0b be r1,r13,80097a4 <rtems_string_to_unsigned_int+0x90>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
800977c: f8 00 0f 50 calli 800d4bc <__errno>
8009780: 28 22 00 00 lw r2,(r1+0)
8009784: 34 01 00 22 mvi r1,34
8009788: 5c 41 00 05 bne r2,r1,800979c <rtems_string_to_unsigned_int+0x88>
(( result == 0 ) || ( result == ULONG_MAX )))
800978c: 35 82 ff ff addi r2,r12,-1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
8009790: 34 01 ff fd mvi r1,-3
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
8009794: 34 05 00 0a mvi r5,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
8009798: 54 41 00 03 bgu r2,r1,80097a4 <rtems_string_to_unsigned_int+0x90><== ALWAYS TAKEN
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
800979c: 59 6c 00 00 sw (r11+0),r12
return RTEMS_SUCCESSFUL;
80097a0: 34 05 00 00 mvi r5,0
}
80097a4: b8 a0 08 00 mv r1,r5
80097a8: 2b 9d 00 04 lw ra,(sp+4)
80097ac: 2b 8b 00 14 lw r11,(sp+20)
80097b0: 2b 8c 00 10 lw r12,(sp+16)
80097b4: 2b 8d 00 0c lw r13,(sp+12)
80097b8: 2b 8e 00 08 lw r14,(sp+8)
80097bc: 37 9c 00 18 addi sp,sp,24
80097c0: c3 a0 00 00 ret
08009894 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
8009894: 37 9c ff e8 addi sp,sp,-24
8009898: 5b 8b 00 14 sw (sp+20),r11
800989c: 5b 8c 00 10 sw (sp+16),r12
80098a0: 5b 8d 00 0c sw (sp+12),r13
80098a4: 5b 8e 00 08 sw (sp+8),r14
80098a8: 5b 9d 00 04 sw (sp+4),ra
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
80098ac: 34 05 00 09 mvi r5,9
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
80098b0: b8 20 68 00 mv r13,r1
80098b4: b8 40 58 00 mv r11,r2
80098b8: b8 60 70 00 mv r14,r3
80098bc: b8 80 60 00 mv r12,r4
unsigned long result;
char *end;
if ( !n )
80098c0: 44 40 00 19 be r2,r0,8009924 <rtems_string_to_unsigned_long+0x90>
return RTEMS_INVALID_ADDRESS;
errno = 0;
80098c4: f8 00 0e fe calli 800d4bc <__errno>
80098c8: 58 20 00 00 sw (r1+0),r0
*n = 0;
result = strtoul( s, &end, base );
80098cc: b9 80 18 00 mv r3,r12
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
80098d0: 59 60 00 00 sw (r11+0),r0
result = strtoul( s, &end, base );
80098d4: b9 a0 08 00 mv r1,r13
80098d8: 37 82 00 18 addi r2,sp,24
80098dc: f8 00 1c 3b calli 80109c8 <strtoul>
80098e0: b8 20 60 00 mv r12,r1
if ( endptr )
80098e4: 45 c0 00 03 be r14,r0,80098f0 <rtems_string_to_unsigned_long+0x5c>
*endptr = end;
80098e8: 2b 81 00 18 lw r1,(sp+24)
80098ec: 59 c1 00 00 sw (r14+0),r1
if ( end == s )
80098f0: 2b 81 00 18 lw r1,(sp+24)
return RTEMS_NOT_DEFINED;
80098f4: 34 05 00 0b mvi r5,11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
80098f8: 44 2d 00 0b be r1,r13,8009924 <rtems_string_to_unsigned_long+0x90>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
80098fc: f8 00 0e f0 calli 800d4bc <__errno>
8009900: 28 22 00 00 lw r2,(r1+0)
8009904: 34 01 00 22 mvi r1,34
8009908: 5c 41 00 05 bne r2,r1,800991c <rtems_string_to_unsigned_long+0x88>
(( result == 0 ) || ( result == ULONG_MAX )))
800990c: 35 82 ff ff addi r2,r12,-1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
8009910: 34 01 ff fd mvi r1,-3
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
8009914: 34 05 00 0a mvi r5,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
8009918: 54 41 00 03 bgu r2,r1,8009924 <rtems_string_to_unsigned_long+0x90><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
800991c: 59 6c 00 00 sw (r11+0),r12
return RTEMS_SUCCESSFUL;
8009920: 34 05 00 00 mvi r5,0
}
8009924: b8 a0 08 00 mv r1,r5
8009928: 2b 9d 00 04 lw ra,(sp+4)
800992c: 2b 8b 00 14 lw r11,(sp+20)
8009930: 2b 8c 00 10 lw r12,(sp+16)
8009934: 2b 8d 00 0c lw r13,(sp+12)
8009938: 2b 8e 00 08 lw r14,(sp+8)
800993c: 37 9c 00 18 addi sp,sp,24
8009940: c3 a0 00 00 ret
080097c4 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
80097c4: 37 9c ff e4 addi sp,sp,-28
80097c8: 5b 8b 00 18 sw (sp+24),r11
80097cc: 5b 8c 00 14 sw (sp+20),r12
80097d0: 5b 8d 00 10 sw (sp+16),r13
80097d4: 5b 8e 00 0c sw (sp+12),r14
80097d8: 5b 8f 00 08 sw (sp+8),r15
80097dc: 5b 9d 00 04 sw (sp+4),ra
unsigned long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
80097e0: 34 05 00 09 mvi r5,9
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
80097e4: b8 20 70 00 mv r14,r1
80097e8: b8 40 58 00 mv r11,r2
80097ec: b8 60 78 00 mv r15,r3
80097f0: b8 80 60 00 mv r12,r4
unsigned long long result;
char *end;
if ( !n )
80097f4: 44 40 00 1f be r2,r0,8009870 <rtems_string_to_unsigned_long_long+0xac>
return RTEMS_INVALID_ADDRESS;
errno = 0;
80097f8: f8 00 0f 31 calli 800d4bc <__errno>
80097fc: 58 20 00 00 sw (r1+0),r0
*n = 0;
result = strtoull( s, &end, base );
8009800: b9 80 18 00 mv r3,r12
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
8009804: 59 60 00 00 sw (r11+0),r0
8009808: 59 60 00 04 sw (r11+4),r0
result = strtoull( s, &end, base );
800980c: b9 c0 08 00 mv r1,r14
8009810: 37 82 00 1c addi r2,sp,28
8009814: f8 00 1c 7b calli 8010a00 <strtoull>
8009818: b8 20 68 00 mv r13,r1
800981c: b8 40 60 00 mv r12,r2
if ( endptr )
8009820: 45 e0 00 03 be r15,r0,800982c <rtems_string_to_unsigned_long_long+0x68>
*endptr = end;
8009824: 2b 81 00 1c lw r1,(sp+28)
8009828: 59 e1 00 00 sw (r15+0),r1
if ( end == s )
800982c: 2b 81 00 1c lw r1,(sp+28)
return RTEMS_NOT_DEFINED;
8009830: 34 05 00 0b mvi r5,11
result = strtoull( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
8009834: 44 2e 00 0f be r1,r14,8009870 <rtems_string_to_unsigned_long_long+0xac>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
8009838: f8 00 0f 21 calli 800d4bc <__errno>
800983c: 28 22 00 00 lw r2,(r1+0)
8009840: 34 01 00 22 mvi r1,34
8009844: 5c 41 00 08 bne r2,r1,8009864 <rtems_string_to_unsigned_long_long+0xa0>
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
8009848: 35 81 ff ff addi r1,r12,-1
800984c: f5 81 18 00 cmpgu r3,r12,r1
8009850: c8 0d 10 00 sub r2,r0,r13
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
8009854: 5c 62 00 04 bne r3,r2,8009864 <rtems_string_to_unsigned_long_long+0xa0><== NEVER TAKEN
8009858: 34 02 ff fd mvi r2,-3
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
800985c: 34 05 00 0a mvi r5,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
8009860: 54 22 00 04 bgu r1,r2,8009870 <rtems_string_to_unsigned_long_long+0xac><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
8009864: 59 6d 00 00 sw (r11+0),r13
8009868: 59 6c 00 04 sw (r11+4),r12
return RTEMS_SUCCESSFUL;
800986c: 34 05 00 00 mvi r5,0
}
8009870: b8 a0 08 00 mv r1,r5
8009874: 2b 9d 00 04 lw ra,(sp+4)
8009878: 2b 8b 00 18 lw r11,(sp+24)
800987c: 2b 8c 00 14 lw r12,(sp+20)
8009880: 2b 8d 00 10 lw r13,(sp+16)
8009884: 2b 8e 00 0c lw r14,(sp+12)
8009888: 2b 8f 00 08 lw r15,(sp+8)
800988c: 37 9c 00 1c addi sp,sp,28
8009890: c3 a0 00 00 ret
08000ec0 <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
8000ec0: 37 9c fe 20 addi sp,sp,-480
8000ec4: 5b 8b 00 44 sw (sp+68),r11
8000ec8: 5b 8c 00 40 sw (sp+64),r12
8000ecc: 5b 8d 00 3c sw (sp+60),r13
8000ed0: 5b 8e 00 38 sw (sp+56),r14
8000ed4: 5b 8f 00 34 sw (sp+52),r15
8000ed8: 5b 90 00 30 sw (sp+48),r16
8000edc: 5b 91 00 2c sw (sp+44),r17
8000ee0: 5b 92 00 28 sw (sp+40),r18
8000ee4: 5b 93 00 24 sw (sp+36),r19
8000ee8: 5b 94 00 20 sw (sp+32),r20
8000eec: 5b 95 00 1c sw (sp+28),r21
8000ef0: 5b 96 00 18 sw (sp+24),r22
8000ef4: 5b 97 00 14 sw (sp+20),r23
8000ef8: 5b 98 00 10 sw (sp+16),r24
8000efc: 5b 99 00 0c sw (sp+12),r25
8000f00: 5b 9b 00 08 sw (sp+8),fp
8000f04: 5b 9d 00 04 sw (sp+4),ra
8000f08: b8 20 98 00 mv r19,r1
8000f0c: b8 40 a0 00 mv r20,r2
8000f10: 5b 83 00 50 sw (sp+80),r3
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
8000f14: f8 00 43 41 calli 8011c18 <strlen>
8000f18: b8 20 10 00 mv r2,r1
8000f1c: 34 03 00 00 mvi r3,0
8000f20: ba 60 08 00 mv r1,r19
8000f24: 37 84 01 cc addi r4,sp,460
8000f28: 34 05 00 00 mvi r5,0
8000f2c: f8 00 03 3d calli 8001c20 <rtems_filesystem_evaluate_path>
8000f30: b8 20 60 00 mv r12,r1
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
8000f34: 5c 20 00 71 bne r1,r0,80010f8 <rtems_tarfs_load+0x238>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
8000f38: 2b 81 01 d8 lw r1,(sp+472)
8000f3c: 78 04 08 02 mvhi r4,0x802
8000f40: 38 84 13 00 ori r4,r4,0x1300
8000f44: 34 0b 00 00 mvi r11,0
8000f48: 44 24 00 08 be r1,r4,8000f68 <rtems_tarfs_load+0xa8>
8000f4c: 78 04 08 02 mvhi r4,0x802
8000f50: 38 84 1b 68 ori r4,r4,0x1b68
8000f54: b9 80 58 00 mv r11,r12
8000f58: 5c 24 00 68 bne r1,r4,80010f8 <rtems_tarfs_load+0x238> <== ALWAYS TAKEN
8000f5c: e0 00 00 03 bi 8000f68 <rtems_tarfs_load+0xa8> <== NOT EXECUTED
8000f60: b9 c0 58 00 mv r11,r14
8000f64: e0 00 00 0c bi 8000f94 <rtems_tarfs_load+0xd4>
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
8000f68: 78 11 08 02 mvhi r17,0x802
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
if (full_filename[strlen(full_filename)-1] != '/')
strcat(full_filename, "/");
8000f6c: 78 0f 08 01 mvhi r15,0x801
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
8000f70: 3a 31 13 48 ori r17,r17,0x1348
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
8000f74: 37 90 01 54 addi r16,sp,340
* 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) {
8000f78: 34 1b 00 30 mvi fp,48
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
8000f7c: 37 92 01 b8 addi r18,sp,440
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
}
nblocks = (((file_size) + 511) & ~511) / 512;
8000f80: 34 19 fe 00 mvi r25,-512
* - 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);
8000f84: 37 8d 00 54 addi r13,sp,84
if (full_filename[strlen(full_filename)-1] != '/')
8000f88: 37 98 00 53 addi r24,sp,83
8000f8c: 34 17 00 2f mvi r23,47
strcat(full_filename, "/");
8000f90: 39 ef e7 a4 ori r15,r15,0xe7a4
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
8000f94: 2b 81 00 50 lw r1,(sp+80)
8000f98: 35 6e 02 00 addi r14,r11,512
8000f9c: 55 c1 00 58 bgu r14,r1,80010fc <rtems_tarfs_load+0x23c> <== NEVER TAKEN
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
8000fa0: b6 8b 58 00 add r11,r20,r11
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
8000fa4: 35 61 01 01 addi r1,r11,257
8000fa8: ba 20 10 00 mv r2,r17
8000fac: 34 03 00 05 mvi r3,5
8000fb0: f8 00 43 49 calli 8011cd4 <strncmp>
8000fb4: 5c 20 00 52 bne r1,r0,80010fc <rtems_tarfs_load+0x23c> <== NEVER TAKEN
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
8000fb8: 34 03 00 63 mvi r3,99
8000fbc: b9 60 10 00 mv r2,r11
8000fc0: ba 00 08 00 mv r1,r16
8000fc4: f8 00 43 91 calli 8011e08 <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
8000fc8: 34 02 00 08 mvi r2,8
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
8000fcc: 33 80 01 b7 sb (sp+439),r0
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
8000fd0: 35 61 00 64 addi r1,r11,100
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
8000fd4: 41 76 00 9c lbu r22,(r11+156)
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
8000fd8: f8 00 1a 74 calli 80079a8 <_rtems_octal2ulong>
8000fdc: 5b 81 00 4c sw (sp+76),r1
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
8000fe0: 34 02 00 0c mvi r2,12
8000fe4: 35 61 00 7c addi r1,r11,124
8000fe8: f8 00 1a 70 calli 80079a8 <_rtems_octal2ulong>
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
8000fec: 34 02 00 08 mvi r2,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);
8000ff0: b8 20 a8 00 mv r21,r1
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
8000ff4: 35 61 00 94 addi r1,r11,148
8000ff8: f8 00 1a 6c calli 80079a8 <_rtems_octal2ulong>
8000ffc: b8 20 10 00 mv r2,r1
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
8001000: b9 60 08 00 mv r1,r11
8001004: 5b 82 00 48 sw (sp+72),r2
8001008: f8 00 1a 87 calli 8007a24 <_rtems_tar_header_checksum>
800100c: 2b 82 00 48 lw r2,(sp+72)
8001010: 5c 22 00 3b bne r1,r2,80010fc <rtems_tarfs_load+0x23c> <== NEVER TAKEN
* Generate an IMFS node depending on the file type.
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
8001014: 34 01 00 35 mvi r1,53
8001018: 5e c1 00 13 bne r22,r1,8001064 <rtems_tarfs_load+0x1a4>
strcpy(full_filename, mountpoint);
800101c: ba 60 10 00 mv r2,r19
8001020: b9 a0 08 00 mv r1,r13
8001024: f8 00 41 c9 calli 8011748 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
8001028: b9 a0 08 00 mv r1,r13
800102c: f8 00 42 fb calli 8011c18 <strlen>
8001030: b7 01 08 00 add r1,r24,r1
8001034: 40 21 00 00 lbu r1,(r1+0)
8001038: 44 37 00 04 be r1,r23,8001048 <rtems_tarfs_load+0x188> <== ALWAYS TAKEN
strcat(full_filename, "/");
800103c: b9 a0 08 00 mv r1,r13 <== NOT EXECUTED
8001040: b9 e0 10 00 mv r2,r15 <== NOT EXECUTED
8001044: f8 00 41 6a calli 80115ec <strcat> <== NOT EXECUTED
strcat(full_filename, filename);
8001048: ba 00 10 00 mv r2,r16
800104c: b9 a0 08 00 mv r1,r13
8001050: f8 00 41 67 calli 80115ec <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
8001054: b9 a0 08 00 mv r1,r13
8001058: 34 02 01 ff mvi r2,511
800105c: f8 00 05 9b calli 80026c8 <mkdir>
8001060: e3 ff ff c0 bi 8000f60 <rtems_tarfs_load+0xa0>
* 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) {
8001064: 5e db ff bf bne r22,fp,8000f60 <rtems_tarfs_load+0xa0> <== NEVER TAKEN
const char *name;
loc = root_loc;
8001068: 2b 81 01 cc lw r1,(sp+460)
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
800106c: ba 40 10 00 mv r2,r18
8001070: 37 83 01 e0 addi r3,sp,480
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
8001074: 5b 81 01 b8 sw (sp+440),r1
8001078: 2b 81 01 d0 lw r1,(sp+464)
800107c: 5b 81 01 bc sw (sp+444),r1
8001080: 2b 81 01 d4 lw r1,(sp+468)
8001084: 5b 81 01 c0 sw (sp+448),r1
8001088: 2b 81 01 d8 lw r1,(sp+472)
800108c: 5b 81 01 c4 sw (sp+452),r1
8001090: 2b 81 01 dc lw r1,(sp+476)
8001094: 5b 81 01 c8 sw (sp+456),r1
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
8001098: ba 00 08 00 mv r1,r16
800109c: f8 00 1e 1f calli 8008918 <IMFS_evaluate_for_make>
80010a0: 5c 20 00 0e bne r1,r0,80010d8 <rtems_tarfs_load+0x218> <== NEVER TAKEN
node = IMFS_create_node(
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
80010a4: 2b 81 00 4c lw r1,(sp+76)
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
80010a8: 2b 83 01 e0 lw r3,(sp+480)
80010ac: 34 02 00 06 mvi r2,6
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
80010b0: 20 24 01 ff andi r4,r1,0x1ff
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
80010b4: 38 84 80 00 ori r4,r4,0x8000
80010b8: ba 40 08 00 mv r1,r18
80010bc: 34 05 00 00 mvi r5,0
80010c0: f8 00 1c 24 calli 8008150 <IMFS_create_node>
80010c4: b8 20 20 00 mv r4,r1
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
80010c8: 58 20 00 50 sw (r1+80),r0
80010cc: 58 35 00 54 sw (r1+84),r21
node->info.linearfile.direct = &tar_image[offset];
80010d0: b6 8e 08 00 add r1,r20,r14
80010d4: 58 81 00 58 sw (r4+88),r1
}
nblocks = (((file_size) + 511) & ~511) / 512;
80010d8: 36 a1 01 ff addi r1,r21,511
80010dc: 34 02 00 09 mvi r2,9
80010e0: a0 39 08 00 and r1,r1,r25
80010e4: f8 00 73 13 calli 801dd30 <__lshrsi3>
offset += 512 * nblocks;
80010e8: 34 02 00 09 mvi r2,9
80010ec: f8 00 72 c3 calli 801dbf8 <__ashlsi3>
80010f0: b4 2e 70 00 add r14,r1,r14
80010f4: e3 ff ff 9b bi 8000f60 <rtems_tarfs_load+0xa0>
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
return -1;
80010f8: 34 0c ff ff mvi r12,-1
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
80010fc: b9 80 08 00 mv r1,r12
8001100: 2b 9d 00 04 lw ra,(sp+4)
8001104: 2b 8b 00 44 lw r11,(sp+68)
8001108: 2b 8c 00 40 lw r12,(sp+64)
800110c: 2b 8d 00 3c lw r13,(sp+60)
8001110: 2b 8e 00 38 lw r14,(sp+56)
8001114: 2b 8f 00 34 lw r15,(sp+52)
8001118: 2b 90 00 30 lw r16,(sp+48)
800111c: 2b 91 00 2c lw r17,(sp+44)
8001120: 2b 92 00 28 lw r18,(sp+40)
8001124: 2b 93 00 24 lw r19,(sp+36)
8001128: 2b 94 00 20 lw r20,(sp+32)
800112c: 2b 95 00 1c lw r21,(sp+28)
8001130: 2b 96 00 18 lw r22,(sp+24)
8001134: 2b 97 00 14 lw r23,(sp+20)
8001138: 2b 98 00 10 lw r24,(sp+16)
800113c: 2b 99 00 0c lw r25,(sp+12)
8001140: 2b 9b 00 08 lw fp,(sp+8)
8001144: 37 9c 01 e0 addi sp,sp,480
8001148: c3 a0 00 00 ret
0800e094 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
800e094: 37 9c ff e0 addi sp,sp,-32
800e098: 5b 8b 00 20 sw (sp+32),r11
800e09c: 5b 8c 00 1c sw (sp+28),r12
800e0a0: 5b 8d 00 18 sw (sp+24),r13
800e0a4: 5b 8e 00 14 sw (sp+20),r14
800e0a8: 5b 8f 00 10 sw (sp+16),r15
800e0ac: 5b 90 00 0c sw (sp+12),r16
800e0b0: 5b 91 00 08 sw (sp+8),r17
800e0b4: 5b 9d 00 04 sw (sp+4),ra
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
800e0b8: 34 04 00 09 mvi r4,9
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
800e0bc: b8 20 68 00 mv r13,r1
800e0c0: b8 40 70 00 mv r14,r2
800e0c4: b8 60 80 00 mv r16,r3
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
800e0c8: 44 60 00 51 be r3,r0,800e20c <rtems_task_mode+0x178>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
800e0cc: 78 01 08 01 mvhi r1,0x801
800e0d0: 38 21 9e 3c ori r1,r1,0x9e3c
800e0d4: 28 2c 00 0c lw r12,(r1+12)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
800e0d8: 41 8f 00 74 lbu r15,(r12+116)
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
800e0dc: 29 81 00 7c lw r1,(r12+124)
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
800e0e0: 29 8b 01 1c lw r11,(r12+284)
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
800e0e4: 65 ef 00 00 cmpei r15,r15,0
800e0e8: c8 0f 78 00 sub r15,r0,r15
800e0ec: 21 ef 01 00 andi r15,r15,0x100
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
800e0f0: 44 20 00 02 be r1,r0,800e0f8 <rtems_task_mode+0x64>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
800e0f4: 39 ef 02 00 ori r15,r15,0x200
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
800e0f8: 41 71 00 08 lbu r17,(r11+8)
old_mode |= _ISR_Get_level();
800e0fc: fb ff e7 f8 calli 80080dc <_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;
800e100: 66 31 00 00 cmpei r17,r17,0
800e104: c8 11 88 00 sub r17,r0,r17
800e108: 22 31 04 00 andi r17,r17,0x400
800e10c: ba 21 08 00 or r1,r17,r1
old_mode |= _ISR_Get_level();
800e110: b8 2f 78 00 or r15,r1,r15
*previous_mode_set = old_mode;
800e114: 5a 0f 00 00 sw (r16+0),r15
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
800e118: 21 c1 01 00 andi r1,r14,0x100
800e11c: 44 20 00 04 be r1,r0,800e12c <rtems_task_mode+0x98>
*/
RTEMS_INLINE_ROUTINE bool _Modes_Is_preempt (
Modes_Control mode_set
)
{
return (mode_set & RTEMS_PREEMPT_MASK) == RTEMS_PREEMPT;
800e120: 21 a1 01 00 andi r1,r13,0x100
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
800e124: 64 21 00 00 cmpei r1,r1,0
800e128: 31 81 00 74 sb (r12+116),r1
if ( mask & RTEMS_TIMESLICE_MASK ) {
800e12c: 21 c1 02 00 andi r1,r14,0x200
800e130: 44 20 00 0b be r1,r0,800e15c <rtems_task_mode+0xc8>
*/
RTEMS_INLINE_ROUTINE bool _Modes_Is_timeslice (
Modes_Control mode_set
)
{
return (mode_set & RTEMS_TIMESLICE_MASK) == RTEMS_TIMESLICE;
800e134: 21 a1 02 00 andi r1,r13,0x200
if ( _Modes_Is_timeslice(mode_set) ) {
800e138: 44 20 00 08 be r1,r0,800e158 <rtems_task_mode+0xc4>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
800e13c: 34 01 00 01 mvi r1,1
800e140: 59 81 00 7c sw (r12+124),r1
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
800e144: 78 01 08 01 mvhi r1,0x801
800e148: 38 21 99 28 ori r1,r1,0x9928
800e14c: 28 21 00 00 lw r1,(r1+0)
800e150: 59 81 00 78 sw (r12+120),r1
800e154: e0 00 00 02 bi 800e15c <rtems_task_mode+0xc8>
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
800e158: 59 80 00 7c sw (r12+124),r0
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
800e15c: 21 c1 00 01 andi r1,r14,0x1
800e160: 44 20 00 04 be r1,r0,800e170 <rtems_task_mode+0xdc>
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
800e164: 21 a1 00 01 andi r1,r13,0x1
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
800e168: 64 21 00 00 cmpei r1,r1,0
800e16c: d0 01 00 00 wcsr IE,r1
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
800e170: 21 ce 04 00 andi r14,r14,0x400
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
800e174: 34 03 00 00 mvi r3,0
if ( mask & RTEMS_ASR_MASK ) {
800e178: 45 c0 00 11 be r14,r0,800e1bc <rtems_task_mode+0x128>
*/
RTEMS_INLINE_ROUTINE bool _Modes_Is_asr_disabled (
Modes_Control mode_set
)
{
return (mode_set & RTEMS_ASR_MASK) == RTEMS_NO_ASR;
800e17c: 21 ad 04 00 andi r13,r13,0x400
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
800e180: 41 61 00 08 lbu r1,(r11+8)
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
800e184: 65 ad 00 00 cmpei r13,r13,0
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 ) {
800e188: 44 2d 00 0d be r1,r13,800e1bc <rtems_task_mode+0x128>
asr->is_enabled = is_asr_enabled;
800e18c: 31 6d 00 08 sb (r11+8),r13
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
800e190: 90 00 08 00 rcsr r1,IE
800e194: 34 02 ff fe mvi r2,-2
800e198: a0 22 10 00 and r2,r1,r2
800e19c: d0 02 00 00 wcsr IE,r2
_signals = information->signals_pending;
800e1a0: 29 62 00 18 lw r2,(r11+24)
information->signals_pending = information->signals_posted;
800e1a4: 29 63 00 14 lw r3,(r11+20)
information->signals_posted = _signals;
800e1a8: 59 62 00 14 sw (r11+20),r2
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
800e1ac: 59 63 00 18 sw (r11+24),r3
information->signals_posted = _signals;
_ISR_Enable( _level );
800e1b0: d0 01 00 00 wcsr IE,r1
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
800e1b4: 29 63 00 14 lw r3,(r11+20)
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
800e1b8: 7c 63 00 00 cmpnei r3,r3,0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
800e1bc: 78 01 08 01 mvhi r1,0x801
800e1c0: 38 21 9a e8 ori r1,r1,0x9ae8
800e1c4: 28 22 00 00 lw r2,(r1+0)
800e1c8: 34 01 00 03 mvi r1,3
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
800e1cc: 34 04 00 00 mvi r4,0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
800e1d0: 5c 41 00 0f bne r2,r1,800e20c <rtems_task_mode+0x178>
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
800e1d4: 78 01 08 01 mvhi r1,0x801
800e1d8: 38 21 9e 3c ori r1,r1,0x9e3c
800e1dc: 28 22 00 0c lw r2,(r1+12)
if ( are_signals_pending ||
800e1e0: 5c 60 00 05 bne r3,r0,800e1f4 <rtems_task_mode+0x160>
800e1e4: 28 21 00 10 lw r1,(r1+16)
800e1e8: 44 41 00 09 be r2,r1,800e20c <rtems_task_mode+0x178>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
800e1ec: 40 41 00 74 lbu r1,(r2+116)
800e1f0: 44 20 00 07 be r1,r0,800e20c <rtems_task_mode+0x178> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
800e1f4: 78 01 08 01 mvhi r1,0x801
800e1f8: 38 21 9e 3c ori r1,r1,0x9e3c
800e1fc: 34 02 00 01 mvi r2,1
800e200: 30 22 00 18 sb (r1+24),r2
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
800e204: fb ff e1 e9 calli 80069a8 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
800e208: 34 04 00 00 mvi r4,0
}
800e20c: b8 80 08 00 mv r1,r4
800e210: 2b 9d 00 04 lw ra,(sp+4)
800e214: 2b 8b 00 20 lw r11,(sp+32)
800e218: 2b 8c 00 1c lw r12,(sp+28)
800e21c: 2b 8d 00 18 lw r13,(sp+24)
800e220: 2b 8e 00 14 lw r14,(sp+20)
800e224: 2b 8f 00 10 lw r15,(sp+16)
800e228: 2b 90 00 0c lw r16,(sp+12)
800e22c: 2b 91 00 08 lw r17,(sp+8)
800e230: 37 9c 00 20 addi sp,sp,32
800e234: c3 a0 00 00 ret
080084c8 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
80084c8: 37 9c ff f0 addi sp,sp,-16
80084cc: 5b 8b 00 0c sw (sp+12),r11
80084d0: 5b 8c 00 08 sw (sp+8),r12
80084d4: 5b 9d 00 04 sw (sp+4),ra
80084d8: b8 40 58 00 mv r11,r2
80084dc: b8 60 60 00 mv r12,r3
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
80084e0: 44 40 00 06 be r2,r0,80084f8 <rtems_task_set_priority+0x30>
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
80084e4: 78 02 08 01 mvhi r2,0x801
80084e8: 38 42 a0 f0 ori r2,r2,0xa0f0
80084ec: 40 43 00 00 lbu r3,(r2+0)
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
80084f0: 34 02 00 13 mvi r2,19
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
80084f4: 55 63 00 16 bgu r11,r3,800854c <rtems_task_set_priority+0x84>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
80084f8: 34 02 00 09 mvi r2,9
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
80084fc: 45 80 00 14 be r12,r0,800854c <rtems_task_set_priority+0x84>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
8008500: 37 82 00 10 addi r2,sp,16
8008504: f8 00 0a f8 calli 800b0e4 <_Thread_Get>
switch ( location ) {
8008508: 2b 82 00 10 lw r2,(sp+16)
800850c: 5c 40 00 0f bne r2,r0,8008548 <rtems_task_set_priority+0x80>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
8008510: 28 23 00 14 lw r3,(r1+20)
8008514: 59 83 00 00 sw (r12+0),r3
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
8008518: 45 62 00 09 be r11,r2,800853c <rtems_task_set_priority+0x74>
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
800851c: 28 22 00 1c lw r2,(r1+28)
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
the_thread->real_priority = new_priority;
8008520: 58 2b 00 18 sw (r1+24),r11
if ( the_thread->resource_count == 0 ||
8008524: 44 40 00 03 be r2,r0,8008530 <rtems_task_set_priority+0x68>
8008528: 28 22 00 14 lw r2,(r1+20)
800852c: 51 62 00 04 bgeu r11,r2,800853c <rtems_task_set_priority+0x74><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
8008530: b9 60 10 00 mv r2,r11
8008534: 34 03 00 00 mvi r3,0
8008538: f8 00 09 ad calli 800abec <_Thread_Change_priority>
}
_Thread_Enable_dispatch();
800853c: f8 00 0a dd calli 800b0b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8008540: 34 02 00 00 mvi r2,0
8008544: e0 00 00 02 bi 800854c <rtems_task_set_priority+0x84>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8008548: 34 02 00 04 mvi r2,4
}
800854c: b8 40 08 00 mv r1,r2
8008550: 2b 9d 00 04 lw ra,(sp+4)
8008554: 2b 8b 00 0c lw r11,(sp+12)
8008558: 2b 8c 00 08 lw r12,(sp+8)
800855c: 37 9c 00 10 addi sp,sp,16
8008560: c3 a0 00 00 ret
080046ec <rtems_termios_baud_to_index>:
#include <rtems/termiostypes.h>
int rtems_termios_baud_to_index(
rtems_termios_baud_t termios_baud
)
{
80046ec: b8 20 10 00 mv r2,r1
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
80046f0: 34 01 00 09 mvi r1,9
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
80046f4: 44 41 00 38 be r2,r1,80047d4 <rtems_termios_baud_to_index+0xe8>
80046f8: 48 41 00 19 bg r2,r1,800475c <rtems_termios_baud_to_index+0x70>
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
80046fc: 34 01 00 04 mvi r1,4
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
8004700: 44 41 00 35 be r2,r1,80047d4 <rtems_termios_baud_to_index+0xe8>
8004704: 48 41 00 0c bg r2,r1,8004734 <rtems_termios_baud_to_index+0x48>
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
8004708: 34 01 00 01 mvi r1,1
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
800470c: 44 41 00 32 be r2,r1,80047d4 <rtems_termios_baud_to_index+0xe8>
8004710: 48 41 00 04 bg r2,r1,8004720 <rtems_termios_baud_to_index+0x34>
case B0: baud_index = 0; break;
8004714: 34 01 00 00 mvi r1,0
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
8004718: 5c 40 00 2e bne r2,r0,80047d0 <rtems_termios_baud_to_index+0xe4>
800471c: c3 a0 00 00 ret
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
8004720: 34 01 00 02 mvi r1,2
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
8004724: 44 41 00 2c be r2,r1,80047d4 <rtems_termios_baud_to_index+0xe8>
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
8004728: 34 01 00 03 mvi r1,3
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
800472c: 5c 41 00 29 bne r2,r1,80047d0 <rtems_termios_baud_to_index+0xe4><== NEVER TAKEN
8004730: c3 a0 00 00 ret
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
8004734: 34 01 00 06 mvi r1,6
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
8004738: 44 41 00 27 be r2,r1,80047d4 <rtems_termios_baud_to_index+0xe8>
800473c: 34 03 00 06 mvi r3,6
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
8004740: 34 01 00 05 mvi r1,5
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
8004744: 48 62 00 24 bg r3,r2,80047d4 <rtems_termios_baud_to_index+0xe8>
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
8004748: 34 01 00 07 mvi r1,7
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
800474c: 44 41 00 22 be r2,r1,80047d4 <rtems_termios_baud_to_index+0xe8>
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
8004750: 34 01 00 08 mvi r1,8
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
8004754: 5c 41 00 1f bne r2,r1,80047d0 <rtems_termios_baud_to_index+0xe4><== NEVER TAKEN
8004758: c3 a0 00 00 ret
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
800475c: 34 01 00 0e mvi r1,14
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
8004760: 44 41 00 1d be r2,r1,80047d4 <rtems_termios_baud_to_index+0xe8>
8004764: 48 41 00 0b bg r2,r1,8004790 <rtems_termios_baud_to_index+0xa4>
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
8004768: 34 01 00 0b mvi r1,11
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
800476c: 44 41 00 1a be r2,r1,80047d4 <rtems_termios_baud_to_index+0xe8>
8004770: 34 03 00 0b mvi r3,11
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
8004774: 34 01 00 0a mvi r1,10
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
8004778: 48 62 00 17 bg r3,r2,80047d4 <rtems_termios_baud_to_index+0xe8>
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
800477c: 34 01 00 0c mvi r1,12
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
8004780: 44 41 00 15 be r2,r1,80047d4 <rtems_termios_baud_to_index+0xe8>
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
8004784: 34 01 00 0d mvi r1,13
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
8004788: 5c 41 00 12 bne r2,r1,80047d0 <rtems_termios_baud_to_index+0xe4><== NEVER TAKEN
800478c: c3 a0 00 00 ret
8004790: 34 03 10 02 mvi r3,4098
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
8004794: 34 01 00 11 mvi r1,17
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
8004798: 44 43 00 0f be r2,r3,80047d4 <rtems_termios_baud_to_index+0xe8>
800479c: 48 43 00 07 bg r2,r3,80047b8 <rtems_termios_baud_to_index+0xcc>
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
80047a0: 34 01 00 0f mvi r1,15
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
80047a4: 44 41 00 0c be r2,r1,80047d4 <rtems_termios_baud_to_index+0xe8>
80047a8: 34 03 10 01 mvi r3,4097
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
80047ac: 34 01 00 10 mvi r1,16
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
80047b0: 5c 43 00 08 bne r2,r3,80047d0 <rtems_termios_baud_to_index+0xe4><== NEVER TAKEN
80047b4: c3 a0 00 00 ret
80047b8: 34 03 10 03 mvi r3,4099
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
80047bc: 34 01 00 12 mvi r1,18
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
80047c0: 44 43 00 05 be r2,r3,80047d4 <rtems_termios_baud_to_index+0xe8>
80047c4: 34 03 10 04 mvi r3,4100
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
80047c8: 34 01 00 13 mvi r1,19
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
80047cc: 44 43 00 02 be r2,r3,80047d4 <rtems_termios_baud_to_index+0xe8><== ALWAYS TAKEN
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
80047d0: 34 01 ff ff mvi r1,-1
}
return baud_index;
}
80047d4: c3 a0 00 00 ret
08003750 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
8003750: 37 9c ff ec addi sp,sp,-20
8003754: 5b 8b 00 14 sw (sp+20),r11
8003758: 5b 8c 00 10 sw (sp+16),r12
800375c: 5b 8d 00 0c sw (sp+12),r13
8003760: 5b 8e 00 08 sw (sp+8),r14
8003764: 5b 9d 00 04 sw (sp+4),ra
8003768: b8 20 70 00 mv r14,r1
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
800376c: 28 21 00 00 lw r1,(r1+0)
rtems_status_code sc;
sc = rtems_semaphore_obtain(
8003770: 78 02 08 02 mvhi r2,0x802
8003774: 38 42 5d a8 ori r2,r2,0x5da8
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
8003778: 28 2b 00 38 lw r11,(r1+56)
rtems_status_code sc;
sc = rtems_semaphore_obtain(
800377c: 28 41 00 00 lw r1,(r2+0)
8003780: 34 03 00 00 mvi r3,0
8003784: 34 02 00 00 mvi r2,0
8003788: f8 00 08 af calli 8005a44 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
800378c: 5c 20 00 25 bne r1,r0,8003820 <rtems_termios_close+0xd0> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
8003790: 29 6d 00 08 lw r13,(r11+8)
8003794: 35 ad ff ff addi r13,r13,-1
8003798: 59 6d 00 08 sw (r11+8),r13
800379c: 5d a1 00 51 bne r13,r1,80038e0 <rtems_termios_close+0x190> <== NEVER TAKEN
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
80037a0: 29 61 00 cc lw r1,(r11+204)
80037a4: 78 0c 08 02 mvhi r12,0x802
80037a8: 34 02 00 05 mvi r2,5
80037ac: 39 8c 57 a4 ori r12,r12,0x57a4
80037b0: fb ff f4 78 calli 8000990 <__ashlsi3>
80037b4: b5 81 08 00 add r1,r12,r1
80037b8: 28 2c 00 04 lw r12,(r1+4)
80037bc: 45 8d 00 04 be r12,r13,80037cc <rtems_termios_close+0x7c>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
80037c0: b9 60 08 00 mv r1,r11
80037c4: d9 80 00 00 call r12
80037c8: e0 00 00 0a bi 80037f0 <rtems_termios_close+0xa0>
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
80037cc: 29 61 00 18 lw r1,(r11+24)
80037d0: 34 02 00 00 mvi r2,0
80037d4: 34 03 00 00 mvi r3,0
80037d8: f8 00 08 9b calli 8005a44 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
80037dc: 5d 81 00 11 bne r12,r1,8003820 <rtems_termios_close+0xd0> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
80037e0: b9 60 08 00 mv r1,r11
80037e4: fb ff fe 89 calli 8003208 <drainOutput>
rtems_semaphore_release (tty->osem);
80037e8: 29 61 00 18 lw r1,(r11+24)
80037ec: f8 00 08 e6 calli 8005b84 <rtems_semaphore_release>
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
80037f0: 29 62 00 b4 lw r2,(r11+180)
80037f4: 34 01 00 02 mvi r1,2
80037f8: 5c 41 00 0b bne r2,r1,8003824 <rtems_termios_close+0xd4>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
80037fc: 29 61 00 c4 lw r1,(r11+196)
8003800: 34 02 00 01 mvi r2,1
8003804: f8 00 07 44 calli 8005514 <rtems_event_send>
8003808: b8 20 60 00 mv r12,r1
if (sc != RTEMS_SUCCESSFUL)
800380c: 5c 20 00 05 bne r1,r0,8003820 <rtems_termios_close+0xd0> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
8003810: 29 61 00 c8 lw r1,(r11+200)
8003814: 34 02 00 01 mvi r2,1
8003818: f8 00 07 3f calli 8005514 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
800381c: 44 2c 00 02 be r1,r12,8003824 <rtems_termios_close+0xd4> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
8003820: f8 00 0a cb calli 800634c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
if (tty->device.lastClose)
8003824: 29 64 00 9c lw r4,(r11+156)
8003828: 44 80 00 05 be r4,r0,800383c <rtems_termios_close+0xec> <== ALWAYS TAKEN
(*tty->device.lastClose)(tty->major, tty->minor, arg);
800382c: 29 61 00 0c lw r1,(r11+12) <== NOT EXECUTED
8003830: 29 62 00 10 lw r2,(r11+16) <== NOT EXECUTED
8003834: b9 c0 18 00 mv r3,r14 <== NOT EXECUTED
8003838: d8 80 00 00 call r4 <== NOT EXECUTED
if (tty->forw == NULL) {
800383c: 29 62 00 00 lw r2,(r11+0)
8003840: 29 61 00 04 lw r1,(r11+4)
8003844: 5c 40 00 07 bne r2,r0,8003860 <rtems_termios_close+0x110> <== NEVER TAKEN
rtems_termios_ttyTail = tty->back;
8003848: 78 03 08 02 mvhi r3,0x802
800384c: 38 63 5d ac ori r3,r3,0x5dac
8003850: 58 61 00 00 sw (r3+0),r1
if ( rtems_termios_ttyTail != NULL ) {
8003854: 44 22 00 04 be r1,r2,8003864 <rtems_termios_close+0x114> <== ALWAYS TAKEN
rtems_termios_ttyTail->forw = NULL;
8003858: 58 20 00 00 sw (r1+0),r0 <== NOT EXECUTED
800385c: e0 00 00 02 bi 8003864 <rtems_termios_close+0x114> <== NOT EXECUTED
}
} else {
tty->forw->back = tty->back;
8003860: 58 41 00 04 sw (r2+4),r1 <== NOT EXECUTED
}
if (tty->back == NULL) {
8003864: 29 62 00 04 lw r2,(r11+4)
8003868: 29 61 00 00 lw r1,(r11+0)
800386c: 5c 40 00 07 bne r2,r0,8003888 <rtems_termios_close+0x138> <== NEVER TAKEN
rtems_termios_ttyHead = tty->forw;
8003870: 78 03 08 02 mvhi r3,0x802
8003874: 38 63 5d b0 ori r3,r3,0x5db0
8003878: 58 61 00 00 sw (r3+0),r1
if ( rtems_termios_ttyHead != NULL ) {
800387c: 44 22 00 04 be r1,r2,800388c <rtems_termios_close+0x13c> <== ALWAYS TAKEN
rtems_termios_ttyHead->back = NULL;
8003880: 58 20 00 04 sw (r1+4),r0 <== NOT EXECUTED
8003884: e0 00 00 02 bi 800388c <rtems_termios_close+0x13c> <== NOT EXECUTED
}
} else {
tty->back->forw = tty->forw;
8003888: 58 41 00 00 sw (r2+0),r1 <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
800388c: 29 61 00 14 lw r1,(r11+20)
8003890: f8 00 08 3e calli 8005988 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
8003894: 29 61 00 18 lw r1,(r11+24)
8003898: f8 00 08 3c calli 8005988 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
800389c: 29 61 00 8c lw r1,(r11+140)
80038a0: f8 00 08 3a calli 8005988 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
80038a4: 29 61 00 a0 lw r1,(r11+160)
80038a8: 44 20 00 04 be r1,r0,80038b8 <rtems_termios_close+0x168>
80038ac: 29 62 00 b4 lw r2,(r11+180)
80038b0: 34 01 00 02 mvi r1,2
80038b4: 5c 41 00 03 bne r2,r1,80038c0 <rtems_termios_close+0x170>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
80038b8: 29 61 00 68 lw r1,(r11+104)
80038bc: f8 00 08 33 calli 8005988 <rtems_semaphore_delete>
free (tty->rawInBuf.theBuf);
80038c0: 29 61 00 58 lw r1,(r11+88)
80038c4: fb ff f9 50 calli 8001e04 <free>
free (tty->rawOutBuf.theBuf);
80038c8: 29 61 00 7c lw r1,(r11+124)
80038cc: fb ff f9 4e calli 8001e04 <free>
free (tty->cbuf);
80038d0: 29 61 00 1c lw r1,(r11+28)
80038d4: fb ff f9 4c calli 8001e04 <free>
free (tty);
80038d8: b9 60 08 00 mv r1,r11
80038dc: fb ff f9 4a calli 8001e04 <free>
}
rtems_semaphore_release (rtems_termios_ttyMutex);
80038e0: 78 01 08 02 mvhi r1,0x802
80038e4: 38 21 5d a8 ori r1,r1,0x5da8
80038e8: 28 21 00 00 lw r1,(r1+0)
80038ec: f8 00 08 a6 calli 8005b84 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
80038f0: 34 01 00 00 mvi r1,0
80038f4: 2b 9d 00 04 lw ra,(sp+4)
80038f8: 2b 8b 00 14 lw r11,(sp+20)
80038fc: 2b 8c 00 10 lw r12,(sp+16)
8003900: 2b 8d 00 0c lw r13,(sp+12)
8003904: 2b 8e 00 08 lw r14,(sp+8)
8003908: 37 9c 00 14 addi sp,sp,20
800390c: c3 a0 00 00 ret
08004f14 <rtems_termios_dequeue_characters>:
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
8004f14: 37 9c ff f8 addi sp,sp,-8
8004f18: 5b 8b 00 08 sw (sp+8),r11
8004f1c: 5b 9d 00 04 sw (sp+4),ra
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
8004f20: 28 24 00 90 lw r4,(r1+144)
8004f24: b4 82 10 00 add r2,r4,r2
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
8004f28: 28 24 00 b4 lw r4,(r1+180)
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
8004f2c: 58 22 00 90 sw (r1+144),r2
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
8004f30: 34 02 00 02 mvi r2,2
8004f34: 5c 82 00 06 bne r4,r2,8004f4c <rtems_termios_dequeue_characters+0x38>
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
8004f38: 28 21 00 c8 lw r1,(r1+200)
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
8004f3c: 34 0b 00 00 mvi r11,0
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
8004f40: f8 00 01 75 calli 8005514 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
8004f44: 44 20 00 0e be r1,r0,8004f7c <rtems_termios_dequeue_characters+0x68><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
8004f48: f8 00 05 01 calli 800634c <rtems_fatal_error_occurred> <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
8004f4c: 28 23 00 cc lw r3,(r1+204)
8004f50: 34 02 00 05 mvi r2,5
8004f54: 5c 62 00 08 bne r3,r2,8004f74 <rtems_termios_dequeue_characters+0x60>
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
8004f58: 78 02 08 02 mvhi r2,0x802
8004f5c: 38 42 57 a4 ori r2,r2,0x57a4
8004f60: 28 42 00 b4 lw r2,(r2+180)
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
8004f64: 34 0b 00 00 mvi r11,0
if (tty->t_line == PPPDISC ) {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
8004f68: 44 40 00 05 be r2,r0,8004f7c <rtems_termios_dequeue_characters+0x68><== NEVER TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
8004f6c: d8 40 00 00 call r2
8004f70: e0 00 00 03 bi 8004f7c <rtems_termios_dequeue_characters+0x68>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
8004f74: fb ff ff 4a calli 8004c9c <rtems_termios_refill_transmitter>
8004f78: b8 20 58 00 mv r11,r1
}
8004f7c: b9 60 08 00 mv r1,r11
8004f80: 2b 9d 00 04 lw ra,(sp+4)
8004f84: 2b 8b 00 08 lw r11,(sp+8)
8004f88: 37 9c 00 08 addi sp,sp,8
8004f8c: c3 a0 00 00 ret
080048fc <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)
{
80048fc: 37 9c ff bc addi sp,sp,-68
8004900: 5b 8b 00 44 sw (sp+68),r11
8004904: 5b 8c 00 40 sw (sp+64),r12
8004908: 5b 8d 00 3c sw (sp+60),r13
800490c: 5b 8e 00 38 sw (sp+56),r14
8004910: 5b 8f 00 34 sw (sp+52),r15
8004914: 5b 90 00 30 sw (sp+48),r16
8004918: 5b 91 00 2c sw (sp+44),r17
800491c: 5b 92 00 28 sw (sp+40),r18
8004920: 5b 93 00 24 sw (sp+36),r19
8004924: 5b 94 00 20 sw (sp+32),r20
8004928: 5b 95 00 1c sw (sp+28),r21
800492c: 5b 96 00 18 sw (sp+24),r22
8004930: 5b 97 00 14 sw (sp+20),r23
8004934: 5b 98 00 10 sw (sp+16),r24
8004938: 5b 99 00 0c sw (sp+12),r25
800493c: 5b 9b 00 08 sw (sp+8),fp
8004940: 5b 9d 00 04 sw (sp+4),ra
8004944: b8 20 58 00 mv r11,r1
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) {
8004948: 28 21 00 cc lw r1,(r1+204)
* 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)
{
800494c: b8 40 68 00 mv r13,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) {
8004950: 78 0c 08 02 mvhi r12,0x802
8004954: 34 02 00 05 mvi r2,5
* 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)
{
8004958: b8 60 78 00 mv r15,r3
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) {
800495c: 39 8c 57 a4 ori r12,r12,0x57a4
8004960: fb ff f0 0c calli 8000990 <__ashlsi3>
8004964: b5 81 08 00 add r1,r12,r1
8004968: 28 21 00 10 lw r1,(r1+16)
800496c: b9 e0 70 00 mv r14,r15
8004970: 5c 20 00 17 bne r1,r0,80049cc <rtems_termios_enqueue_raw_characters+0xd0>
8004974: 34 12 00 00 mvi r18,0
8004978: 34 0c 00 00 mvi r12,0
flow_rcv = true;
}
}
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
800497c: 34 1b 00 20 mvi fp,32
/* disable interrupts */
rtems_interrupt_disable(level);
8004980: 34 11 ff fe mvi r17,-2
tty->flow_ctrl &= ~FL_OSTOP;
8004984: 34 19 ff df mvi r25,-33
/*
* 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);
8004988: 35 78 00 30 addi r24,r11,48
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;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
800498c: 34 17 04 00 mvi r23,1024
/* 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) ) {
8004990: 34 16 01 00 mvi r22,256
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,
8004994: 35 75 00 4a addi r21,r11,74
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
8004998: 34 14 ff ef mvi r20,-17
800499c: e0 00 00 87 bi 8004bb8 <rtems_termios_enqueue_raw_characters+0x2bc>
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
80049a0: 29 61 00 cc lw r1,(r11+204)
80049a4: 34 02 00 05 mvi r2,5
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
80049a8: 41 af 00 00 lbu r15,(r13+0)
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
80049ac: fb ff ef f9 calli 8000990 <__ashlsi3>
80049b0: b5 81 10 00 add r2,r12,r1
80049b4: 28 43 00 10 lw r3,(r2+16)
80049b8: b9 e0 08 00 mv r1,r15
80049bc: b9 60 10 00 mv r2,r11
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
80049c0: 35 ad 00 01 addi r13,r13,1
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
80049c4: d8 60 00 00 call r3
80049c8: 35 ce ff ff addi r14,r14,-1
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--) {
80049cc: 5d c0 ff f5 bne r14,r0,80049a0 <rtems_termios_enqueue_raw_characters+0xa4>
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
80049d0: 29 61 00 e4 lw r1,(r11+228)
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
80049d4: 34 0c 00 00 mvi r12,0
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
80049d8: 5c 2c 00 7e bne r1,r12,8004bd0 <rtems_termios_enqueue_raw_characters+0x2d4><== NEVER TAKEN
80049dc: 29 63 00 dc lw r3,(r11+220)
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
80049e0: b9 c0 60 00 mv r12,r14
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
80049e4: 44 60 00 7b be r3,r0,8004bd0 <rtems_termios_enqueue_raw_characters+0x2d4>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
80049e8: 29 62 00 e0 lw r2,(r11+224)
80049ec: 35 61 00 30 addi r1,r11,48
80049f0: d8 60 00 00 call r3
tty->tty_rcvwakeup = 1;
80049f4: 34 01 00 01 mvi r1,1
80049f8: 59 61 00 e4 sw (r11+228),r1
80049fc: e0 00 00 75 bi 8004bd0 <rtems_termios_enqueue_raw_characters+0x2d4>
while (len--) {
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
8004a00: 29 61 00 b8 lw r1,(r11+184)
}
return 0;
}
while (len--) {
c = *buf++;
8004a04: 41 b0 00 00 lbu r16,(r13+0)
8004a08: 35 ad 00 01 addi r13,r13,1
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
8004a0c: 20 21 02 00 andi r1,r1,0x200
8004a10: 44 20 00 11 be r1,r0,8004a54 <rtems_termios_enqueue_raw_characters+0x158>
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
8004a14: 41 64 00 4a lbu r4,(r11+74)
8004a18: 41 63 00 49 lbu r3,(r11+73)
8004a1c: 5c 90 00 0a bne r4,r16,8004a44 <rtems_termios_enqueue_raw_characters+0x148>
if (c == tty->termios.c_cc[VSTART]) {
8004a20: 5c 64 00 04 bne r3,r4,8004a30 <rtems_termios_enqueue_raw_characters+0x134><== ALWAYS TAKEN
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
8004a24: 29 61 00 b8 lw r1,(r11+184) <== NOT EXECUTED
8004a28: 18 21 00 10 xori r1,r1,0x10 <== NOT EXECUTED
8004a2c: e0 00 00 03 bi 8004a38 <rtems_termios_enqueue_raw_characters+0x13c><== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
8004a30: 29 61 00 b8 lw r1,(r11+184)
8004a34: 38 21 00 10 ori r1,r1,0x10
8004a38: 59 61 00 b8 sw (r11+184),r1
* 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)
{
8004a3c: 34 12 00 01 mvi r18,1
8004a40: e0 00 00 06 bi 8004a58 <rtems_termios_enqueue_raw_characters+0x15c>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
8004a44: 5c 70 00 04 bne r3,r16,8004a54 <rtems_termios_enqueue_raw_characters+0x158><== ALWAYS TAKEN
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
8004a48: 29 61 00 b8 lw r1,(r11+184) <== NOT EXECUTED
8004a4c: a0 34 08 00 and r1,r1,r20 <== NOT EXECUTED
8004a50: e3 ff ff fa bi 8004a38 <rtems_termios_enqueue_raw_characters+0x13c><== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
8004a54: 46 40 00 15 be r18,r0,8004aa8 <rtems_termios_enqueue_raw_characters+0x1ac><== ALWAYS TAKEN
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
8004a58: 29 61 00 b8 lw r1,(r11+184)
8004a5c: 20 21 00 30 andi r1,r1,0x30
8004a60: 5c 3b 00 55 bne r1,fp,8004bb4 <rtems_termios_enqueue_raw_characters+0x2b8><== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
8004a64: 90 00 70 00 rcsr r14,IE <== NOT EXECUTED
8004a68: a1 d1 08 00 and r1,r14,r17 <== NOT EXECUTED
8004a6c: d0 01 00 00 wcsr IE,r1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
8004a70: 29 61 00 b8 lw r1,(r11+184) <== NOT EXECUTED
8004a74: a0 39 08 00 and r1,r1,r25 <== NOT EXECUTED
8004a78: 59 61 00 b8 sw (r11+184),r1 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
8004a7c: 29 61 00 94 lw r1,(r11+148) <== NOT EXECUTED
8004a80: 44 20 00 08 be r1,r0,8004aa0 <rtems_termios_enqueue_raw_characters+0x1a4><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
8004a84: 29 63 00 84 lw r3,(r11+132) <== 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)(
8004a88: 29 62 00 7c lw r2,(r11+124) <== NOT EXECUTED
8004a8c: 29 64 00 a4 lw r4,(r11+164) <== NOT EXECUTED
8004a90: 29 61 00 10 lw r1,(r11+16) <== NOT EXECUTED
8004a94: b4 43 10 00 add r2,r2,r3 <== NOT EXECUTED
8004a98: 34 03 00 01 mvi r3,1 <== NOT EXECUTED
8004a9c: d8 80 00 00 call r4 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
8004aa0: d0 0e 00 00 wcsr IE,r14 <== NOT EXECUTED
8004aa4: e0 00 00 44 bi 8004bb4 <rtems_termios_enqueue_raw_characters+0x2b8><== NOT EXECUTED
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
8004aa8: 29 63 00 60 lw r3,(r11+96)
8004aac: 29 62 00 64 lw r2,(r11+100)
8004ab0: 34 61 00 01 addi r1,r3,1
8004ab4: f8 00 76 69 calli 8022458 <__umodsi3>
8004ab8: b8 20 70 00 mv r14,r1
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
8004abc: 90 00 98 00 rcsr r19,IE
8004ac0: a2 71 08 00 and r1,r19,r17
8004ac4: d0 01 00 00 wcsr IE,r1
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
8004ac8: 29 61 00 5c lw r1,(r11+92)
8004acc: 29 63 00 64 lw r3,(r11+100)
% tty->rawInBuf.Size) > tty->highwater) &&
8004ad0: 29 62 00 64 lw r2,(r11+100)
}
} 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)
8004ad4: c8 61 18 00 sub r3,r3,r1
% tty->rawInBuf.Size) > tty->highwater) &&
8004ad8: b4 6e 08 00 add r1,r3,r14
8004adc: f8 00 76 5f calli 8022458 <__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)
8004ae0: 29 62 00 c0 lw r2,(r11+192)
8004ae4: 50 41 00 22 bgeu r2,r1,8004b6c <rtems_termios_enqueue_raw_characters+0x270><== ALWAYS TAKEN
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
8004ae8: 29 61 00 b8 lw r1,(r11+184) <== NOT EXECUTED
8004aec: 20 21 00 01 andi r1,r1,0x1 <== 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) &&
8004af0: 5c 20 00 1f bne r1,r0,8004b6c <rtems_termios_enqueue_raw_characters+0x270><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
8004af4: 29 61 00 b8 lw r1,(r11+184) <== NOT EXECUTED
8004af8: 38 21 00 01 ori r1,r1,0x1 <== NOT EXECUTED
8004afc: 59 61 00 b8 sw (r11+184),r1 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
8004b00: 29 61 00 b8 lw r1,(r11+184) <== NOT EXECUTED
8004b04: 20 21 04 02 andi r1,r1,0x402 <== NOT EXECUTED
8004b08: 5c 37 00 0f bne r1,r23,8004b44 <rtems_termios_enqueue_raw_characters+0x248><== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
8004b0c: 29 63 00 b8 lw r3,(r11+184) <== NOT EXECUTED
8004b10: 20 63 00 20 andi r3,r3,0x20 <== NOT EXECUTED
8004b14: 5c 60 00 03 bne r3,r0,8004b20 <rtems_termios_enqueue_raw_characters+0x224><== NOT EXECUTED
8004b18: 29 61 00 94 lw r1,(r11+148) <== NOT EXECUTED
8004b1c: 5c 23 00 14 bne r1,r3,8004b6c <rtems_termios_enqueue_raw_characters+0x270><== 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;
8004b20: 29 61 00 b8 lw r1,(r11+184) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
8004b24: 29 64 00 a4 lw r4,(r11+164) <== NOT EXECUTED
8004b28: ba a0 10 00 mv r2,r21 <== 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;
8004b2c: 38 21 00 02 ori r1,r1,0x2 <== NOT EXECUTED
8004b30: 59 61 00 b8 sw (r11+184),r1 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
8004b34: 29 61 00 10 lw r1,(r11+16) <== NOT EXECUTED
8004b38: 34 03 00 01 mvi r3,1 <== NOT EXECUTED
8004b3c: d8 80 00 00 call r4 <== NOT EXECUTED
8004b40: e0 00 00 0b bi 8004b6c <rtems_termios_enqueue_raw_characters+0x270><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
8004b44: 29 61 00 b8 lw r1,(r11+184) <== NOT EXECUTED
8004b48: 20 21 01 04 andi r1,r1,0x104 <== NOT EXECUTED
8004b4c: 5c 36 00 08 bne r1,r22,8004b6c <rtems_termios_enqueue_raw_characters+0x270><== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
8004b50: 29 61 00 b8 lw r1,(r11+184) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
8004b54: 29 63 00 ac lw r3,(r11+172) <== 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;
8004b58: 38 21 00 04 ori r1,r1,0x4 <== NOT EXECUTED
8004b5c: 59 61 00 b8 sw (r11+184),r1 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
8004b60: 44 60 00 03 be r3,r0,8004b6c <rtems_termios_enqueue_raw_characters+0x270><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
8004b64: 29 61 00 10 lw r1,(r11+16) <== NOT EXECUTED
8004b68: d8 60 00 00 call r3 <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
8004b6c: d0 13 00 00 wcsr IE,r19
if (newTail == tty->rawInBuf.Head) {
8004b70: 29 61 00 5c lw r1,(r11+92)
8004b74: 5d c1 00 03 bne r14,r1,8004b80 <rtems_termios_enqueue_raw_characters+0x284><== ALWAYS TAKEN
dropped++;
8004b78: 35 8c 00 01 addi r12,r12,1 <== NOT EXECUTED
8004b7c: e0 00 00 0e bi 8004bb4 <rtems_termios_enqueue_raw_characters+0x2b8><== NOT EXECUTED
} else {
tty->rawInBuf.theBuf[newTail] = c;
8004b80: 29 61 00 58 lw r1,(r11+88)
8004b84: b4 2e 08 00 add r1,r1,r14
8004b88: 30 30 00 00 sb (r1+0),r16
tty->rawInBuf.Tail = newTail;
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
8004b8c: 29 64 00 e4 lw r4,(r11+228)
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
8004b90: 59 6e 00 60 sw (r11+96),r14
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
8004b94: 5c 80 00 08 bne r4,r0,8004bb4 <rtems_termios_enqueue_raw_characters+0x2b8><== NEVER TAKEN
8004b98: 29 63 00 dc lw r3,(r11+220)
8004b9c: 44 64 00 06 be r3,r4,8004bb4 <rtems_termios_enqueue_raw_characters+0x2b8><== ALWAYS TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
8004ba0: 29 62 00 e0 lw r2,(r11+224) <== NOT EXECUTED
8004ba4: bb 00 08 00 mv r1,r24 <== NOT EXECUTED
8004ba8: d8 60 00 00 call r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
8004bac: 34 01 00 01 mvi r1,1 <== NOT EXECUTED
8004bb0: 59 61 00 e4 sw (r11+228),r1 <== NOT EXECUTED
8004bb4: 35 ef ff ff addi r15,r15,-1
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
8004bb8: 5d e0 ff 92 bne r15,r0,8004a00 <rtems_termios_enqueue_raw_characters+0x104>
}
}
}
}
tty->rawInBufDropped += dropped;
8004bbc: 29 61 00 78 lw r1,(r11+120)
8004bc0: b4 2c 08 00 add r1,r1,r12
8004bc4: 59 61 00 78 sw (r11+120),r1
rtems_semaphore_release (tty->rawInBuf.Semaphore);
8004bc8: 29 61 00 68 lw r1,(r11+104)
8004bcc: f8 00 03 ee calli 8005b84 <rtems_semaphore_release>
return dropped;
}
8004bd0: b9 80 08 00 mv r1,r12
8004bd4: 2b 9d 00 04 lw ra,(sp+4)
8004bd8: 2b 8b 00 44 lw r11,(sp+68)
8004bdc: 2b 8c 00 40 lw r12,(sp+64)
8004be0: 2b 8d 00 3c lw r13,(sp+60)
8004be4: 2b 8e 00 38 lw r14,(sp+56)
8004be8: 2b 8f 00 34 lw r15,(sp+52)
8004bec: 2b 90 00 30 lw r16,(sp+48)
8004bf0: 2b 91 00 2c lw r17,(sp+44)
8004bf4: 2b 92 00 28 lw r18,(sp+40)
8004bf8: 2b 93 00 24 lw r19,(sp+36)
8004bfc: 2b 94 00 20 lw r20,(sp+32)
8004c00: 2b 95 00 1c lw r21,(sp+28)
8004c04: 2b 96 00 18 lw r22,(sp+24)
8004c08: 2b 97 00 14 lw r23,(sp+20)
8004c0c: 2b 98 00 10 lw r24,(sp+16)
8004c10: 2b 99 00 0c lw r25,(sp+12)
8004c14: 2b 9b 00 08 lw fp,(sp+8)
8004c18: 37 9c 00 44 addi sp,sp,68
8004c1c: c3 a0 00 00 ret
080031b8 <rtems_termios_initialize>:
struct rtems_termios_tty *rtems_termios_ttyTail;
rtems_id rtems_termios_ttyMutex;
void
rtems_termios_initialize (void)
{
80031b8: 37 9c ff f8 addi sp,sp,-8
80031bc: 5b 8b 00 08 sw (sp+8),r11
80031c0: 5b 9d 00 04 sw (sp+4),ra
rtems_status_code sc;
/*
* Create the mutex semaphore for the tty list
*/
if (!rtems_termios_ttyMutex) {
80031c4: 78 05 08 02 mvhi r5,0x802
80031c8: 38 a5 5d a8 ori r5,r5,0x5da8
80031cc: 28 ab 00 00 lw r11,(r5+0)
80031d0: 5d 60 00 0a bne r11,r0,80031f8 <rtems_termios_initialize+0x40><== NEVER TAKEN
sc = rtems_semaphore_create (
80031d4: 78 02 08 02 mvhi r2,0x802
80031d8: 38 42 38 c8 ori r2,r2,0x38c8
80031dc: 28 41 00 00 lw r1,(r2+0)
80031e0: 34 03 00 54 mvi r3,84
80031e4: 34 02 00 01 mvi r2,1
80031e8: 34 04 00 00 mvi r4,0
80031ec: f8 00 09 6a calli 8005794 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'm', 'i'),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_termios_ttyMutex);
if (sc != RTEMS_SUCCESSFUL)
80031f0: 44 2b 00 02 be r1,r11,80031f8 <rtems_termios_initialize+0x40><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
80031f4: f8 00 0c 56 calli 800634c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
}
80031f8: 2b 9d 00 04 lw ra,(sp+4)
80031fc: 2b 8b 00 08 lw r11,(sp+8)
8003200: 37 9c 00 08 addi sp,sp,8
8003204: c3 a0 00 00 ret
0800393c <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
800393c: 37 9c ff e8 addi sp,sp,-24
8003940: 5b 8b 00 18 sw (sp+24),r11
8003944: 5b 8c 00 14 sw (sp+20),r12
8003948: 5b 8d 00 10 sw (sp+16),r13
800394c: 5b 8e 00 0c sw (sp+12),r14
8003950: 5b 8f 00 08 sw (sp+8),r15
8003954: 5b 9d 00 04 sw (sp+4),ra
8003958: b8 20 60 00 mv r12,r1
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
800395c: 28 21 00 00 lw r1,(r1+0)
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
8003960: 34 02 00 00 mvi r2,0
8003964: 34 03 00 00 mvi r3,0
rtems_status_code
rtems_termios_ioctl (void *arg)
{
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
8003968: 28 2b 00 38 lw r11,(r1+56)
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
800396c: 59 80 00 0c sw (r12+12),r0
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;
8003970: 29 8e 00 08 lw r14,(r12+8)
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
8003974: 29 61 00 18 lw r1,(r11+24)
8003978: f8 00 08 33 calli 8005a44 <rtems_semaphore_obtain>
800397c: b8 20 68 00 mv r13,r1
if (sc != RTEMS_SUCCESSFUL) {
8003980: 5c 20 00 da bne r1,r0,8003ce8 <rtems_termios_ioctl+0x3ac> <== NEVER TAKEN
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
8003984: 29 82 00 04 lw r2,(r12+4)
8003988: 34 01 00 04 mvi r1,4
800398c: 44 41 00 a6 be r2,r1,8003c24 <rtems_termios_ioctl+0x2e8>
8003990: 54 41 00 07 bgu r2,r1,80039ac <rtems_termios_ioctl+0x70>
8003994: 34 01 00 02 mvi r1,2
8003998: 44 41 00 27 be r2,r1,8003a34 <rtems_termios_ioctl+0xf8>
800399c: 54 41 00 9a bgu r2,r1,8003c04 <rtems_termios_ioctl+0x2c8>
80039a0: 34 01 00 01 mvi r1,1
80039a4: 5c 41 00 12 bne r2,r1,80039ec <rtems_termios_ioctl+0xb0> <== NEVER TAKEN
80039a8: e0 00 00 1e bi 8003a20 <rtems_termios_ioctl+0xe4>
80039ac: 78 03 08 02 mvhi r3,0x802
80039b0: 38 63 38 e4 ori r3,r3,0x38e4
80039b4: 28 61 00 00 lw r1,(r3+0)
80039b8: 44 41 00 be be r2,r1,8003cb0 <rtems_termios_ioctl+0x374> <== NEVER TAKEN
80039bc: 54 41 00 04 bgu r2,r1,80039cc <rtems_termios_ioctl+0x90>
80039c0: 34 01 00 05 mvi r1,5
80039c4: 5c 41 00 0a bne r2,r1,80039ec <rtems_termios_ioctl+0xb0>
80039c8: e0 00 00 92 bi 8003c10 <rtems_termios_ioctl+0x2d4>
80039cc: 78 03 08 02 mvhi r3,0x802
80039d0: 38 63 38 e8 ori r3,r3,0x38e8
80039d4: 28 61 00 00 lw r1,(r3+0)
80039d8: 44 41 00 b2 be r2,r1,8003ca0 <rtems_termios_ioctl+0x364>
80039dc: 78 03 08 02 mvhi r3,0x802
80039e0: 38 63 38 ec ori r3,r3,0x38ec
80039e4: 28 61 00 00 lw r1,(r3+0)
80039e8: 44 41 00 94 be r2,r1,8003c38 <rtems_termios_ioctl+0x2fc> <== ALWAYS TAKEN
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
80039ec: 29 61 00 cc lw r1,(r11+204)
80039f0: 78 0d 08 02 mvhi r13,0x802
80039f4: 34 02 00 05 mvi r2,5
80039f8: 39 ad 57 a4 ori r13,r13,0x57a4
80039fc: fb ff f3 e5 calli 8000990 <__ashlsi3>
8003a00: b5 a1 08 00 add r1,r13,r1
8003a04: 28 23 00 18 lw r3,(r1+24)
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
8003a08: 34 0d 00 0a mvi r13,10
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
8003a0c: 44 60 00 b5 be r3,r0,8003ce0 <rtems_termios_ioctl+0x3a4> <== NEVER TAKEN
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
8003a10: b9 60 08 00 mv r1,r11
8003a14: b9 80 10 00 mv r2,r12
8003a18: d8 60 00 00 call r3
8003a1c: e0 00 00 9f bi 8003c98 <rtems_termios_ioctl+0x35c>
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
8003a20: 29 81 00 08 lw r1,(r12+8)
8003a24: 35 62 00 30 addi r2,r11,48
8003a28: 34 03 00 24 mvi r3,36
8003a2c: f8 00 37 4f calli 8011768 <memcpy>
break;
8003a30: e0 00 00 ac bi 8003ce0 <rtems_termios_ioctl+0x3a4>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
8003a34: 29 82 00 08 lw r2,(r12+8)
8003a38: 35 61 00 30 addi r1,r11,48
8003a3c: 34 03 00 24 mvi r3,36
8003a40: f8 00 37 4a calli 8011768 <memcpy>
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
8003a44: 29 61 00 b8 lw r1,(r11+184)
8003a48: 20 21 02 00 andi r1,r1,0x200
8003a4c: 44 20 00 1d be r1,r0,8003ac0 <rtems_termios_ioctl+0x184>
!(tty->termios.c_iflag & IXON)) {
8003a50: 29 61 00 30 lw r1,(r11+48)
8003a54: 20 21 04 00 andi r1,r1,0x400
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
8003a58: 5c 20 00 1a bne r1,r0,8003ac0 <rtems_termios_ioctl+0x184>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
8003a5c: 29 62 00 b8 lw r2,(r11+184)
8003a60: 34 01 fd ef mvi r1,-529
8003a64: a0 41 08 00 and r1,r2,r1
8003a68: 59 61 00 b8 sw (r11+184),r1
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
8003a6c: 29 61 00 b8 lw r1,(r11+184)
8003a70: 20 21 00 20 andi r1,r1,0x20
8003a74: 44 20 00 13 be r1,r0,8003ac0 <rtems_termios_ioctl+0x184> <== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
8003a78: 90 00 70 00 rcsr r14,IE <== NOT EXECUTED
8003a7c: 34 01 ff fe mvi r1,-2 <== NOT EXECUTED
8003a80: a1 c1 08 00 and r1,r14,r1 <== NOT EXECUTED
8003a84: d0 01 00 00 wcsr IE,r1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
8003a88: 29 62 00 b8 lw r2,(r11+184) <== NOT EXECUTED
8003a8c: 34 01 ff df mvi r1,-33 <== NOT EXECUTED
8003a90: a0 41 08 00 and r1,r2,r1 <== NOT EXECUTED
8003a94: 59 61 00 b8 sw (r11+184),r1 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
8003a98: 29 61 00 94 lw r1,(r11+148) <== NOT EXECUTED
8003a9c: 44 20 00 08 be r1,r0,8003abc <rtems_termios_ioctl+0x180> <== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
8003aa0: 29 63 00 7c lw r3,(r11+124) <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
8003aa4: 29 62 00 84 lw r2,(r11+132) <== 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)(
8003aa8: 29 64 00 a4 lw r4,(r11+164) <== NOT EXECUTED
8003aac: 29 61 00 10 lw r1,(r11+16) <== NOT EXECUTED
8003ab0: b4 62 10 00 add r2,r3,r2 <== NOT EXECUTED
8003ab4: 34 03 00 01 mvi r3,1 <== NOT EXECUTED
8003ab8: d8 80 00 00 call r4 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
8003abc: d0 0e 00 00 wcsr IE,r14 <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
8003ac0: 29 61 00 b8 lw r1,(r11+184)
8003ac4: 20 21 04 00 andi r1,r1,0x400
8003ac8: 44 20 00 0c be r1,r0,8003af8 <rtems_termios_ioctl+0x1bc>
8003acc: 29 61 00 30 lw r1,(r11+48)
8003ad0: 20 21 10 00 andi r1,r1,0x1000
8003ad4: 5c 20 00 09 bne r1,r0,8003af8 <rtems_termios_ioctl+0x1bc> <== NEVER TAKEN
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
8003ad8: 29 62 00 b8 lw r2,(r11+184)
8003adc: 34 01 fb ff mvi r1,-1025
8003ae0: a0 41 08 00 and r1,r2,r1
8003ae4: 59 61 00 b8 sw (r11+184),r1
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
8003ae8: 29 62 00 b8 lw r2,(r11+184)
8003aec: 34 01 ff fd mvi r1,-3
8003af0: a0 41 08 00 and r1,r2,r1
8003af4: 59 61 00 b8 sw (r11+184),r1
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
8003af8: 29 61 00 b8 lw r1,(r11+184)
8003afc: 20 21 01 00 andi r1,r1,0x100
8003b00: 44 20 00 12 be r1,r0,8003b48 <rtems_termios_ioctl+0x20c> <== ALWAYS TAKEN
8003b04: 29 61 00 38 lw r1,(r11+56) <== NOT EXECUTED
8003b08: 48 01 00 10 bg r0,r1,8003b48 <rtems_termios_ioctl+0x20c> <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
8003b0c: 29 62 00 b8 lw r2,(r11+184) <== NOT EXECUTED
8003b10: 34 01 fe ff mvi r1,-257 <== NOT EXECUTED
8003b14: a0 41 08 00 and r1,r2,r1 <== NOT EXECUTED
8003b18: 59 61 00 b8 sw (r11+184),r1 <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
8003b1c: 29 61 00 b8 lw r1,(r11+184) <== NOT EXECUTED
8003b20: 20 21 00 04 andi r1,r1,0x4 <== NOT EXECUTED
8003b24: 44 20 00 05 be r1,r0,8003b38 <rtems_termios_ioctl+0x1fc> <== NOT EXECUTED
8003b28: 29 62 00 b0 lw r2,(r11+176) <== NOT EXECUTED
8003b2c: 44 40 00 03 be r2,r0,8003b38 <rtems_termios_ioctl+0x1fc> <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
8003b30: 29 61 00 10 lw r1,(r11+16) <== NOT EXECUTED
8003b34: d8 40 00 00 call r2 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
8003b38: 29 62 00 b8 lw r2,(r11+184) <== NOT EXECUTED
8003b3c: 34 01 ff fb mvi r1,-5 <== NOT EXECUTED
8003b40: a0 41 08 00 and r1,r2,r1 <== NOT EXECUTED
8003b44: 59 61 00 b8 sw (r11+184),r1 <== 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) {
8003b48: 29 61 00 38 lw r1,(r11+56)
8003b4c: 4c 20 00 04 bge r1,r0,8003b5c <rtems_termios_ioctl+0x220> <== ALWAYS TAKEN
tty->flow_ctrl |= FL_MDRTS;
8003b50: 29 61 00 b8 lw r1,(r11+184) <== NOT EXECUTED
8003b54: 38 21 01 00 ori r1,r1,0x100 <== NOT EXECUTED
8003b58: 59 61 00 b8 sw (r11+184),r1 <== NOT EXECUTED
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
8003b5c: 29 61 00 30 lw r1,(r11+48)
8003b60: 20 22 10 00 andi r2,r1,0x1000
8003b64: 44 40 00 04 be r2,r0,8003b74 <rtems_termios_ioctl+0x238>
tty->flow_ctrl |= FL_MDXOF;
8003b68: 29 62 00 b8 lw r2,(r11+184)
8003b6c: 38 42 04 00 ori r2,r2,0x400
8003b70: 59 62 00 b8 sw (r11+184),r2
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
8003b74: 20 21 04 00 andi r1,r1,0x400
8003b78: 44 20 00 04 be r1,r0,8003b88 <rtems_termios_ioctl+0x24c>
tty->flow_ctrl |= FL_MDXON;
8003b7c: 29 61 00 b8 lw r1,(r11+184)
8003b80: 38 21 02 00 ori r1,r1,0x200
8003b84: 59 61 00 b8 sw (r11+184),r1
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) {
8003b88: 29 6e 00 3c lw r14,(r11+60)
8003b8c: 21 ce 00 02 andi r14,r14,0x2
8003b90: 5d c0 00 11 bne r14,r0,8003bd4 <rtems_termios_ioctl+0x298>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
8003b94: 41 6f 00 46 lbu r15,(r11+70)
rtems_clock_get_ticks_per_second() / 10;
8003b98: f8 00 05 d6 calli 80052f0 <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] *
8003b9c: b9 e0 10 00 mv r2,r15
8003ba0: f8 00 79 b9 calli 8022284 <__mulsi3>
rtems_clock_get_ticks_per_second() / 10;
8003ba4: 34 02 00 0a mvi r2,10
8003ba8: f8 00 7a 1c calli 8022418 <__udivsi3>
if (tty->termios.c_cc[VTIME]) {
8003bac: 41 62 00 46 lbu r2,(r11+70)
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] *
8003bb0: 59 61 00 54 sw (r11+84),r1
8003bb4: 41 63 00 47 lbu r3,(r11+71)
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
8003bb8: 44 4e 00 06 be r2,r14,8003bd0 <rtems_termios_ioctl+0x294>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
8003bbc: 59 60 00 6c sw (r11+108),r0
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
8003bc0: 59 61 00 70 sw (r11+112),r1
if (tty->termios.c_cc[VMIN])
8003bc4: 5c 60 00 06 bne r3,r0,8003bdc <rtems_termios_ioctl+0x2a0>
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
8003bc8: 59 61 00 74 sw (r11+116),r1
8003bcc: e0 00 00 08 bi 8003bec <rtems_termios_ioctl+0x2b0>
} else {
if (tty->termios.c_cc[VMIN]) {
8003bd0: 44 62 00 05 be r3,r2,8003be4 <rtems_termios_ioctl+0x2a8> <== ALWAYS TAKEN
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
8003bd4: 59 60 00 6c sw (r11+108),r0
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
8003bd8: 59 60 00 70 sw (r11+112),r0
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
8003bdc: 59 60 00 74 sw (r11+116),r0
8003be0: e0 00 00 03 bi 8003bec <rtems_termios_ioctl+0x2b0>
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
8003be4: 34 01 00 01 mvi r1,1
8003be8: 59 61 00 6c sw (r11+108),r1
}
}
}
if (tty->device.setAttributes)
8003bec: 29 63 00 a8 lw r3,(r11+168)
8003bf0: 44 60 00 3c be r3,r0,8003ce0 <rtems_termios_ioctl+0x3a4> <== NEVER TAKEN
(*tty->device.setAttributes)(tty->minor, &tty->termios);
8003bf4: 29 61 00 10 lw r1,(r11+16)
8003bf8: 35 62 00 30 addi r2,r11,48
8003bfc: d8 60 00 00 call r3
8003c00: e0 00 00 38 bi 8003ce0 <rtems_termios_ioctl+0x3a4>
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
8003c04: b9 60 08 00 mv r1,r11
8003c08: fb ff fd 80 calli 8003208 <drainOutput>
break;
8003c0c: e0 00 00 35 bi 8003ce0 <rtems_termios_ioctl+0x3a4>
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
8003c10: 29 c1 00 00 lw r1,(r14+0)
8003c14: 59 61 00 d4 sw (r11+212),r1
8003c18: 29 c1 00 04 lw r1,(r14+4)
8003c1c: 59 61 00 d8 sw (r11+216),r1
break;
8003c20: e0 00 00 30 bi 8003ce0 <rtems_termios_ioctl+0x3a4>
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
8003c24: 29 c1 00 00 lw r1,(r14+0)
8003c28: 59 61 00 dc sw (r11+220),r1
8003c2c: 29 c1 00 04 lw r1,(r14+4)
8003c30: 59 61 00 e0 sw (r11+224),r1
break;
8003c34: e0 00 00 2b bi 8003ce0 <rtems_termios_ioctl+0x3a4>
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
8003c38: 29 61 00 cc lw r1,(r11+204)
8003c3c: 34 02 00 05 mvi r2,5
8003c40: 78 0e 08 02 mvhi r14,0x802
8003c44: fb ff f3 53 calli 8000990 <__ashlsi3>
8003c48: 39 ce 57 a4 ori r14,r14,0x57a4
8003c4c: b5 c1 08 00 add r1,r14,r1
8003c50: 28 22 00 04 lw r2,(r1+4)
8003c54: 44 40 00 04 be r2,r0,8003c64 <rtems_termios_ioctl+0x328>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
8003c58: b9 60 08 00 mv r1,r11
8003c5c: d8 40 00 00 call r2
8003c60: b8 20 68 00 mv r13,r1
}
tty->t_line=*(int*)(args->buffer);
8003c64: 29 81 00 08 lw r1,(r12+8)
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
8003c68: 34 02 00 05 mvi r2,5
8003c6c: 78 0e 08 02 mvhi r14,0x802
* 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);
8003c70: 28 21 00 00 lw r1,(r1+0)
tty->t_sc = NULL; /* ensure that no more valid data */
8003c74: 59 60 00 d0 sw (r11+208),r0
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
8003c78: 39 ce 57 a4 ori r14,r14,0x57a4
* 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);
8003c7c: 59 61 00 cc sw (r11+204),r1
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
8003c80: fb ff f3 44 calli 8000990 <__ashlsi3>
8003c84: b5 c1 08 00 add r1,r14,r1
8003c88: 28 22 00 00 lw r2,(r1+0)
8003c8c: 44 40 00 15 be r2,r0,8003ce0 <rtems_termios_ioctl+0x3a4>
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
8003c90: b9 60 08 00 mv r1,r11
8003c94: d8 40 00 00 call r2
8003c98: b8 20 68 00 mv r13,r1
8003c9c: e0 00 00 11 bi 8003ce0 <rtems_termios_ioctl+0x3a4>
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
8003ca0: 29 81 00 08 lw r1,(r12+8)
8003ca4: 29 62 00 cc lw r2,(r11+204)
8003ca8: 58 22 00 00 sw (r1+0),r2
break;
8003cac: e0 00 00 0d bi 8003ce0 <rtems_termios_ioctl+0x3a4>
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
8003cb0: 29 62 00 60 lw r2,(r11+96) <== NOT EXECUTED
8003cb4: 29 61 00 5c lw r1,(r11+92) <== NOT EXECUTED
8003cb8: c8 41 08 00 sub r1,r2,r1 <== NOT EXECUTED
if ( rawnc < 0 )
8003cbc: 4c 20 00 03 bge r1,r0,8003cc8 <rtems_termios_ioctl+0x38c> <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
8003cc0: 29 62 00 64 lw r2,(r11+100) <== NOT EXECUTED
8003cc4: b4 22 08 00 add r1,r1,r2 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
8003cc8: 29 64 00 20 lw r4,(r11+32) <== NOT EXECUTED
8003ccc: 29 62 00 24 lw r2,(r11+36) <== NOT EXECUTED
8003cd0: 29 83 00 08 lw r3,(r12+8) <== NOT EXECUTED
8003cd4: c8 82 10 00 sub r2,r4,r2 <== NOT EXECUTED
8003cd8: b4 41 08 00 add r1,r2,r1 <== NOT EXECUTED
8003cdc: 58 61 00 00 sw (r3+0),r1 <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
8003ce0: 29 61 00 18 lw r1,(r11+24)
8003ce4: f8 00 07 a8 calli 8005b84 <rtems_semaphore_release>
args->ioctl_return = sc;
return sc;
}
8003ce8: b9 a0 08 00 mv r1,r13
}
break;
}
rtems_semaphore_release (tty->osem);
args->ioctl_return = sc;
8003cec: 59 8d 00 0c sw (r12+12),r13
return sc;
}
8003cf0: 2b 9d 00 04 lw ra,(sp+4)
8003cf4: 2b 8b 00 18 lw r11,(sp+24)
8003cf8: 2b 8c 00 14 lw r12,(sp+20)
8003cfc: 2b 8d 00 10 lw r13,(sp+16)
8003d00: 2b 8e 00 0c lw r14,(sp+12)
8003d04: 2b 8f 00 08 lw r15,(sp+8)
8003d08: 37 9c 00 18 addi sp,sp,24
8003d0c: c3 a0 00 00 ret
08003298 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
8003298: 37 9c ff d4 addi sp,sp,-44
800329c: 5b 8b 00 2c sw (sp+44),r11
80032a0: 5b 8c 00 28 sw (sp+40),r12
80032a4: 5b 8d 00 24 sw (sp+36),r13
80032a8: 5b 8e 00 20 sw (sp+32),r14
80032ac: 5b 8f 00 1c sw (sp+28),r15
80032b0: 5b 90 00 18 sw (sp+24),r16
80032b4: 5b 91 00 14 sw (sp+20),r17
80032b8: 5b 92 00 10 sw (sp+16),r18
80032bc: 5b 93 00 0c sw (sp+12),r19
80032c0: 5b 94 00 08 sw (sp+8),r20
80032c4: 5b 9d 00 04 sw (sp+4),ra
80032c8: b8 20 88 00 mv r17,r1
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
80032cc: 78 01 08 02 mvhi r1,0x802
80032d0: 38 21 5d a8 ori r1,r1,0x5da8
80032d4: 28 21 00 00 lw r1,(r1+0)
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
80032d8: b8 40 90 00 mv r18,r2
80032dc: b8 60 a0 00 mv r20,r3
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
80032e0: 34 02 00 00 mvi r2,0
80032e4: 34 03 00 00 mvi r3,0
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
80032e8: b8 80 68 00 mv r13,r4
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
80032ec: f8 00 09 d6 calli 8005a44 <rtems_semaphore_obtain>
80032f0: b8 20 78 00 mv r15,r1
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
80032f4: 5c 20 01 02 bne r1,r0,80036fc <rtems_termios_open+0x464> <== NEVER TAKEN
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
80032f8: 78 01 08 02 mvhi r1,0x802
80032fc: 38 21 5d b0 ori r1,r1,0x5db0
8003300: 28 2e 00 00 lw r14,(r1+0)
8003304: b9 c0 60 00 mv r12,r14
8003308: e0 00 00 06 bi 8003320 <rtems_termios_open+0x88>
if ((tty->major == major) && (tty->minor == minor))
800330c: 29 81 00 0c lw r1,(r12+12) <== NOT EXECUTED
8003310: 5c 31 00 03 bne r1,r17,800331c <rtems_termios_open+0x84> <== NOT EXECUTED
8003314: 29 81 00 10 lw r1,(r12+16) <== NOT EXECUTED
8003318: 44 32 00 d8 be r1,r18,8003678 <rtems_termios_open+0x3e0> <== NOT EXECUTED
sc = rtems_semaphore_obtain(
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
800331c: 29 8c 00 00 lw r12,(r12+0) <== NOT EXECUTED
8003320: 5d 80 ff fb bne r12,r0,800330c <rtems_termios_open+0x74> <== NEVER TAKEN
8003324: e0 00 01 04 bi 8003734 <rtems_termios_open+0x49c>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
8003328: 78 01 08 02 mvhi r1,0x802
800332c: 38 21 51 90 ori r1,r1,0x5190
8003330: 28 21 00 00 lw r1,(r1+0)
8003334: 59 81 00 64 sw (r12+100),r1
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
8003338: 29 81 00 64 lw r1,(r12+100)
800333c: fb ff fc 6a calli 80024e4 <malloc>
8003340: 59 81 00 58 sw (r12+88),r1
8003344: b8 20 80 00 mv r16,r1
if (tty->rawInBuf.theBuf == NULL) {
8003348: 5c 20 00 09 bne r1,r0,800336c <rtems_termios_open+0xd4>
free(tty);
800334c: b9 80 08 00 mv r1,r12
8003350: fb ff fa ad calli 8001e04 <free>
rtems_semaphore_release (rtems_termios_ttyMutex);
8003354: 78 01 08 02 mvhi r1,0x802
8003358: 38 21 5d a8 ori r1,r1,0x5da8
800335c: 28 21 00 00 lw r1,(r1+0)
return RTEMS_NO_MEMORY;
8003360: 34 0f 00 1a mvi r15,26
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
if (tty->rawInBuf.theBuf == NULL) {
free(tty);
rtems_semaphore_release (rtems_termios_ttyMutex);
8003364: f8 00 0a 08 calli 8005b84 <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
8003368: e0 00 00 e5 bi 80036fc <rtems_termios_open+0x464>
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
800336c: 78 01 08 02 mvhi r1,0x802
8003370: 38 21 51 94 ori r1,r1,0x5194
8003374: 28 21 00 00 lw r1,(r1+0)
8003378: 59 81 00 88 sw (r12+136),r1
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
800337c: 29 81 00 88 lw r1,(r12+136)
8003380: fb ff fc 59 calli 80024e4 <malloc>
8003384: 59 81 00 7c sw (r12+124),r1
8003388: b8 20 98 00 mv r19,r1
if (tty->rawOutBuf.theBuf == NULL) {
800338c: 44 20 00 09 be r1,r0,80033b0 <rtems_termios_open+0x118>
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
8003390: 78 01 08 02 mvhi r1,0x802
8003394: 38 21 51 8c ori r1,r1,0x518c
8003398: 28 21 00 00 lw r1,(r1+0)
800339c: fb ff fc 52 calli 80024e4 <malloc>
80033a0: 59 81 00 1c sw (r12+28),r1
if (tty->cbuf == NULL) {
80033a4: 5c 20 00 06 bne r1,r0,80033bc <rtems_termios_open+0x124> <== ALWAYS TAKEN
free((void *)(tty->rawOutBuf.theBuf));
80033a8: ba 60 08 00 mv r1,r19 <== NOT EXECUTED
80033ac: fb ff fa 96 calli 8001e04 <free> <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
80033b0: ba 00 08 00 mv r1,r16
80033b4: fb ff fa 94 calli 8001e04 <free>
80033b8: e3 ff ff e5 bi 800334c <rtems_termios_open+0xb4>
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
80033bc: 59 80 00 d4 sw (r12+212),r0
tty->tty_snd.sw_arg = NULL;
80033c0: 59 80 00 d8 sw (r12+216),r0
tty->tty_rcv.sw_pfn = NULL;
80033c4: 59 80 00 dc sw (r12+220),r0
tty->tty_rcv.sw_arg = NULL;
80033c8: 59 80 00 e0 sw (r12+224),r0
tty->tty_rcvwakeup = 0;
80033cc: 59 80 00 e4 sw (r12+228),r0
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
80033d0: 59 8e 00 00 sw (r12+0),r14
tty->back = NULL;
80033d4: 59 80 00 04 sw (r12+4),r0
if (rtems_termios_ttyHead != NULL)
80033d8: 45 c0 00 02 be r14,r0,80033e0 <rtems_termios_open+0x148> <== ALWAYS TAKEN
rtems_termios_ttyHead->back = tty;
80033dc: 59 cc 00 04 sw (r14+4),r12 <== NOT EXECUTED
rtems_termios_ttyHead = tty;
80033e0: 78 01 08 02 mvhi r1,0x802
if (rtems_termios_ttyTail == NULL)
80033e4: 78 04 08 02 mvhi r4,0x802
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
80033e8: 38 21 5d b0 ori r1,r1,0x5db0
if (rtems_termios_ttyTail == NULL)
80033ec: 38 84 5d ac ori r4,r4,0x5dac
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
80033f0: 58 2b 00 00 sw (r1+0),r11
if (rtems_termios_ttyTail == NULL)
80033f4: 28 81 00 00 lw r1,(r4+0)
80033f8: 5c 20 00 02 bne r1,r0,8003400 <rtems_termios_open+0x168> <== NEVER TAKEN
rtems_termios_ttyTail = tty;
80033fc: 58 8b 00 00 sw (r4+0),r11
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
8003400: 78 0e 08 02 mvhi r14,0x802
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
8003404: 78 03 08 02 mvhi r3,0x802
8003408: 38 63 38 cc ori r3,r3,0x38cc
rtems_build_name ('T', 'R', 'i', c),
800340c: 39 ce 51 98 ori r14,r14,0x5198
8003410: 41 c2 00 00 lbu r2,(r14+0)
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
8003414: 28 61 00 00 lw r1,(r3+0)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
8003418: 59 72 00 10 sw (r11+16),r18
tty->major = major;
800341c: 59 71 00 0c sw (r11+12),r17
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
8003420: b8 41 08 00 or r1,r2,r1
8003424: 34 03 00 54 mvi r3,84
8003428: 34 02 00 01 mvi r2,1
800342c: 34 04 00 00 mvi r4,0
8003430: 35 65 00 14 addi r5,r11,20
8003434: f8 00 08 d8 calli 8005794 <rtems_semaphore_create>
8003438: b8 20 80 00 mv r16,r1
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)
800343c: 5c 20 00 ab bne r1,r0,80036e8 <rtems_termios_open+0x450> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
8003440: 78 03 08 02 mvhi r3,0x802
8003444: 38 63 38 d0 ori r3,r3,0x38d0
rtems_build_name ('T', 'R', 'o', c),
8003448: 41 c2 00 00 lbu r2,(r14+0)
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 (
800344c: 28 61 00 00 lw r1,(r3+0)
8003450: 34 04 00 00 mvi r4,0
8003454: 34 03 00 54 mvi r3,84
8003458: b8 41 08 00 or r1,r2,r1
800345c: 35 65 00 18 addi r5,r11,24
8003460: 34 02 00 01 mvi r2,1
8003464: f8 00 08 cc calli 8005794 <rtems_semaphore_create>
8003468: b8 20 98 00 mv r19,r1
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)
800346c: 5c 30 00 9f bne r1,r16,80036e8 <rtems_termios_open+0x450> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
8003470: 78 03 08 02 mvhi r3,0x802
8003474: 38 63 38 d4 ori r3,r3,0x38d4
rtems_build_name ('T', 'R', 'x', c),
8003478: 41 c2 00 00 lbu r2,(r14+0)
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 (
800347c: 28 61 00 00 lw r1,(r3+0)
8003480: 34 04 00 00 mvi r4,0
8003484: 34 03 00 20 mvi r3,32
8003488: b8 41 08 00 or r1,r2,r1
800348c: 35 65 00 8c addi r5,r11,140
8003490: 34 02 00 00 mvi r2,0
8003494: f8 00 08 c0 calli 8005794 <rtems_semaphore_create>
8003498: b8 20 80 00 mv r16,r1
rtems_build_name ('T', 'R', 'x', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
800349c: 5c 33 00 93 bne r1,r19,80036e8 <rtems_termios_open+0x450> <== NEVER TAKEN
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
80034a0: 29 a2 00 18 lw r2,(r13+24)
80034a4: 29 a8 00 00 lw r8,(r13+0)
80034a8: 29 a7 00 04 lw r7,(r13+4)
80034ac: 29 a6 00 08 lw r6,(r13+8)
80034b0: 29 a5 00 0c lw r5,(r13+12)
80034b4: 29 a4 00 10 lw r4,(r13+16)
80034b8: 29 a3 00 14 lw r3,(r13+20)
80034bc: 29 a1 00 1c lw r1,(r13+28)
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;
80034c0: 59 60 00 94 sw (r11+148),r0
/*
* Set callbacks
*/
tty->device = *callbacks;
80034c4: 59 62 00 b0 sw (r11+176),r2
80034c8: 59 68 00 98 sw (r11+152),r8
80034cc: 59 67 00 9c sw (r11+156),r7
80034d0: 59 66 00 a0 sw (r11+160),r6
80034d4: 59 65 00 a4 sw (r11+164),r5
80034d8: 59 64 00 a8 sw (r11+168),r4
80034dc: 59 63 00 ac sw (r11+172),r3
80034e0: 59 61 00 b4 sw (r11+180),r1
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
80034e4: 34 02 00 02 mvi r2,2
80034e8: 5c 22 00 1a bne r1,r2,8003550 <rtems_termios_open+0x2b8>
sc = rtems_task_create (
80034ec: 78 03 08 02 mvhi r3,0x802
80034f0: 38 63 38 d8 ori r3,r3,0x38d8
rtems_build_name ('T', 'x', 'T', c),
80034f4: 41 c2 00 00 lbu r2,(r14+0)
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
80034f8: 28 61 00 00 lw r1,(r3+0)
80034fc: 34 04 05 00 mvi r4,1280
8003500: 34 03 04 00 mvi r3,1024
8003504: b8 41 08 00 or r1,r2,r1
8003508: 34 05 00 00 mvi r5,0
800350c: 34 02 00 0a mvi r2,10
8003510: 35 66 00 c8 addi r6,r11,200
8003514: f8 00 09 da calli 8005c7c <rtems_task_create>
8003518: b8 20 68 00 mv r13,r1
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
800351c: 5c 30 00 73 bne r1,r16,80036e8 <rtems_termios_open+0x450> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
8003520: 78 03 08 02 mvhi r3,0x802
8003524: 38 63 38 dc ori r3,r3,0x38dc
rtems_build_name ('R', 'x', 'T', c),
8003528: 41 c2 00 00 lbu r2,(r14+0)
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
800352c: 28 61 00 00 lw r1,(r3+0)
8003530: 34 04 05 00 mvi r4,1280
8003534: 34 03 04 00 mvi r3,1024
8003538: b8 41 08 00 or r1,r2,r1
800353c: 34 05 00 00 mvi r5,0
8003540: 34 02 00 09 mvi r2,9
8003544: 35 66 00 c4 addi r6,r11,196
8003548: f8 00 09 cd calli 8005c7c <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)
800354c: 5c 2d 00 67 bne r1,r13,80036e8 <rtems_termios_open+0x450> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
8003550: 29 61 00 a0 lw r1,(r11+160)
8003554: 44 20 00 04 be r1,r0,8003564 <rtems_termios_open+0x2cc>
8003558: 29 62 00 b4 lw r2,(r11+180)
800355c: 34 01 00 02 mvi r1,2
8003560: 5c 41 00 0e bne r2,r1,8003598 <rtems_termios_open+0x300>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'r', c),
8003564: 78 01 08 02 mvhi r1,0x802
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
8003568: 78 03 08 02 mvhi r3,0x802
rtems_build_name ('T', 'R', 'r', c),
800356c: 38 21 51 98 ori r1,r1,0x5198
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
8003570: 38 63 38 e0 ori r3,r3,0x38e0
rtems_build_name ('T', 'R', 'r', c),
8003574: 40 22 00 00 lbu r2,(r1+0)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
8003578: 28 61 00 00 lw r1,(r3+0)
800357c: 34 04 00 00 mvi r4,0
8003580: 34 03 00 24 mvi r3,36
8003584: b8 41 08 00 or r1,r2,r1
8003588: 35 65 00 68 addi r5,r11,104
800358c: 34 02 00 00 mvi r2,0
8003590: f8 00 08 81 calli 8005794 <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)
8003594: 5c 20 00 55 bne r1,r0,80036e8 <rtems_termios_open+0x450> <== NEVER TAKEN
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
8003598: 34 01 25 02 mvi r1,9474
800359c: 59 61 00 30 sw (r11+48),r1
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
80035a0: 34 01 18 05 mvi r1,6149
80035a4: 59 61 00 34 sw (r11+52),r1
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
80035a8: 34 01 08 bd mvi r1,2237
80035ac: 59 61 00 38 sw (r11+56),r1
tty->termios.c_lflag =
80035b0: 34 21 79 7e addi r1,r1,31102
80035b4: 59 61 00 3c sw (r11+60),r1
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
80035b8: 34 01 00 03 mvi r1,3
80035bc: 31 61 00 41 sb (r11+65),r1
tty->termios.c_cc[VQUIT] = '\034';
80035c0: 34 01 00 1c mvi r1,28
80035c4: 31 61 00 42 sb (r11+66),r1
tty->termios.c_cc[VERASE] = '\177';
80035c8: 34 01 00 7f mvi r1,127
80035cc: 31 61 00 43 sb (r11+67),r1
tty->termios.c_cc[VKILL] = '\025';
80035d0: 34 01 00 15 mvi r1,21
80035d4: 31 61 00 44 sb (r11+68),r1
tty->termios.c_cc[VEOF] = '\004';
80035d8: 34 01 00 04 mvi r1,4
80035dc: 31 61 00 45 sb (r11+69),r1
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
80035e0: 34 01 00 11 mvi r1,17
80035e4: 31 61 00 49 sb (r11+73),r1
tty->termios.c_cc[VSTOP] = '\023';
80035e8: 34 01 00 13 mvi r1,19
80035ec: 31 61 00 4a sb (r11+74),r1
tty->termios.c_cc[VSUSP] = '\032';
80035f0: 34 01 00 1a mvi r1,26
80035f4: 31 61 00 4b sb (r11+75),r1
tty->termios.c_cc[VREPRINT] = '\022';
80035f8: 34 01 00 12 mvi r1,18
80035fc: 31 61 00 4d sb (r11+77),r1
tty->termios.c_cc[VDISCARD] = '\017';
8003600: 34 01 00 0f mvi r1,15
8003604: 31 61 00 4e sb (r11+78),r1
tty->termios.c_cc[VWERASE] = '\027';
8003608: 34 01 00 17 mvi r1,23
800360c: 31 61 00 4f sb (r11+79),r1
tty->termios.c_cc[VLNEXT] = '\026';
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
8003610: 59 60 00 b8 sw (r11+184),r0
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';
8003614: 34 01 00 16 mvi r1,22
8003618: 31 61 00 50 sb (r11+80),r1
/* 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;
800361c: 29 61 00 64 lw r1,(r11+100)
8003620: 34 02 00 01 mvi r2,1
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';
8003624: 31 60 00 4c sb (r11+76),r0
tty->termios.c_cc[VEOL2] = '\000';
8003628: 31 60 00 51 sb (r11+81),r0
/* 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;
800362c: f8 00 7a ef calli 80221e8 <__lshrsi3>
tty->highwater = tty->rawInBuf.Size * 3/4;
8003630: 29 6d 00 64 lw r13,(r11+100)
/* 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;
8003634: 59 61 00 bc sw (r11+188),r1
tty->highwater = tty->rawInBuf.Size * 3/4;
8003638: 34 02 00 01 mvi r2,1
800363c: b9 a0 08 00 mv r1,r13
8003640: fb ff f4 d4 calli 8000990 <__ashlsi3>
8003644: 34 02 00 02 mvi r2,2
8003648: b4 2d 08 00 add r1,r1,r13
800364c: f8 00 7a e7 calli 80221e8 <__lshrsi3>
/*
* Bump name characer
*/
if (c++ == 'z')
8003650: 78 04 08 02 mvhi r4,0x802
8003654: 38 84 51 98 ori r4,r4,0x5198
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;
8003658: 59 61 00 c0 sw (r11+192),r1
/*
* Bump name characer
*/
if (c++ == 'z')
800365c: 40 81 00 00 lbu r1,(r4+0)
8003660: 34 22 00 01 addi r2,r1,1
8003664: 30 82 00 00 sb (r4+0),r2
8003668: 34 02 00 7a mvi r2,122
800366c: 5c 22 00 03 bne r1,r2,8003678 <rtems_termios_open+0x3e0>
c = 'a';
8003670: 34 01 00 61 mvi r1,97
8003674: 30 81 00 00 sb (r4+0),r1
}
args->iop->data1 = tty;
8003678: 2a 81 00 00 lw r1,(r20+0)
if (!tty->refcount++) {
800367c: 29 82 00 08 lw r2,(r12+8)
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
8003680: 58 2c 00 38 sw (r1+56),r12
if (!tty->refcount++) {
8003684: 34 41 00 01 addi r1,r2,1
8003688: 59 81 00 08 sw (r12+8),r1
800368c: 5c 40 00 18 bne r2,r0,80036ec <rtems_termios_open+0x454> <== NEVER TAKEN
if (tty->device.firstOpen)
8003690: 29 84 00 98 lw r4,(r12+152)
8003694: 44 82 00 05 be r4,r2,80036a8 <rtems_termios_open+0x410> <== ALWAYS TAKEN
(*tty->device.firstOpen)(major, minor, arg);
8003698: ba 20 08 00 mv r1,r17 <== NOT EXECUTED
800369c: ba 40 10 00 mv r2,r18 <== NOT EXECUTED
80036a0: ba 80 18 00 mv r3,r20 <== NOT EXECUTED
80036a4: d8 80 00 00 call r4 <== NOT EXECUTED
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
80036a8: 29 82 00 b4 lw r2,(r12+180)
80036ac: 34 01 00 02 mvi r1,2
80036b0: 5c 41 00 0f bne r2,r1,80036ec <rtems_termios_open+0x454>
sc = rtems_task_start(
80036b4: 29 81 00 c4 lw r1,(r12+196)
80036b8: 78 02 08 00 mvhi r2,0x800
80036bc: 38 42 4c 20 ori r2,r2,0x4c20
80036c0: b9 80 18 00 mv r3,r12
80036c4: f8 00 0a 16 calli 8005f1c <rtems_task_start>
80036c8: b8 20 58 00 mv r11,r1
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
80036cc: 5c 20 00 07 bne r1,r0,80036e8 <rtems_termios_open+0x450> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
80036d0: 29 81 00 c8 lw r1,(r12+200)
80036d4: 78 02 08 00 mvhi r2,0x800
80036d8: 38 42 4e a0 ori r2,r2,0x4ea0
80036dc: b9 80 18 00 mv r3,r12
80036e0: f8 00 0a 0f calli 8005f1c <rtems_task_start>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
80036e4: 44 2b 00 02 be r1,r11,80036ec <rtems_termios_open+0x454> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
80036e8: f8 00 0b 19 calli 800634c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
80036ec: 78 01 08 02 mvhi r1,0x802
80036f0: 38 21 5d a8 ori r1,r1,0x5da8
80036f4: 28 21 00 00 lw r1,(r1+0)
80036f8: f8 00 09 23 calli 8005b84 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
80036fc: b9 e0 08 00 mv r1,r15
8003700: 2b 9d 00 04 lw ra,(sp+4)
8003704: 2b 8b 00 2c lw r11,(sp+44)
8003708: 2b 8c 00 28 lw r12,(sp+40)
800370c: 2b 8d 00 24 lw r13,(sp+36)
8003710: 2b 8e 00 20 lw r14,(sp+32)
8003714: 2b 8f 00 1c lw r15,(sp+28)
8003718: 2b 90 00 18 lw r16,(sp+24)
800371c: 2b 91 00 14 lw r17,(sp+20)
8003720: 2b 92 00 10 lw r18,(sp+16)
8003724: 2b 93 00 0c lw r19,(sp+12)
8003728: 2b 94 00 08 lw r20,(sp+8)
800372c: 37 9c 00 2c addi sp,sp,44
8003730: c3 a0 00 00 ret
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
8003734: 34 01 00 01 mvi r1,1
8003738: 34 02 00 e8 mvi r2,232
800373c: fb ff f8 f4 calli 8001b0c <calloc>
8003740: b8 20 60 00 mv r12,r1
8003744: b8 20 58 00 mv r11,r1
if (tty == NULL) {
8003748: 5c 20 fe f8 bne r1,r0,8003328 <rtems_termios_open+0x90>
800374c: e3 ff ff 02 bi 8003354 <rtems_termios_open+0xbc>
08003d10 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
8003d10: 37 9c ff dc addi sp,sp,-36
8003d14: 5b 8b 00 24 sw (sp+36),r11
8003d18: 5b 8c 00 20 sw (sp+32),r12
8003d1c: 5b 8d 00 1c sw (sp+28),r13
8003d20: 5b 8e 00 18 sw (sp+24),r14
8003d24: 5b 8f 00 14 sw (sp+20),r15
8003d28: 5b 90 00 10 sw (sp+16),r16
8003d2c: 5b 91 00 0c sw (sp+12),r17
8003d30: 5b 92 00 08 sw (sp+8),r18
8003d34: 5b 9d 00 04 sw (sp+4),ra
8003d38: b8 20 20 00 mv r4,r1
const unsigned char *buf = _buf;
8003d3c: b8 20 68 00 mv r13,r1
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
8003d40: 28 61 00 b4 lw r1,(r3+180)
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
8003d44: b8 40 70 00 mv r14,r2
8003d48: b8 60 58 00 mv r11,r3
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
8003d4c: 5c 20 00 07 bne r1,r0,8003d68 <rtems_termios_puts+0x58> <== NEVER TAKEN
(*tty->device.write)(tty->minor, (void *)buf, len);
8003d50: 28 65 00 a4 lw r5,(r3+164)
8003d54: 28 61 00 10 lw r1,(r3+16)
8003d58: b8 80 10 00 mv r2,r4
8003d5c: b9 c0 18 00 mv r3,r14
8003d60: d8 a0 00 00 call r5
return;
8003d64: e0 00 00 36 bi 8003e3c <rtems_termios_puts+0x12c>
}
newHead = tty->rawOutBuf.Head;
8003d68: 28 6c 00 80 lw r12,(r3+128)
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
8003d6c: 34 10 ff fe mvi r16,-2
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
8003d70: 34 12 00 02 mvi r18,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;
8003d74: 34 11 00 01 mvi r17,1
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
8003d78: e0 00 00 30 bi 8003e38 <rtems_termios_puts+0x128>
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
8003d7c: 29 62 00 88 lw r2,(r11+136)
8003d80: 35 81 00 01 addi r1,r12,1
8003d84: f8 00 79 b5 calli 8022458 <__umodsi3>
8003d88: b8 20 60 00 mv r12,r1
rtems_interrupt_disable (level);
8003d8c: 90 00 78 00 rcsr r15,IE
8003d90: a1 f0 08 00 and r1,r15,r16
8003d94: d0 01 00 00 wcsr IE,r1
while (newHead == tty->rawOutBuf.Tail) {
8003d98: e0 00 00 0c bi 8003dc8 <rtems_termios_puts+0xb8>
tty->rawOutBufState = rob_wait;
8003d9c: 59 72 00 94 sw (r11+148),r18
rtems_interrupt_enable (level);
8003da0: d0 0f 00 00 wcsr IE,r15
sc = rtems_semaphore_obtain(
8003da4: 29 61 00 8c lw r1,(r11+140)
8003da8: 34 02 00 00 mvi r2,0
8003dac: 34 03 00 00 mvi r3,0
8003db0: f8 00 07 25 calli 8005a44 <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
8003db4: 44 20 00 02 be r1,r0,8003dbc <rtems_termios_puts+0xac> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
8003db8: f8 00 09 65 calli 800634c <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_interrupt_disable (level);
8003dbc: 90 00 78 00 rcsr r15,IE
8003dc0: a1 f0 08 00 and r1,r15,r16
8003dc4: d0 01 00 00 wcsr IE,r1
* 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) {
8003dc8: 29 61 00 84 lw r1,(r11+132)
8003dcc: 45 81 ff f4 be r12,r1,8003d9c <rtems_termios_puts+0x8c>
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++;
8003dd0: 29 61 00 80 lw r1,(r11+128)
8003dd4: 29 62 00 7c lw r2,(r11+124)
8003dd8: b4 41 08 00 add r1,r2,r1
8003ddc: 41 a2 00 00 lbu r2,(r13+0)
8003de0: 35 ad 00 01 addi r13,r13,1
8003de4: 30 22 00 00 sb (r1+0),r2
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
8003de8: 29 61 00 94 lw r1,(r11+148)
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
8003dec: 59 6c 00 80 sw (r11+128),r12
if (tty->rawOutBufState == rob_idle) {
8003df0: 5c 20 00 10 bne r1,r0,8003e30 <rtems_termios_puts+0x120>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
8003df4: 29 62 00 b8 lw r2,(r11+184)
8003df8: 20 42 00 10 andi r2,r2,0x10
8003dfc: 5c 41 00 09 bne r2,r1,8003e20 <rtems_termios_puts+0x110> <== NEVER TAKEN
(*tty->device.write)(tty->minor,
8003e00: 29 63 00 7c lw r3,(r11+124)
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
8003e04: 29 62 00 84 lw r2,(r11+132)
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,
8003e08: 29 64 00 a4 lw r4,(r11+164)
8003e0c: 29 61 00 10 lw r1,(r11+16)
8003e10: b4 62 10 00 add r2,r3,r2
8003e14: 34 03 00 01 mvi r3,1
8003e18: d8 80 00 00 call r4
8003e1c: e0 00 00 04 bi 8003e2c <rtems_termios_puts+0x11c>
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
8003e20: 29 61 00 b8 lw r1,(r11+184) <== NOT EXECUTED
8003e24: 38 21 00 20 ori r1,r1,0x20 <== NOT EXECUTED
8003e28: 59 61 00 b8 sw (r11+184),r1 <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
8003e2c: 59 71 00 94 sw (r11+148),r17
}
rtems_interrupt_enable (level);
8003e30: d0 0f 00 00 wcsr IE,r15
len--;
8003e34: 35 ce ff ff addi r14,r14,-1
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
8003e38: 5d c0 ff d1 bne r14,r0,8003d7c <rtems_termios_puts+0x6c>
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
8003e3c: 2b 9d 00 04 lw ra,(sp+4)
8003e40: 2b 8b 00 24 lw r11,(sp+36)
8003e44: 2b 8c 00 20 lw r12,(sp+32)
8003e48: 2b 8d 00 1c lw r13,(sp+28)
8003e4c: 2b 8e 00 18 lw r14,(sp+24)
8003e50: 2b 8f 00 14 lw r15,(sp+20)
8003e54: 2b 90 00 10 lw r16,(sp+16)
8003e58: 2b 91 00 0c lw r17,(sp+12)
8003e5c: 2b 92 00 08 lw r18,(sp+8)
8003e60: 37 9c 00 24 addi sp,sp,36
8003e64: c3 a0 00 00 ret
08004588 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
8004588: 37 9c ff cc addi sp,sp,-52
800458c: 5b 8b 00 34 sw (sp+52),r11
8004590: 5b 8c 00 30 sw (sp+48),r12
8004594: 5b 8d 00 2c sw (sp+44),r13
8004598: 5b 8e 00 28 sw (sp+40),r14
800459c: 5b 8f 00 24 sw (sp+36),r15
80045a0: 5b 90 00 20 sw (sp+32),r16
80045a4: 5b 91 00 1c sw (sp+28),r17
80045a8: 5b 92 00 18 sw (sp+24),r18
80045ac: 5b 93 00 14 sw (sp+20),r19
80045b0: 5b 94 00 10 sw (sp+16),r20
80045b4: 5b 95 00 0c sw (sp+12),r21
80045b8: 5b 96 00 08 sw (sp+8),r22
80045bc: 5b 9d 00 04 sw (sp+4),ra
80045c0: b8 20 60 00 mv r12,r1
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
80045c4: 28 21 00 00 lw r1,(r1+0)
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
80045c8: 34 02 00 00 mvi r2,0
80045cc: 34 03 00 00 mvi r3,0
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
80045d0: 28 2b 00 38 lw r11,(r1+56)
uint32_t count = args->count;
80045d4: 29 8f 00 14 lw r15,(r12+20)
char *buffer = args->buffer;
80045d8: 29 91 00 10 lw r17,(r12+16)
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
80045dc: 29 61 00 14 lw r1,(r11+20)
80045e0: f8 00 05 19 calli 8005a44 <rtems_semaphore_obtain>
80045e4: b8 20 70 00 mv r14,r1
if (sc != RTEMS_SUCCESSFUL)
80045e8: 5c 20 00 ad bne r1,r0,800489c <rtems_termios_read+0x314> <== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
80045ec: 29 61 00 cc lw r1,(r11+204)
80045f0: 78 0d 08 02 mvhi r13,0x802
80045f4: 34 02 00 05 mvi r2,5
80045f8: fb ff f0 e6 calli 8000990 <__ashlsi3>
80045fc: 39 ad 57 a4 ori r13,r13,0x57a4
8004600: b5 a1 08 00 add r1,r13,r1
8004604: 28 23 00 08 lw r3,(r1+8)
8004608: 44 6e 00 06 be r3,r14,8004620 <rtems_termios_read+0x98>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
800460c: b9 60 08 00 mv r1,r11
8004610: b9 80 10 00 mv r2,r12
8004614: d8 60 00 00 call r3
8004618: b8 20 70 00 mv r14,r1
800461c: e0 00 00 9d bi 8004890 <rtems_termios_read+0x308>
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
8004620: 29 62 00 24 lw r2,(r11+36)
8004624: 29 61 00 20 lw r1,(r11+32)
8004628: 5c 41 00 93 bne r2,r1,8004874 <rtems_termios_read+0x2ec> <== NEVER TAKEN
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
800462c: 29 61 00 28 lw r1,(r11+40)
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
8004630: 59 60 00 20 sw (r11+32),r0
8004634: 59 60 00 24 sw (r11+36),r0
tty->read_start_column = tty->column;
8004638: 59 61 00 2c sw (r11+44),r1
if (tty->device.pollRead != NULL &&
800463c: 29 61 00 a0 lw r1,(r11+160)
8004640: 44 20 00 31 be r1,r0,8004704 <rtems_termios_read+0x17c>
8004644: 29 61 00 b4 lw r1,(r11+180)
8004648: 5c 20 00 2f bne r1,r0,8004704 <rtems_termios_read+0x17c>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
800464c: 29 61 00 3c lw r1,(r11+60)
8004650: 20 21 00 02 andi r1,r1,0x2
8004654: 44 20 00 0d be r1,r0,8004688 <rtems_termios_read+0x100>
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
8004658: 29 62 00 a0 lw r2,(r11+160)
800465c: 29 61 00 10 lw r1,(r11+16)
8004660: d8 40 00 00 call r2
if (n < 0) {
8004664: 4c 20 00 04 bge r1,r0,8004674 <rtems_termios_read+0xec>
rtems_task_wake_after (1);
8004668: 34 01 00 01 mvi r1,1
800466c: f8 00 06 4c calli 8005f9c <rtems_task_wake_after>
8004670: e3 ff ff fa bi 8004658 <rtems_termios_read+0xd0>
} else {
if (siproc (n, tty))
8004674: 20 21 00 ff andi r1,r1,0xff
8004678: b9 60 10 00 mv r2,r11
800467c: fb ff ff 6b calli 8004428 <siproc>
8004680: 44 20 ff f6 be r1,r0,8004658 <rtems_termios_read+0xd0>
8004684: e0 00 00 7c bi 8004874 <rtems_termios_read+0x2ec>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
8004688: f8 00 03 26 calli 8005320 <rtems_clock_get_ticks_since_boot>
800468c: b8 20 68 00 mv r13,r1
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
8004690: 29 62 00 a0 lw r2,(r11+160)
8004694: 29 61 00 10 lw r1,(r11+16)
8004698: d8 40 00 00 call r2
if (n < 0) {
800469c: 4c 20 00 10 bge r1,r0,80046dc <rtems_termios_read+0x154>
if (tty->termios.c_cc[VMIN]) {
80046a0: 41 61 00 47 lbu r1,(r11+71)
80046a4: 41 62 00 46 lbu r2,(r11+70)
80046a8: 44 20 00 05 be r1,r0,80046bc <rtems_termios_read+0x134> <== NEVER TAKEN
if (tty->termios.c_cc[VTIME] && tty->ccount) {
80046ac: 44 40 00 09 be r2,r0,80046d0 <rtems_termios_read+0x148> <== NEVER TAKEN
80046b0: 29 61 00 20 lw r1,(r11+32)
80046b4: 44 20 00 07 be r1,r0,80046d0 <rtems_termios_read+0x148>
80046b8: e0 00 00 02 bi 80046c0 <rtems_termios_read+0x138>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
80046bc: 44 41 00 6e be r2,r1,8004874 <rtems_termios_read+0x2ec> <== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
80046c0: f8 00 03 18 calli 8005320 <rtems_clock_get_ticks_since_boot>
if ((now - then) > tty->vtimeTicks) {
80046c4: 29 62 00 54 lw r2,(r11+84)
80046c8: c8 2d 08 00 sub r1,r1,r13
80046cc: 54 22 00 6a bgu r1,r2,8004874 <rtems_termios_read+0x2ec>
break;
}
}
rtems_task_wake_after (1);
80046d0: 34 01 00 01 mvi r1,1
80046d4: f8 00 06 32 calli 8005f9c <rtems_task_wake_after>
80046d8: e3 ff ff ee bi 8004690 <rtems_termios_read+0x108>
} else {
siproc (n, tty);
80046dc: b9 60 10 00 mv r2,r11
80046e0: 20 21 00 ff andi r1,r1,0xff
80046e4: fb ff ff 51 calli 8004428 <siproc>
if (tty->ccount >= tty->termios.c_cc[VMIN])
80046e8: 41 61 00 47 lbu r1,(r11+71)
80046ec: 29 62 00 20 lw r2,(r11+32)
80046f0: 4c 41 00 61 bge r2,r1,8004874 <rtems_termios_read+0x2ec> <== NEVER TAKEN
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
80046f4: 44 20 ff e7 be r1,r0,8004690 <rtems_termios_read+0x108> <== NEVER TAKEN
80046f8: 41 61 00 46 lbu r1,(r11+70)
80046fc: 44 20 ff e5 be r1,r0,8004690 <rtems_termios_read+0x108> <== NEVER TAKEN
8004700: e3 ff ff e2 bi 8004688 <rtems_termios_read+0x100>
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
8004704: 78 10 08 02 mvhi r16,0x802
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
8004708: 29 72 00 74 lw r18,(r11+116)
rtems_status_code sc;
int wait = (int)1;
800470c: 34 0d 00 01 mvi r13,1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
8004710: 3a 10 51 8c ori r16,r16,0x518c
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;
8004714: 34 16 ff fe mvi r22,-2
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
8004718: 34 15 02 02 mvi r21,514
|| (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;
800471c: 34 14 ff fb mvi r20,-5
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)(
8004720: 35 73 00 49 addi r19,r11,73
8004724: e0 00 00 3e bi 800481c <rtems_termios_read+0x294>
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
8004728: 29 61 00 5c lw r1,(r11+92)
800472c: 29 62 00 64 lw r2,(r11+100)
8004730: 34 21 00 01 addi r1,r1,1
8004734: f8 00 77 49 calli 8022458 <__umodsi3>
8004738: b8 20 18 00 mv r3,r1
c = tty->rawInBuf.theBuf[newHead];
800473c: 29 61 00 58 lw r1,(r11+88)
8004740: b4 23 08 00 add r1,r1,r3
8004744: 40 32 00 00 lbu r18,(r1+0)
tty->rawInBuf.Head = newHead;
8004748: 59 63 00 5c sw (r11+92),r3
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
800474c: 29 61 00 60 lw r1,(r11+96)
8004750: 29 64 00 64 lw r4,(r11+100)
% tty->rawInBuf.Size)
8004754: 29 62 00 64 lw r2,(r11+100)
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)
8004758: b4 81 08 00 add r1,r4,r1
% tty->rawInBuf.Size)
800475c: c8 23 08 00 sub r1,r1,r3
8004760: f8 00 77 3e calli 8022458 <__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)
8004764: 29 62 00 bc lw r2,(r11+188)
8004768: 50 22 00 1c bgeu r1,r2,80047d8 <rtems_termios_read+0x250> <== NEVER TAKEN
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
800476c: 29 61 00 b8 lw r1,(r11+184)
8004770: a0 36 08 00 and r1,r1,r22
8004774: 59 61 00 b8 sw (r11+184),r1
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
8004778: 29 61 00 b8 lw r1,(r11+184)
800477c: 20 21 02 02 andi r1,r1,0x202
8004780: 5c 35 00 0c bne r1,r21,80047b0 <rtems_termios_read+0x228> <== ALWAYS TAKEN
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
8004784: 29 61 00 94 lw r1,(r11+148) <== NOT EXECUTED
8004788: 44 20 00 04 be r1,r0,8004798 <rtems_termios_read+0x210> <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
800478c: 29 61 00 b8 lw r1,(r11+184) <== NOT EXECUTED
8004790: 20 21 00 20 andi r1,r1,0x20 <== NOT EXECUTED
8004794: 44 20 00 07 be r1,r0,80047b0 <rtems_termios_read+0x228> <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
8004798: 29 64 00 a4 lw r4,(r11+164) <== NOT EXECUTED
800479c: 29 61 00 10 lw r1,(r11+16) <== NOT EXECUTED
80047a0: ba 60 10 00 mv r2,r19 <== NOT EXECUTED
80047a4: 34 03 00 01 mvi r3,1 <== NOT EXECUTED
80047a8: d8 80 00 00 call r4 <== NOT EXECUTED
80047ac: e0 00 00 0b bi 80047d8 <rtems_termios_read+0x250> <== NOT EXECUTED
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
80047b0: 29 61 00 b8 lw r1,(r11+184)
80047b4: 20 21 01 00 andi r1,r1,0x100
80047b8: 44 20 00 08 be r1,r0,80047d8 <rtems_termios_read+0x250> <== ALWAYS TAKEN
tty->flow_ctrl &= ~FL_IRTSOFF;
80047bc: 29 61 00 b8 lw r1,(r11+184) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
80047c0: 29 63 00 b0 lw r3,(r11+176) <== 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;
80047c4: a0 34 08 00 and r1,r1,r20 <== NOT EXECUTED
80047c8: 59 61 00 b8 sw (r11+184),r1 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
80047cc: 44 60 00 03 be r3,r0,80047d8 <rtems_termios_read+0x250> <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
80047d0: 29 61 00 10 lw r1,(r11+16) <== NOT EXECUTED
80047d4: d8 60 00 00 call r3 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
80047d8: 29 61 00 3c lw r1,(r11+60)
80047dc: 20 21 00 02 andi r1,r1,0x2
80047e0: 44 20 00 06 be r1,r0,80047f8 <rtems_termios_read+0x270> <== NEVER TAKEN
if (siproc (c, tty))
80047e4: ba 40 08 00 mv r1,r18
80047e8: b9 60 10 00 mv r2,r11
80047ec: fb ff ff 0f calli 8004428 <siproc>
wait = 0;
80047f0: 64 21 00 00 cmpei r1,r1,0
80047f4: e0 00 00 07 bi 8004810 <rtems_termios_read+0x288>
} else {
siproc (c, tty);
80047f8: b9 60 10 00 mv r2,r11 <== NOT EXECUTED
80047fc: ba 40 08 00 mv r1,r18 <== NOT EXECUTED
8004800: fb ff ff 0a calli 8004428 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
8004804: 41 61 00 47 lbu r1,(r11+71) <== NOT EXECUTED
8004808: 29 62 00 20 lw r2,(r11+32) <== NOT EXECUTED
wait = 0;
800480c: e8 22 08 00 cmpg r1,r1,r2 <== NOT EXECUTED
}
timeout = tty->rawInBufSemaphoreTimeout;
8004810: 29 72 00 70 lw r18,(r11+112)
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
8004814: c8 01 08 00 sub r1,r0,r1
8004818: a1 a1 68 00 and r13,r13,r1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
800481c: 29 62 00 5c lw r2,(r11+92)
8004820: 29 61 00 60 lw r1,(r11+96)
8004824: 44 41 00 05 be r2,r1,8004838 <rtems_termios_read+0x2b0>
(tty->ccount < (CBUFSIZE-1))) {
8004828: 2a 01 00 00 lw r1,(r16+0)
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
800482c: 29 62 00 20 lw r2,(r11+32)
(tty->ccount < (CBUFSIZE-1))) {
8004830: 34 21 ff ff addi r1,r1,-1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
8004834: 48 22 ff bd bg r1,r2,8004728 <rtems_termios_read+0x1a0> <== ALWAYS TAKEN
}
/*
* Wait for characters
*/
if ( wait ) {
8004838: 45 a0 00 0f be r13,r0,8004874 <rtems_termios_read+0x2ec>
sc = rtems_semaphore_obtain(
800483c: 29 61 00 68 lw r1,(r11+104)
8004840: 29 62 00 6c lw r2,(r11+108)
8004844: ba 40 18 00 mv r3,r18
8004848: f8 00 04 7f calli 8005a44 <rtems_semaphore_obtain>
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
800484c: 44 20 ff f4 be r1,r0,800481c <rtems_termios_read+0x294> <== ALWAYS TAKEN
8004850: e0 00 00 09 bi 8004874 <rtems_termios_read+0x2ec> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
8004854: 29 62 00 1c lw r2,(r11+28)
count--;
8004858: 35 ef ff ff addi r15,r15,-1
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
800485c: b4 41 10 00 add r2,r2,r1
8004860: 40 42 00 00 lbu r2,(r2+0)
8004864: 34 21 00 01 addi r1,r1,1
8004868: 32 22 00 00 sb (r17+0),r2
800486c: 59 61 00 24 sw (r11+36),r1
8004870: 36 31 00 01 addi r17,r17,1
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
8004874: 45 e0 00 04 be r15,r0,8004884 <rtems_termios_read+0x2fc>
8004878: 29 61 00 24 lw r1,(r11+36)
800487c: 29 62 00 20 lw r2,(r11+32)
8004880: 48 41 ff f5 bg r2,r1,8004854 <rtems_termios_read+0x2cc>
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
8004884: 29 81 00 14 lw r1,(r12+20)
8004888: c8 2f 78 00 sub r15,r1,r15
800488c: 59 8f 00 1c sw (r12+28),r15
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
8004890: 29 61 00 14 lw r1,(r11+20)
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
tty->tty_rcvwakeup = 0;
8004894: 59 60 00 e4 sw (r11+228),r0
rtems_semaphore_release (tty->isem);
8004898: f8 00 04 bb calli 8005b84 <rtems_semaphore_release>
return sc;
}
800489c: b9 c0 08 00 mv r1,r14
80048a0: 2b 9d 00 04 lw ra,(sp+4)
80048a4: 2b 8b 00 34 lw r11,(sp+52)
80048a8: 2b 8c 00 30 lw r12,(sp+48)
80048ac: 2b 8d 00 2c lw r13,(sp+44)
80048b0: 2b 8e 00 28 lw r14,(sp+40)
80048b4: 2b 8f 00 24 lw r15,(sp+36)
80048b8: 2b 90 00 20 lw r16,(sp+32)
80048bc: 2b 91 00 1c lw r17,(sp+28)
80048c0: 2b 92 00 18 lw r18,(sp+24)
80048c4: 2b 93 00 14 lw r19,(sp+20)
80048c8: 2b 94 00 10 lw r20,(sp+16)
80048cc: 2b 95 00 0c lw r21,(sp+12)
80048d0: 2b 96 00 08 lw r22,(sp+8)
80048d4: 37 9c 00 34 addi sp,sp,52
80048d8: c3 a0 00 00 ret
08004c9c <rtems_termios_refill_transmitter>:
* in task-driven mode, this function is called in Tx task context
* in interrupt-driven mode, this function is called in TxIRQ context
*/
int
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
{
8004c9c: 37 9c ff f0 addi sp,sp,-16
8004ca0: 5b 8b 00 10 sw (sp+16),r11
8004ca4: 5b 8c 00 0c sw (sp+12),r12
8004ca8: 5b 8d 00 08 sw (sp+8),r13
8004cac: 5b 9d 00 04 sw (sp+4),ra
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
8004cb0: 28 22 00 b8 lw r2,(r1+184)
* 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)
{
8004cb4: b8 20 58 00 mv r11,r1
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
8004cb8: 34 01 04 01 mvi r1,1025
8004cbc: 20 42 04 03 andi r2,r2,0x403
8004cc0: 5c 41 00 12 bne r2,r1,8004d08 <rtems_termios_refill_transmitter+0x6c><== ALWAYS TAKEN
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
8004cc4: 29 64 00 a4 lw r4,(r11+164) <== NOT EXECUTED
8004cc8: 29 61 00 10 lw r1,(r11+16) <== NOT EXECUTED
8004ccc: 35 62 00 4a addi r2,r11,74 <== NOT EXECUTED
8004cd0: 34 03 00 01 mvi r3,1 <== NOT EXECUTED
8004cd4: d8 80 00 00 call r4 <== NOT EXECUTED
rtems_interrupt_disable(level);
8004cd8: 90 00 08 00 rcsr r1,IE <== NOT EXECUTED
8004cdc: 34 02 ff fe mvi r2,-2 <== NOT EXECUTED
8004ce0: a0 22 10 00 and r2,r1,r2 <== NOT EXECUTED
8004ce4: d0 02 00 00 wcsr IE,r2 <== NOT EXECUTED
tty->t_dqlen--;
8004ce8: 29 62 00 90 lw r2,(r11+144) <== NOT EXECUTED
8004cec: 34 42 ff ff addi r2,r2,-1 <== NOT EXECUTED
8004cf0: 59 62 00 90 sw (r11+144),r2 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
8004cf4: 29 62 00 b8 lw r2,(r11+184) <== NOT EXECUTED
8004cf8: 38 42 00 02 ori r2,r2,0x2 <== NOT EXECUTED
8004cfc: 59 62 00 b8 sw (r11+184),r2 <== NOT EXECUTED
rtems_interrupt_enable(level);
8004d00: d0 01 00 00 wcsr IE,r1 <== NOT EXECUTED
8004d04: e0 00 00 16 bi 8004d5c <rtems_termios_refill_transmitter+0xc0><== NOT EXECUTED
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
8004d08: 29 62 00 b8 lw r2,(r11+184)
8004d0c: 34 01 00 02 mvi r1,2
8004d10: 20 42 00 03 andi r2,r2,0x3
8004d14: 5c 41 00 14 bne r2,r1,8004d64 <rtems_termios_refill_transmitter+0xc8><== ALWAYS TAKEN
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
8004d18: 29 64 00 a4 lw r4,(r11+164) <== NOT EXECUTED
8004d1c: 29 61 00 10 lw r1,(r11+16) <== NOT EXECUTED
8004d20: 35 62 00 49 addi r2,r11,73 <== NOT EXECUTED
8004d24: 34 03 00 01 mvi r3,1 <== NOT EXECUTED
8004d28: d8 80 00 00 call r4 <== NOT EXECUTED
rtems_interrupt_disable(level);
8004d2c: 90 00 08 00 rcsr r1,IE <== NOT EXECUTED
8004d30: 34 02 ff fe mvi r2,-2 <== NOT EXECUTED
8004d34: a0 22 10 00 and r2,r1,r2 <== NOT EXECUTED
8004d38: d0 02 00 00 wcsr IE,r2 <== NOT EXECUTED
tty->t_dqlen--;
8004d3c: 29 62 00 90 lw r2,(r11+144) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
8004d40: 29 63 00 b8 lw r3,(r11+184) <== 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--;
8004d44: 34 42 ff ff addi r2,r2,-1 <== NOT EXECUTED
8004d48: 59 62 00 90 sw (r11+144),r2 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
8004d4c: 34 02 ff fd mvi r2,-3 <== NOT EXECUTED
8004d50: a0 62 10 00 and r2,r3,r2 <== NOT EXECUTED
8004d54: 59 62 00 b8 sw (r11+184),r2 <== NOT EXECUTED
rtems_interrupt_enable(level);
8004d58: d0 01 00 00 wcsr IE,r1 <== NOT EXECUTED
nToSend = 1;
8004d5c: 34 0c 00 01 mvi r12,1 <== NOT EXECUTED
8004d60: e0 00 00 49 bi 8004e84 <rtems_termios_refill_transmitter+0x1e8><== NOT EXECUTED
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
8004d64: 29 63 00 80 lw r3,(r11+128)
8004d68: 29 62 00 84 lw r2,(r11+132)
8004d6c: 5c 62 00 07 bne r3,r2,8004d88 <rtems_termios_refill_transmitter+0xec>
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
8004d70: 29 62 00 94 lw r2,(r11+148)
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
8004d74: 34 0c 00 00 mvi r12,0
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
8004d78: 5c 41 00 43 bne r2,r1,8004e84 <rtems_termios_refill_transmitter+0x1e8><== ALWAYS TAKEN
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
8004d7c: 29 61 00 8c lw r1,(r11+140) <== NOT EXECUTED
8004d80: f8 00 03 81 calli 8005b84 <rtems_semaphore_release> <== NOT EXECUTED
8004d84: e0 00 00 40 bi 8004e84 <rtems_termios_refill_transmitter+0x1e8><== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
8004d88: 90 00 10 00 rcsr r2,IE
8004d8c: 34 01 ff fe mvi r1,-2
8004d90: a0 41 08 00 and r1,r2,r1
8004d94: d0 01 00 00 wcsr IE,r1
len = tty->t_dqlen;
8004d98: 29 63 00 90 lw r3,(r11+144)
tty->t_dqlen = 0;
8004d9c: 59 60 00 90 sw (r11+144),r0
rtems_interrupt_enable(level);
8004da0: d0 02 00 00 wcsr IE,r2
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
8004da4: 29 61 00 84 lw r1,(r11+132)
8004da8: 29 62 00 88 lw r2,(r11+136)
8004dac: b4 61 08 00 add r1,r3,r1
8004db0: f8 00 75 aa calli 8022458 <__umodsi3>
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
8004db4: 29 62 00 94 lw r2,(r11+148)
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
8004db8: b8 20 68 00 mv r13,r1
tty->rawOutBuf.Tail = newTail;
8004dbc: 59 61 00 84 sw (r11+132),r1
if (tty->rawOutBufState == rob_wait) {
8004dc0: 34 01 00 02 mvi r1,2
8004dc4: 5c 41 00 03 bne r2,r1,8004dd0 <rtems_termios_refill_transmitter+0x134>
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
8004dc8: 29 61 00 8c lw r1,(r11+140)
8004dcc: f8 00 03 6e calli 8005b84 <rtems_semaphore_release>
}
if (newTail == tty->rawOutBuf.Head) {
8004dd0: 29 61 00 80 lw r1,(r11+128)
8004dd4: 5d a1 00 09 bne r13,r1,8004df8 <rtems_termios_refill_transmitter+0x15c>
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
8004dd8: 29 63 00 d4 lw r3,(r11+212)
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
8004ddc: 59 60 00 94 sw (r11+148),r0
nToSend = 0;
8004de0: 34 0c 00 00 mvi r12,0
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
8004de4: 44 60 00 27 be r3,r0,8004e80 <rtems_termios_refill_transmitter+0x1e4><== ALWAYS TAKEN
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
8004de8: 29 62 00 d8 lw r2,(r11+216) <== NOT EXECUTED
8004dec: 35 61 00 30 addi r1,r11,48 <== NOT EXECUTED
8004df0: d8 60 00 00 call r3 <== NOT EXECUTED
8004df4: e0 00 00 23 bi 8004e80 <rtems_termios_refill_transmitter+0x1e4><== NOT EXECUTED
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
8004df8: 29 62 00 b8 lw r2,(r11+184)
8004dfc: 34 01 02 10 mvi r1,528
8004e00: 20 42 02 10 andi r2,r2,0x210
8004e04: 5c 41 00 0d bne r2,r1,8004e38 <rtems_termios_refill_transmitter+0x19c><== ALWAYS TAKEN
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
8004e08: 90 00 08 00 rcsr r1,IE <== NOT EXECUTED
8004e0c: 34 02 ff fe mvi r2,-2 <== NOT EXECUTED
8004e10: a0 22 10 00 and r2,r1,r2 <== NOT EXECUTED
8004e14: d0 02 00 00 wcsr IE,r2 <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
8004e18: 29 62 00 b8 lw r2,(r11+184) <== NOT EXECUTED
8004e1c: 38 42 00 20 ori r2,r2,0x20 <== NOT EXECUTED
8004e20: 59 62 00 b8 sw (r11+184),r2 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
8004e24: 34 02 00 01 mvi r2,1 <== NOT EXECUTED
8004e28: 59 62 00 94 sw (r11+148),r2 <== NOT EXECUTED
rtems_interrupt_enable(level);
8004e2c: d0 01 00 00 wcsr IE,r1 <== NOT EXECUTED
nToSend = 0;
8004e30: 34 0c 00 00 mvi r12,0 <== NOT EXECUTED
8004e34: e0 00 00 13 bi 8004e80 <rtems_termios_refill_transmitter+0x1e4><== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
8004e38: 29 61 00 80 lw r1,(r11+128)
8004e3c: 50 2d 00 03 bgeu r1,r13,8004e48 <rtems_termios_refill_transmitter+0x1ac>
nToSend = tty->rawOutBuf.Size - newTail;
8004e40: 29 6c 00 88 lw r12,(r11+136)
8004e44: e0 00 00 02 bi 8004e4c <rtems_termios_refill_transmitter+0x1b0>
else
nToSend = tty->rawOutBuf.Head - newTail;
8004e48: 29 6c 00 80 lw r12,(r11+128)
/* 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)) {
8004e4c: 29 61 00 b8 lw r1,(r11+184)
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
8004e50: c9 8d 60 00 sub r12,r12,r13
/* 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)) {
8004e54: 20 21 06 00 andi r1,r1,0x600
8004e58: 44 20 00 02 be r1,r0,8004e60 <rtems_termios_refill_transmitter+0x1c4>
nToSend = 1;
8004e5c: 34 0c 00 01 mvi r12,1
}
tty->rawOutBufState = rob_busy; /*apm*/
8004e60: 34 01 00 01 mvi r1,1
(*tty->device.write)(
8004e64: 29 62 00 7c lw r2,(r11+124)
/* 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;
}
tty->rawOutBufState = rob_busy; /*apm*/
8004e68: 59 61 00 94 sw (r11+148),r1
(*tty->device.write)(
8004e6c: 29 64 00 a4 lw r4,(r11+164)
8004e70: 29 61 00 10 lw r1,(r11+16)
8004e74: b4 4d 10 00 add r2,r2,r13
8004e78: b9 80 18 00 mv r3,r12
8004e7c: d8 80 00 00 call r4
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
8004e80: 59 6d 00 84 sw (r11+132),r13
}
return nToSend;
}
8004e84: b9 80 08 00 mv r1,r12
8004e88: 2b 9d 00 04 lw ra,(sp+4)
8004e8c: 2b 8b 00 10 lw r11,(sp+16)
8004e90: 2b 8c 00 0c lw r12,(sp+12)
8004e94: 2b 8d 00 08 lw r13,(sp+8)
8004e98: 37 9c 00 10 addi sp,sp,16
8004e9c: c3 a0 00 00 ret
08004c20 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
8004c20: 37 9c ff e4 addi sp,sp,-28
8004c24: 5b 8b 00 14 sw (sp+20),r11
8004c28: 5b 8c 00 10 sw (sp+16),r12
8004c2c: 5b 8d 00 0c sw (sp+12),r13
8004c30: 5b 8e 00 08 sw (sp+8),r14
8004c34: 5b 9d 00 04 sw (sp+4),ra
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
if (c != EOF) {
8004c38: 34 0d ff ff mvi r13,-1
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
8004c3c: b8 20 58 00 mv r11,r1
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
8004c40: 37 8e 00 18 addi r14,sp,24
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
8004c44: 37 8c 00 1f addi r12,sp,31
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
8004c48: 34 01 00 03 mvi r1,3
8004c4c: 34 02 00 02 mvi r2,2
8004c50: 34 03 00 00 mvi r3,0
8004c54: b9 c0 20 00 mv r4,r14
8004c58: f8 00 01 cb calli 8005384 <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) {
8004c5c: 2b 81 00 18 lw r1,(sp+24)
8004c60: 20 21 00 01 andi r1,r1,0x1
8004c64: 44 20 00 04 be r1,r0,8004c74 <rtems_termios_rxdaemon+0x54> <== ALWAYS TAKEN
tty->rxTaskId = 0;
8004c68: 59 60 00 c4 sw (r11+196),r0 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
8004c6c: 34 01 00 00 mvi r1,0 <== NOT EXECUTED
8004c70: f8 00 04 5a calli 8005dd8 <rtems_task_delete> <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
8004c74: 29 62 00 a0 lw r2,(r11+160)
8004c78: 29 61 00 10 lw r1,(r11+16)
8004c7c: d8 40 00 00 call r2
if (c != EOF) {
8004c80: 44 2d ff f2 be r1,r13,8004c48 <rtems_termios_rxdaemon+0x28>
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
8004c84: 33 81 00 1f sb (sp+31),r1
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
8004c88: b9 80 10 00 mv r2,r12
8004c8c: b9 60 08 00 mv r1,r11
8004c90: 34 03 00 01 mvi r3,1
8004c94: fb ff ff 1a calli 80048fc <rtems_termios_enqueue_raw_characters>
8004c98: e3 ff ff ec bi 8004c48 <rtems_termios_rxdaemon+0x28>
08004ea0 <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
8004ea0: 37 9c ff f0 addi sp,sp,-16
8004ea4: 5b 8b 00 0c sw (sp+12),r11
8004ea8: 5b 8c 00 08 sw (sp+8),r12
8004eac: 5b 9d 00 04 sw (sp+4),ra
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
8004eb0: 78 0c 08 02 mvhi r12,0x802
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
8004eb4: b8 20 58 00 mv r11,r1
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
8004eb8: 39 8c 57 a4 ori r12,r12,0x57a4
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
8004ebc: 34 01 00 03 mvi r1,3
8004ec0: 34 02 00 02 mvi r2,2
8004ec4: 34 03 00 00 mvi r3,0
8004ec8: 37 84 00 10 addi r4,sp,16
8004ecc: f8 00 01 2e calli 8005384 <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) {
8004ed0: 2b 81 00 10 lw r1,(sp+16)
8004ed4: 20 21 00 01 andi r1,r1,0x1
8004ed8: 44 20 00 04 be r1,r0,8004ee8 <rtems_termios_txdaemon+0x48> <== ALWAYS TAKEN
tty->txTaskId = 0;
8004edc: 59 60 00 c8 sw (r11+200),r0 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
8004ee0: 34 01 00 00 mvi r1,0 <== NOT EXECUTED
8004ee4: f8 00 03 bd calli 8005dd8 <rtems_task_delete> <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
8004ee8: 29 61 00 cc lw r1,(r11+204)
8004eec: 34 02 00 05 mvi r2,5
8004ef0: fb ff ee a8 calli 8000990 <__ashlsi3>
8004ef4: b5 81 08 00 add r1,r12,r1
8004ef8: 28 22 00 14 lw r2,(r1+20)
8004efc: 44 40 00 03 be r2,r0,8004f08 <rtems_termios_txdaemon+0x68> <== ALWAYS TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
8004f00: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
8004f04: d8 40 00 00 call r2 <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
8004f08: b9 60 08 00 mv r1,r11
8004f0c: fb ff ff 64 calli 8004c9c <rtems_termios_refill_transmitter>
}
8004f10: e3 ff ff eb bi 8004ebc <rtems_termios_txdaemon+0x1c>
0800449c <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
800449c: 37 9c ff e8 addi sp,sp,-24
80044a0: 5b 8b 00 18 sw (sp+24),r11
80044a4: 5b 8c 00 14 sw (sp+20),r12
80044a8: 5b 8d 00 10 sw (sp+16),r13
80044ac: 5b 8e 00 0c sw (sp+12),r14
80044b0: 5b 8f 00 08 sw (sp+8),r15
80044b4: 5b 9d 00 04 sw (sp+4),ra
80044b8: b8 20 58 00 mv r11,r1
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
80044bc: 28 21 00 00 lw r1,(r1+0)
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
80044c0: 34 02 00 00 mvi r2,0
80044c4: 34 03 00 00 mvi r3,0
rtems_status_code
rtems_termios_write (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
80044c8: 28 2c 00 38 lw r12,(r1+56)
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
80044cc: 29 81 00 18 lw r1,(r12+24)
80044d0: f8 00 05 5d calli 8005a44 <rtems_semaphore_obtain>
80044d4: b8 20 68 00 mv r13,r1
if (sc != RTEMS_SUCCESSFUL)
80044d8: 5c 20 00 23 bne r1,r0,8004564 <rtems_termios_write+0xc8> <== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
80044dc: 29 81 00 cc lw r1,(r12+204)
80044e0: 78 0e 08 02 mvhi r14,0x802
80044e4: 34 02 00 05 mvi r2,5
80044e8: fb ff f1 2a calli 8000990 <__ashlsi3>
80044ec: 39 ce 57 a4 ori r14,r14,0x57a4
80044f0: b5 c1 08 00 add r1,r14,r1
80044f4: 28 23 00 0c lw r3,(r1+12)
80044f8: 44 6d 00 06 be r3,r13,8004510 <rtems_termios_write+0x74>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
80044fc: b9 80 08 00 mv r1,r12
8004500: b9 60 10 00 mv r2,r11
8004504: d8 60 00 00 call r3
8004508: b8 20 68 00 mv r13,r1
800450c: e0 00 00 14 bi 800455c <rtems_termios_write+0xc0>
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
8004510: 29 83 00 34 lw r3,(r12+52)
8004514: 29 62 00 14 lw r2,(r11+20)
8004518: 29 61 00 10 lw r1,(r11+16)
800451c: 20 63 00 01 andi r3,r3,0x1
uint32_t count = args->count;
8004520: b8 40 78 00 mv r15,r2
char *buffer = args->buffer;
8004524: b8 20 70 00 mv r14,r1
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) {
8004528: 5c 60 00 07 bne r3,r0,8004544 <rtems_termios_write+0xa8> <== ALWAYS TAKEN
800452c: e0 00 00 08 bi 800454c <rtems_termios_write+0xb0> <== NOT EXECUTED
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
8004530: 41 c1 00 00 lbu r1,(r14+0)
8004534: b9 80 10 00 mv r2,r12
8004538: 35 ce 00 01 addi r14,r14,1
800453c: fb ff fe 4b calli 8003e68 <oproc>
8004540: 35 ef ff ff addi r15,r15,-1
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
8004544: 5d e0 ff fb bne r15,r0,8004530 <rtems_termios_write+0x94>
8004548: e0 00 00 03 bi 8004554 <rtems_termios_write+0xb8>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
800454c: b9 80 18 00 mv r3,r12 <== NOT EXECUTED
8004550: fb ff fd f0 calli 8003d10 <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
8004554: 29 61 00 14 lw r1,(r11+20)
8004558: 59 61 00 1c sw (r11+28),r1
}
rtems_semaphore_release (tty->osem);
800455c: 29 81 00 18 lw r1,(r12+24)
8004560: f8 00 05 89 calli 8005b84 <rtems_semaphore_release>
return sc;
}
8004564: b9 a0 08 00 mv r1,r13
8004568: 2b 9d 00 04 lw ra,(sp+4)
800456c: 2b 8b 00 18 lw r11,(sp+24)
8004570: 2b 8c 00 14 lw r12,(sp+20)
8004574: 2b 8d 00 10 lw r13,(sp+16)
8004578: 2b 8e 00 0c lw r14,(sp+12)
800457c: 2b 8f 00 08 lw r15,(sp+8)
8004580: 37 9c 00 18 addi sp,sp,24
8004584: c3 a0 00 00 ret
08013f48 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
8013f48: 37 9c ff f8 addi sp,sp,-8
8013f4c: 5b 9d 00 04 sw (sp+4),ra
8013f50: b8 20 10 00 mv r2,r1
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
8013f54: 78 01 08 04 mvhi r1,0x804
8013f58: 38 21 15 f4 ori r1,r1,0x15f4
8013f5c: 37 83 00 08 addi r3,sp,8
8013f60: f8 00 0e 98 calli 80179c0 <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
8013f64: 2b 82 00 08 lw r2,(sp+8)
8013f68: 5c 40 00 09 bne r2,r0,8013f8c <rtems_timer_cancel+0x44>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
8013f6c: 28 23 00 38 lw r3,(r1+56)
8013f70: 34 02 00 04 mvi r2,4
8013f74: 44 62 00 03 be r3,r2,8013f80 <rtems_timer_cancel+0x38> <== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
8013f78: 34 21 00 10 addi r1,r1,16
8013f7c: f8 00 18 62 calli 801a104 <_Watchdog_Remove>
_Thread_Enable_dispatch();
8013f80: f8 00 12 bd calli 8018a74 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8013f84: 34 01 00 00 mvi r1,0
8013f88: e0 00 00 02 bi 8013f90 <rtems_timer_cancel+0x48>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8013f8c: 34 01 00 04 mvi r1,4
}
8013f90: 2b 9d 00 04 lw ra,(sp+4)
8013f94: 37 9c 00 08 addi sp,sp,8
8013f98: c3 a0 00 00 ret
08003388 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
8003388: 37 9c ff e8 addi sp,sp,-24
800338c: 5b 8b 00 18 sw (sp+24),r11
8003390: 5b 8c 00 14 sw (sp+20),r12
8003394: 5b 8d 00 10 sw (sp+16),r13
8003398: 5b 8e 00 0c sw (sp+12),r14
800339c: 5b 8f 00 08 sw (sp+8),r15
80033a0: 5b 9d 00 04 sw (sp+4),ra
80033a4: b8 20 78 00 mv r15,r1
80033a8: b8 40 68 00 mv r13,r2
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
80033ac: 34 01 00 03 mvi r1,3
rtems_id *id
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
80033b0: 45 e0 00 22 be r15,r0,8003438 <rtems_timer_create+0xb0> <== NEVER TAKEN
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
80033b4: 34 01 00 09 mvi r1,9
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
80033b8: 44 40 00 20 be r2,r0,8003438 <rtems_timer_create+0xb0> <== NEVER TAKEN
80033bc: 78 03 08 01 mvhi r3,0x801
80033c0: 38 63 f9 00 ori r3,r3,0xf900
80033c4: 28 61 00 00 lw r1,(r3+0)
80033c8: 34 21 00 01 addi r1,r1,1
80033cc: 58 61 00 00 sw (r3+0),r1
* This function allocates a timer control block from
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Allocate( void )
{
return (Timer_Control *) _Objects_Allocate( &_Timer_Information );
80033d0: 78 0c 08 02 mvhi r12,0x802
80033d4: 39 8c 01 98 ori r12,r12,0x198
80033d8: b9 80 08 00 mv r1,r12
80033dc: f8 00 04 9b calli 8004648 <_Objects_Allocate>
80033e0: b8 20 58 00 mv r11,r1
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
80033e4: 5c 20 00 04 bne r1,r0,80033f4 <rtems_timer_create+0x6c>
_Thread_Enable_dispatch();
80033e8: f8 00 09 80 calli 80059e8 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
80033ec: 34 01 00 05 mvi r1,5
80033f0: e0 00 00 12 bi 8003438 <rtems_timer_create+0xb0>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
80033f4: 29 6e 00 08 lw r14,(r11+8)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
80033f8: 29 8c 00 1c lw r12,(r12+28)
}
the_timer->the_class = TIMER_DORMANT;
80033fc: 34 01 00 04 mvi r1,4
8003400: 59 61 00 38 sw (r11+56),r1
8003404: 34 02 00 02 mvi r2,2
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
8003408: 59 60 00 18 sw (r11+24),r0
the_watchdog->routine = routine;
800340c: 59 60 00 2c sw (r11+44),r0
the_watchdog->id = id;
8003410: 59 60 00 30 sw (r11+48),r0
the_watchdog->user_data = user_data;
8003414: 59 60 00 34 sw (r11+52),r0
8003418: 21 c1 ff ff andi r1,r14,0xffff
800341c: f8 00 5e b4 calli 801aeec <__ashlsi3>
8003420: b5 81 08 00 add r1,r12,r1
8003424: 58 2b 00 00 sw (r1+0),r11
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
8003428: 59 6f 00 0c sw (r11+12),r15
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
800342c: 59 ae 00 00 sw (r13+0),r14
_Thread_Enable_dispatch();
8003430: f8 00 09 6e calli 80059e8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8003434: 34 01 00 00 mvi r1,0
}
8003438: 2b 9d 00 04 lw ra,(sp+4)
800343c: 2b 8b 00 18 lw r11,(sp+24)
8003440: 2b 8c 00 14 lw r12,(sp+20)
8003444: 2b 8d 00 10 lw r13,(sp+16)
8003448: 2b 8e 00 0c lw r14,(sp+12)
800344c: 2b 8f 00 08 lw r15,(sp+8)
8003450: 37 9c 00 18 addi sp,sp,24
8003454: c3 a0 00 00 ret
08014564 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
8014564: 37 9c ff dc addi sp,sp,-36
8014568: 5b 8b 00 20 sw (sp+32),r11
801456c: 5b 8c 00 1c sw (sp+28),r12
8014570: 5b 8d 00 18 sw (sp+24),r13
8014574: 5b 8e 00 14 sw (sp+20),r14
8014578: 5b 8f 00 10 sw (sp+16),r15
801457c: 5b 90 00 0c sw (sp+12),r16
8014580: 5b 91 00 08 sw (sp+8),r17
8014584: 5b 9d 00 04 sw (sp+4),ra
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
8014588: 78 05 08 04 mvhi r5,0x804
801458c: 38 a5 16 34 ori r5,r5,0x1634
8014590: 28 ad 00 00 lw r13,(r5+0)
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
8014594: b8 20 78 00 mv r15,r1
8014598: b8 40 60 00 mv r12,r2
801459c: b8 60 80 00 mv r16,r3
80145a0: b8 80 88 00 mv r17,r4
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
80145a4: 34 0b 00 0e mvi r11,14
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
80145a8: 45 a0 00 2e be r13,r0,8014660 <rtems_timer_server_fire_when+0xfc>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
80145ac: 78 05 08 04 mvhi r5,0x804
80145b0: 38 a5 0d 20 ori r5,r5,0xd20
80145b4: 40 a1 00 00 lbu r1,(r5+0)
return RTEMS_NOT_DEFINED;
80145b8: 34 0b 00 0b mvi r11,11
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
80145bc: 44 20 00 29 be r1,r0,8014660 <rtems_timer_server_fire_when+0xfc><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
80145c0: 34 0b 00 09 mvi r11,9
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
80145c4: 44 60 00 27 be r3,r0,8014660 <rtems_timer_server_fire_when+0xfc>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
80145c8: b8 40 08 00 mv r1,r2
80145cc: fb ff f1 c0 calli 8010ccc <_TOD_Validate>
return RTEMS_INVALID_CLOCK;
80145d0: 34 0b 00 14 mvi r11,20
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
80145d4: 44 20 00 23 be r1,r0,8014660 <rtems_timer_server_fire_when+0xfc>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
80145d8: b9 80 08 00 mv r1,r12
if ( seconds <= _TOD_Seconds_since_epoch() )
80145dc: 78 0c 08 04 mvhi r12,0x804
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
80145e0: fb ff f1 7b calli 8010bcc <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
80145e4: 39 8c 0d 98 ori r12,r12,0xd98
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
80145e8: b8 20 70 00 mv r14,r1
if ( seconds <= _TOD_Seconds_since_epoch() )
80145ec: 29 81 00 00 lw r1,(r12+0)
80145f0: 50 2e 00 1c bgeu r1,r14,8014660 <rtems_timer_server_fire_when+0xfc>
80145f4: 78 01 08 04 mvhi r1,0x804
80145f8: 38 21 15 f4 ori r1,r1,0x15f4
80145fc: b9 e0 10 00 mv r2,r15
8014600: 37 83 00 24 addi r3,sp,36
8014604: f8 00 0c ef calli 80179c0 <_Objects_Get>
8014608: b8 20 58 00 mv r11,r1
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
801460c: 2b 81 00 24 lw r1,(sp+36)
8014610: 5c 20 00 13 bne r1,r0,801465c <rtems_timer_server_fire_when+0xf8>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
8014614: 35 61 00 10 addi r1,r11,16
8014618: f8 00 16 bb calli 801a104 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
801461c: 34 01 00 03 mvi r1,3
8014620: 59 61 00 38 sw (r11+56),r1
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
8014624: 29 81 00 00 lw r1,(r12+0)
(*timer_server->schedule_operation)( timer_server, the_timer );
8014628: 29 a3 00 04 lw r3,(r13+4)
801462c: b9 60 10 00 mv r2,r11
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
8014630: c9 c1 70 00 sub r14,r14,r1
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
8014634: 59 60 00 18 sw (r11+24),r0
the_watchdog->routine = routine;
8014638: 59 70 00 2c sw (r11+44),r16
the_watchdog->id = id;
801463c: 59 6f 00 30 sw (r11+48),r15
the_watchdog->user_data = user_data;
8014640: 59 71 00 34 sw (r11+52),r17
8014644: 59 6e 00 1c sw (r11+28),r14
(*timer_server->schedule_operation)( timer_server, the_timer );
8014648: b9 a0 08 00 mv r1,r13
801464c: d8 60 00 00 call r3
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
8014650: 34 0b 00 00 mvi r11,0
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
(*timer_server->schedule_operation)( timer_server, the_timer );
_Thread_Enable_dispatch();
8014654: f8 00 11 08 calli 8018a74 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8014658: e0 00 00 02 bi 8014660 <rtems_timer_server_fire_when+0xfc>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
801465c: 34 0b 00 04 mvi r11,4
}
8014660: b9 60 08 00 mv r1,r11
8014664: 2b 9d 00 04 lw ra,(sp+4)
8014668: 2b 8b 00 20 lw r11,(sp+32)
801466c: 2b 8c 00 1c lw r12,(sp+28)
8014670: 2b 8d 00 18 lw r13,(sp+24)
8014674: 2b 8e 00 14 lw r14,(sp+20)
8014678: 2b 8f 00 10 lw r15,(sp+16)
801467c: 2b 90 00 0c lw r16,(sp+12)
8014680: 2b 91 00 08 lw r17,(sp+8)
8014684: 37 9c 00 24 addi sp,sp,36
8014688: c3 a0 00 00 ret
080069f4 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
80069f4: 37 9c ff e4 addi sp,sp,-28
80069f8: 5b 8b 00 1c sw (sp+28),r11
80069fc: 5b 8c 00 18 sw (sp+24),r12
8006a00: 5b 8d 00 14 sw (sp+20),r13
8006a04: 5b 8e 00 10 sw (sp+16),r14
8006a08: 5b 8f 00 0c sw (sp+12),r15
8006a0c: 5b 90 00 08 sw (sp+8),r16
8006a10: 5b 9d 00 04 sw (sp+4),ra
8006a14: b8 20 60 00 mv r12,r1
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
8006a18: 78 01 20 00 mvhi r1,0x2000
8006a1c: a1 81 08 00 and r1,r12,r1
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
8006a20: b8 40 80 00 mv r16,r2
8006a24: b8 60 78 00 mv r15,r3
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
8006a28: 44 20 00 12 be r1,r0,8006a70 <rtems_verror+0x7c>
if (rtems_panic_in_progress++)
8006a2c: 78 04 08 02 mvhi r4,0x802
8006a30: 38 84 99 04 ori r4,r4,0x9904
8006a34: 28 81 00 00 lw r1,(r4+0)
8006a38: 34 22 00 01 addi r2,r1,1
8006a3c: 58 82 00 00 sw (r4+0),r2
8006a40: 44 20 00 06 be r1,r0,8006a58 <rtems_verror+0x64> <== ALWAYS TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
8006a44: 78 04 08 02 mvhi r4,0x802 <== NOT EXECUTED
8006a48: 38 84 9a 80 ori r4,r4,0x9a80 <== NOT EXECUTED
8006a4c: 28 81 00 00 lw r1,(r4+0) <== NOT EXECUTED
8006a50: 34 21 00 01 addi r1,r1,1 <== NOT EXECUTED
8006a54: 58 81 00 00 sw (r4+0),r1 <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
8006a58: 78 01 08 02 mvhi r1,0x802
8006a5c: 38 21 99 04 ori r1,r1,0x9904
8006a60: 28 22 00 00 lw r2,(r1+0)
8006a64: 34 01 00 02 mvi r1,2
return 0;
8006a68: 34 0b 00 00 mvi r11,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)
8006a6c: 48 41 00 48 bg r2,r1,8006b8c <rtems_verror+0x198> <== NEVER TAKEN
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
8006a70: 78 01 08 02 mvhi r1,0x802
8006a74: 38 21 92 60 ori r1,r1,0x9260
8006a78: 28 21 00 00 lw r1,(r1+0)
8006a7c: 28 21 00 08 lw r1,(r1+8)
8006a80: f8 00 32 64 calli 8013410 <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
8006a84: 78 01 08 02 mvhi r1,0x802
8006a88: 38 21 71 98 ori r1,r1,0x7198
8006a8c: 28 2e 00 00 lw r14,(r1+0)
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
8006a90: 78 01 40 00 mvhi r1,0x4000
8006a94: a1 81 08 00 and r1,r12,r1
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
8006a98: a1 8e 70 00 and r14,r12,r14
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
8006a9c: 34 0c 00 00 mvi r12,0
}
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
8006aa0: 44 20 00 03 be r1,r0,8006aac <rtems_verror+0xb8>
local_errno = errno;
8006aa4: f8 00 31 5a calli 801300c <__errno>
8006aa8: 28 2c 00 00 lw r12,(r1+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);
8006aac: 78 0d 08 02 mvhi r13,0x802
8006ab0: 39 ad 92 60 ori r13,r13,0x9260
8006ab4: 29 a1 00 00 lw r1,(r13+0)
8006ab8: ba 00 10 00 mv r2,r16
8006abc: b9 e0 18 00 mv r3,r15
8006ac0: 28 21 00 0c lw r1,(r1+12)
8006ac4: f8 00 4b 42 calli 80197cc <vfprintf>
8006ac8: b8 20 58 00 mv r11,r1
if (status)
8006acc: 45 c0 00 0b be r14,r0,8006af8 <rtems_verror+0x104>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
8006ad0: 29 a1 00 00 lw r1,(r13+0)
8006ad4: 28 2d 00 0c lw r13,(r1+12)
8006ad8: b9 c0 08 00 mv r1,r14
8006adc: fb ff ff bd calli 80069d0 <rtems_status_text>
8006ae0: 78 02 08 02 mvhi r2,0x802
8006ae4: b8 20 18 00 mv r3,r1
8006ae8: 38 42 6e 54 ori r2,r2,0x6e54
8006aec: b9 a0 08 00 mv r1,r13
8006af0: f8 00 33 80 calli 80138f0 <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
8006af4: b5 61 58 00 add r11,r11,r1
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
8006af8: 45 80 00 1a be r12,r0,8006b60 <rtems_verror+0x16c>
if ((local_errno > 0) && *strerror(local_errno))
8006afc: 4c 0c 00 10 bge r0,r12,8006b3c <rtems_verror+0x148>
8006b00: b9 80 08 00 mv r1,r12
8006b04: f8 00 37 1b calli 8014770 <strerror>
8006b08: 40 21 00 00 lbu r1,(r1+0)
8006b0c: 44 20 00 0c be r1,r0,8006b3c <rtems_verror+0x148> <== NEVER TAKEN
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
8006b10: 78 01 08 02 mvhi r1,0x802
8006b14: 38 21 92 60 ori r1,r1,0x9260
8006b18: 28 21 00 00 lw r1,(r1+0)
8006b1c: 28 2d 00 0c lw r13,(r1+12)
8006b20: b9 80 08 00 mv r1,r12
8006b24: f8 00 37 13 calli 8014770 <strerror>
8006b28: 78 02 08 02 mvhi r2,0x802
8006b2c: b8 20 18 00 mv r3,r1
8006b30: 38 42 6e 64 ori r2,r2,0x6e64
8006b34: b9 a0 08 00 mv r1,r13
8006b38: e0 00 00 08 bi 8006b58 <rtems_verror+0x164>
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
8006b3c: 78 01 08 02 mvhi r1,0x802
8006b40: 38 21 92 60 ori r1,r1,0x9260
8006b44: 28 21 00 00 lw r1,(r1+0)
8006b48: 78 02 08 02 mvhi r2,0x802
8006b4c: 38 42 6e 74 ori r2,r2,0x6e74
8006b50: 28 21 00 0c lw r1,(r1+12)
8006b54: b9 80 18 00 mv r3,r12
8006b58: f8 00 33 66 calli 80138f0 <fprintf>
8006b5c: b5 61 58 00 add r11,r11,r1
}
chars_written += fprintf(stderr, "\n");
8006b60: 78 0c 08 02 mvhi r12,0x802
8006b64: 39 8c 92 60 ori r12,r12,0x9260
8006b68: 29 81 00 00 lw r1,(r12+0)
8006b6c: 78 02 08 02 mvhi r2,0x802
8006b70: 38 42 65 c8 ori r2,r2,0x65c8
8006b74: 28 21 00 0c lw r1,(r1+12)
8006b78: f8 00 33 5e calli 80138f0 <fprintf>
8006b7c: b4 2b 58 00 add r11,r1,r11
(void) fflush(stderr);
8006b80: 29 81 00 00 lw r1,(r12+0)
8006b84: 28 21 00 0c lw r1,(r1+12)
8006b88: f8 00 32 22 calli 8013410 <fflush>
return chars_written;
}
8006b8c: b9 60 08 00 mv r1,r11
8006b90: 2b 9d 00 04 lw ra,(sp+4)
8006b94: 2b 8b 00 1c lw r11,(sp+28)
8006b98: 2b 8c 00 18 lw r12,(sp+24)
8006b9c: 2b 8d 00 14 lw r13,(sp+20)
8006ba0: 2b 8e 00 10 lw r14,(sp+16)
8006ba4: 2b 8f 00 0c lw r15,(sp+12)
8006ba8: 2b 90 00 08 lw r16,(sp+8)
8006bac: 37 9c 00 1c addi sp,sp,28
8006bb0: c3 a0 00 00 ret
08001b04 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
8001b04: 37 9c ff d4 addi sp,sp,-44
8001b08: 5b 8b 00 2c sw (sp+44),r11
8001b0c: 5b 8c 00 28 sw (sp+40),r12
8001b10: 5b 8d 00 24 sw (sp+36),r13
8001b14: 5b 8e 00 20 sw (sp+32),r14
8001b18: 5b 8f 00 1c sw (sp+28),r15
8001b1c: 5b 90 00 18 sw (sp+24),r16
8001b20: 5b 91 00 14 sw (sp+20),r17
8001b24: 5b 92 00 10 sw (sp+16),r18
8001b28: 5b 93 00 0c sw (sp+12),r19
8001b2c: 5b 94 00 08 sw (sp+8),r20
8001b30: 5b 9d 00 04 sw (sp+4),ra
8001b34: b8 20 58 00 mv r11,r1
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
8001b38: 78 01 08 01 mvhi r1,0x801
8001b3c: 38 21 4b 04 ori r1,r1,0x4b04
8001b40: 28 2e 00 00 lw r14,(r1+0)
int sign = 0;
int d;
for (;;) {
c = getc(fp);
8001b44: 78 11 08 01 mvhi r17,0x801
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
8001b48: 78 10 08 01 mvhi r16,0x801
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
8001b4c: b8 40 90 00 mv r18,r2
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
int sign = 0;
8001b50: 34 0d 00 00 mvi r13,0
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
8001b54: 34 0c 00 00 mvi r12,0
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
8001b58: 3a 31 61 f0 ori r17,r17,0x61f0
if (c == ':')
8001b5c: 34 14 00 3a mvi r20,58
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
8001b60: 3a 10 61 e8 ori r16,r16,0x61e8
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
8001b64: 34 13 00 2d mvi r19,45
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
8001b68: 29 61 00 04 lw r1,(r11+4)
8001b6c: 34 21 ff ff addi r1,r1,-1
8001b70: 59 61 00 04 sw (r11+4),r1
8001b74: 4c 20 00 06 bge r1,r0,8001b8c <scanInt+0x88> <== ALWAYS TAKEN
8001b78: 2a 21 00 00 lw r1,(r17+0) <== NOT EXECUTED
8001b7c: b9 60 10 00 mv r2,r11 <== NOT EXECUTED
8001b80: f8 00 37 1a calli 800f7e8 <__srget_r> <== NOT EXECUTED
8001b84: b8 20 78 00 mv r15,r1 <== NOT EXECUTED
8001b88: e0 00 00 05 bi 8001b9c <scanInt+0x98> <== NOT EXECUTED
8001b8c: 29 61 00 00 lw r1,(r11+0)
8001b90: 40 2f 00 00 lbu r15,(r1+0)
8001b94: 34 21 00 01 addi r1,r1,1
8001b98: 59 61 00 00 sw (r11+0),r1
if (c == ':')
8001b9c: 45 f4 00 1f be r15,r20,8001c18 <scanInt+0x114>
break;
if (sign == 0) {
8001ba0: 5d a0 00 06 bne r13,r0,8001bb8 <scanInt+0xb4>
if (c == '-') {
sign = -1;
limit++;
continue;
}
sign = 1;
8001ba4: 34 0d 00 01 mvi r13,1
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
8001ba8: 5d f3 00 04 bne r15,r19,8001bb8 <scanInt+0xb4>
sign = -1;
limit++;
8001bac: 35 ce 00 01 addi r14,r14,1
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
8001bb0: 34 0d ff ff mvi r13,-1
limit++;
continue;
8001bb4: e3 ff ff ed bi 8001b68 <scanInt+0x64>
}
sign = 1;
}
if (!isdigit(c))
8001bb8: 2a 01 00 00 lw r1,(r16+0)
8001bbc: b4 2f 08 00 add r1,r1,r15
8001bc0: 40 21 00 01 lbu r1,(r1+1)
8001bc4: 20 21 00 04 andi r1,r1,0x4
8001bc8: 44 20 00 1c be r1,r0,8001c38 <scanInt+0x134>
return 0;
d = c - '0';
if ((i > (limit / 10))
8001bcc: b9 c0 08 00 mv r1,r14
8001bd0: 34 02 00 0a mvi r2,10
8001bd4: f8 00 47 65 calli 8013968 <__udivsi3>
8001bd8: 55 81 00 18 bgu r12,r1,8001c38 <scanInt+0x134>
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
8001bdc: 35 ef ff d0 addi r15,r15,-48
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
8001be0: 5d 81 00 05 bne r12,r1,8001bf4 <scanInt+0xf0>
8001be4: b9 c0 08 00 mv r1,r14
8001be8: 34 02 00 0a mvi r2,10
8001bec: f8 00 47 6f calli 80139a8 <__umodsi3>
8001bf0: 55 e1 00 12 bgu r15,r1,8001c38 <scanInt+0x134> <== ALWAYS TAKEN
return 0;
i = i * 10 + d;
8001bf4: b9 80 08 00 mv r1,r12
8001bf8: 34 02 00 01 mvi r2,1
8001bfc: f8 00 46 81 calli 8013600 <__ashlsi3>
8001c00: 34 02 00 02 mvi r2,2
8001c04: b8 20 60 00 mv r12,r1
8001c08: f8 00 46 7e calli 8013600 <__ashlsi3>
8001c0c: b5 81 08 00 add r1,r12,r1
8001c10: b5 e1 60 00 add r12,r15,r1
8001c14: e3 ff ff d5 bi 8001b68 <scanInt+0x64>
}
if (sign == 0)
return 0;
8001c18: 34 03 00 00 mvi r3,0
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
8001c1c: 45 a0 00 08 be r13,r0,8001c3c <scanInt+0x138> <== NEVER TAKEN
return 0;
*val = i * sign;
8001c20: b9 a0 08 00 mv r1,r13
8001c24: b9 80 10 00 mv r2,r12
8001c28: f8 00 46 eb calli 80137d4 <__mulsi3>
8001c2c: 5a 41 00 00 sw (r18+0),r1
return 1;
8001c30: 34 03 00 01 mvi r3,1
8001c34: e0 00 00 02 bi 8001c3c <scanInt+0x138>
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
8001c38: 34 03 00 00 mvi r3,0
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
8001c3c: b8 60 08 00 mv r1,r3
8001c40: 2b 9d 00 04 lw ra,(sp+4)
8001c44: 2b 8b 00 2c lw r11,(sp+44)
8001c48: 2b 8c 00 28 lw r12,(sp+40)
8001c4c: 2b 8d 00 24 lw r13,(sp+36)
8001c50: 2b 8e 00 20 lw r14,(sp+32)
8001c54: 2b 8f 00 1c lw r15,(sp+28)
8001c58: 2b 90 00 18 lw r16,(sp+24)
8001c5c: 2b 91 00 14 lw r17,(sp+20)
8001c60: 2b 92 00 10 lw r18,(sp+16)
8001c64: 2b 93 00 0c lw r19,(sp+12)
8001c68: 2b 94 00 08 lw r20,(sp+8)
8001c6c: 37 9c 00 2c addi sp,sp,44
8001c70: c3 a0 00 00 ret
08001dac <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
8001dac: 37 9c ff d8 addi sp,sp,-40
8001db0: 5b 8b 00 18 sw (sp+24),r11
8001db4: 5b 8c 00 14 sw (sp+20),r12
8001db8: 5b 8d 00 10 sw (sp+16),r13
8001dbc: 5b 8e 00 0c sw (sp+12),r14
8001dc0: 5b 8f 00 08 sw (sp+8),r15
8001dc4: 5b 9d 00 04 sw (sp+4),ra
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
8001dc8: 37 8e 00 20 addi r14,sp,32
8001dcc: 37 8d 00 1c addi r13,sp,28
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
8001dd0: 5b 83 00 20 sw (sp+32),r3
8001dd4: 5b 84 00 1c sw (sp+28),r4
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
8001dd8: b9 c0 18 00 mv r3,r14
8001ddc: b9 a0 20 00 mv r4,r13
8001de0: 34 05 00 00 mvi r5,0
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
8001de4: b8 20 78 00 mv r15,r1
8001de8: b8 40 58 00 mv r11,r2
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
8001dec: fb ff ff a2 calli 8001c74 <scanString>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
8001df0: 34 0c 00 00 mvi r12,0
{
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
8001df4: 44 20 00 43 be r1,r0,8001f00 <scangr+0x154>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
8001df8: b9 e0 08 00 mv r1,r15
8001dfc: 35 62 00 04 addi r2,r11,4
8001e00: b9 c0 18 00 mv r3,r14
8001e04: b9 a0 20 00 mv r4,r13
8001e08: 34 05 00 00 mvi r5,0
8001e0c: fb ff ff 9a calli 8001c74 <scanString>
8001e10: 44 20 00 3c be r1,r0,8001f00 <scangr+0x154> <== NEVER TAKEN
|| !scanInt(fp, &grgid)
8001e14: b9 e0 08 00 mv r1,r15
8001e18: 37 82 00 28 addi r2,sp,40
8001e1c: fb ff ff 3a calli 8001b04 <scanInt>
8001e20: 44 20 00 38 be r1,r0,8001f00 <scangr+0x154> <== NEVER TAKEN
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
8001e24: b9 e0 08 00 mv r1,r15
8001e28: 37 82 00 24 addi r2,sp,36
8001e2c: b9 c0 18 00 mv r3,r14
8001e30: b9 a0 20 00 mv r4,r13
8001e34: 34 05 00 01 mvi r5,1
8001e38: fb ff ff 8f calli 8001c74 <scanString>
8001e3c: 44 20 00 31 be r1,r0,8001f00 <scangr+0x154> <== NEVER TAKEN
return 0;
grp->gr_gid = grgid;
8001e40: 2b 81 00 28 lw r1,(sp+40)
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
8001e44: 2b 8d 00 24 lw r13,(sp+36)
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;
8001e48: 0d 61 00 08 sh (r11+8),r1
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
8001e4c: b9 a0 10 00 mv r2,r13
8001e50: 34 01 00 01 mvi r1,1
8001e54: e0 00 00 04 bi 8001e64 <scangr+0xb8>
if(*cp == ',')
memcount++;
8001e58: 64 63 00 2c cmpei r3,r3,44
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
8001e5c: 34 42 00 01 addi r2,r2,1
if(*cp == ',')
memcount++;
8001e60: b4 23 08 00 add r1,r1,r3
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
8001e64: 40 43 00 00 lbu r3,(r2+0)
8001e68: 5c 60 ff fc bne r3,r0,8001e58 <scangr+0xac>
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
8001e6c: 34 02 00 02 mvi r2,2
8001e70: 34 21 00 01 addi r1,r1,1
8001e74: f8 00 45 e3 calli 8013600 <__ashlsi3>
8001e78: 2b 82 00 1c lw r2,(sp+28)
8001e7c: 34 21 00 0f addi r1,r1,15
return 0;
8001e80: 34 0c 00 00 mvi r12,0
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
8001e84: 54 22 00 1f bgu r1,r2,8001f00 <scangr+0x154> <== NEVER TAKEN
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
8001e88: 2b 81 00 20 lw r1,(sp+32)
8001e8c: 34 02 ff f0 mvi r2,-16
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
if(*cp == ',') {
8001e90: 34 0e 00 2c mvi r14,44
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
8001e94: 34 21 00 0f addi r1,r1,15
8001e98: a0 22 08 00 and r1,r1,r2
8001e9c: 59 61 00 0c sw (r11+12),r1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
8001ea0: 58 2d 00 00 sw (r1+0),r13
}
/*
* Extract a single group record from the database
*/
static int scangr(
8001ea4: 2b 8c 00 24 lw r12,(sp+36)
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
8001ea8: 34 0d 00 01 mvi r13,1
}
/*
* Extract a single group record from the database
*/
static int scangr(
8001eac: 35 8c 00 01 addi r12,r12,1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
8001eb0: e0 00 00 0b bi 8001edc <scangr+0x130>
if(*cp == ',') {
8001eb4: 5c 2e 00 09 bne r1,r14,8001ed8 <scangr+0x12c>
*cp = '\0';
8001eb8: 31 80 ff ff sb (r12+-1),r0
grp->gr_mem[memcount++] = cp + 1;
8001ebc: 29 6f 00 0c lw r15,(r11+12)
8001ec0: b9 a0 08 00 mv r1,r13
8001ec4: 34 02 00 02 mvi r2,2
8001ec8: f8 00 45 ce calli 8013600 <__ashlsi3>
8001ecc: b5 e1 08 00 add r1,r15,r1
8001ed0: 58 2c 00 00 sw (r1+0),r12
8001ed4: 35 ad 00 01 addi r13,r13,1
8001ed8: 35 8c 00 01 addi r12,r12,1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
8001edc: 41 81 ff ff lbu r1,(r12+-1)
8001ee0: 5c 20 ff f5 bne r1,r0,8001eb4 <scangr+0x108>
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
8001ee4: 29 6b 00 0c lw r11,(r11+12)
8001ee8: b9 a0 08 00 mv r1,r13
8001eec: 34 02 00 02 mvi r2,2
8001ef0: f8 00 45 c4 calli 8013600 <__ashlsi3>
8001ef4: b5 61 08 00 add r1,r11,r1
8001ef8: 58 20 00 00 sw (r1+0),r0
return 1;
8001efc: 34 0c 00 01 mvi r12,1
}
8001f00: b9 80 08 00 mv r1,r12
8001f04: 2b 9d 00 04 lw ra,(sp+4)
8001f08: 2b 8b 00 18 lw r11,(sp+24)
8001f0c: 2b 8c 00 14 lw r12,(sp+20)
8001f10: 2b 8d 00 10 lw r13,(sp+16)
8001f14: 2b 8e 00 0c lw r14,(sp+12)
8001f18: 2b 8f 00 08 lw r15,(sp+8)
8001f1c: 37 9c 00 28 addi sp,sp,40
8001f20: c3 a0 00 00 ret
08001f24 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
8001f24: 37 9c ff d8 addi sp,sp,-40
8001f28: 5b 8b 00 18 sw (sp+24),r11
8001f2c: 5b 8c 00 14 sw (sp+20),r12
8001f30: 5b 8d 00 10 sw (sp+16),r13
8001f34: 5b 8e 00 0c sw (sp+12),r14
8001f38: 5b 8f 00 08 sw (sp+8),r15
8001f3c: 5b 9d 00 04 sw (sp+4),ra
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
8001f40: 37 8e 00 20 addi r14,sp,32
8001f44: 37 8d 00 1c addi r13,sp,28
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
8001f48: 5b 83 00 20 sw (sp+32),r3
8001f4c: 5b 84 00 1c sw (sp+28),r4
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
8001f50: b9 c0 18 00 mv r3,r14
8001f54: b9 a0 20 00 mv r4,r13
8001f58: 34 05 00 00 mvi r5,0
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
8001f5c: b8 20 60 00 mv r12,r1
8001f60: b8 40 58 00 mv r11,r2
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
8001f64: fb ff ff 44 calli 8001c74 <scanString>
|| !scanInt(fp, &pwgid)
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
8001f68: 34 0f 00 00 mvi r15,0
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
8001f6c: 44 20 00 31 be r1,r0,8002030 <scanpw+0x10c>
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
8001f70: b9 80 08 00 mv r1,r12
8001f74: 35 62 00 04 addi r2,r11,4
8001f78: b9 c0 18 00 mv r3,r14
8001f7c: b9 a0 20 00 mv r4,r13
8001f80: 34 05 00 00 mvi r5,0
8001f84: fb ff ff 3c calli 8001c74 <scanString>
8001f88: 44 20 00 2a be r1,r0,8002030 <scanpw+0x10c> <== NEVER TAKEN
|| !scanInt(fp, &pwuid)
8001f8c: b9 80 08 00 mv r1,r12
8001f90: 37 82 00 28 addi r2,sp,40
8001f94: fb ff fe dc calli 8001b04 <scanInt>
8001f98: 44 20 00 26 be r1,r0,8002030 <scanpw+0x10c>
|| !scanInt(fp, &pwgid)
8001f9c: b9 80 08 00 mv r1,r12
8001fa0: 37 82 00 24 addi r2,sp,36
8001fa4: fb ff fe d8 calli 8001b04 <scanInt>
8001fa8: 44 20 00 22 be r1,r0,8002030 <scanpw+0x10c>
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
8001fac: b9 80 08 00 mv r1,r12
8001fb0: 35 62 00 0c addi r2,r11,12
8001fb4: b9 c0 18 00 mv r3,r14
8001fb8: b9 a0 20 00 mv r4,r13
8001fbc: 34 05 00 00 mvi r5,0
8001fc0: fb ff ff 2d calli 8001c74 <scanString>
8001fc4: 44 20 00 1b be r1,r0,8002030 <scanpw+0x10c> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
8001fc8: b9 80 08 00 mv r1,r12
8001fcc: 35 62 00 10 addi r2,r11,16
8001fd0: b9 c0 18 00 mv r3,r14
8001fd4: b9 a0 20 00 mv r4,r13
8001fd8: 34 05 00 00 mvi r5,0
8001fdc: fb ff ff 26 calli 8001c74 <scanString>
8001fe0: 44 20 00 14 be r1,r0,8002030 <scanpw+0x10c> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
8001fe4: b9 80 08 00 mv r1,r12
8001fe8: 35 62 00 14 addi r2,r11,20
8001fec: b9 c0 18 00 mv r3,r14
8001ff0: b9 a0 20 00 mv r4,r13
8001ff4: 34 05 00 00 mvi r5,0
8001ff8: fb ff ff 1f calli 8001c74 <scanString>
8001ffc: 44 20 00 0d be r1,r0,8002030 <scanpw+0x10c> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
8002000: b9 80 08 00 mv r1,r12
8002004: 35 62 00 18 addi r2,r11,24
8002008: b9 c0 18 00 mv r3,r14
800200c: b9 a0 20 00 mv r4,r13
8002010: 34 05 00 01 mvi r5,1
8002014: fb ff ff 18 calli 8001c74 <scanString>
8002018: 44 20 00 06 be r1,r0,8002030 <scanpw+0x10c>
return 0;
pwd->pw_uid = pwuid;
800201c: 2b 81 00 28 lw r1,(sp+40)
pwd->pw_gid = pwgid;
return 1;
8002020: 34 0f 00 01 mvi r15,1
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
pwd->pw_uid = pwuid;
8002024: 0d 61 00 08 sh (r11+8),r1
pwd->pw_gid = pwgid;
8002028: 2b 81 00 24 lw r1,(sp+36)
800202c: 0d 61 00 0a sh (r11+10),r1
return 1;
}
8002030: b9 e0 08 00 mv r1,r15
8002034: 2b 9d 00 04 lw ra,(sp+4)
8002038: 2b 8b 00 18 lw r11,(sp+24)
800203c: 2b 8c 00 14 lw r12,(sp+20)
8002040: 2b 8d 00 10 lw r13,(sp+16)
8002044: 2b 8e 00 0c lw r14,(sp+12)
8002048: 2b 8f 00 08 lw r15,(sp+8)
800204c: 37 9c 00 28 addi sp,sp,40
8002050: c3 a0 00 00 ret
08003978 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
8003978: 37 9c ff fc addi sp,sp,-4
800397c: 5b 9d 00 04 sw (sp+4),ra
switch ( policy ) {
8003980: 48 01 00 05 bg r0,r1,8003994 <sched_get_priority_max+0x1c>
8003984: 34 02 00 02 mvi r2,2
8003988: 4c 41 00 08 bge r2,r1,80039a8 <sched_get_priority_max+0x30>
800398c: 34 02 00 04 mvi r2,4
8003990: 44 22 00 06 be r1,r2,80039a8 <sched_get_priority_max+0x30> <== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
8003994: f8 00 26 6e calli 800d34c <__errno>
8003998: 34 02 00 16 mvi r2,22
800399c: 58 22 00 00 sw (r1+0),r2
80039a0: 34 01 ff ff mvi r1,-1
80039a4: e0 00 00 05 bi 80039b8 <sched_get_priority_max+0x40>
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
80039a8: 78 01 08 01 mvhi r1,0x801
80039ac: 38 21 f1 14 ori r1,r1,0xf114
80039b0: 40 21 00 00 lbu r1,(r1+0)
80039b4: 34 21 ff ff addi r1,r1,-1
}
80039b8: 2b 9d 00 04 lw ra,(sp+4)
80039bc: 37 9c 00 04 addi sp,sp,4
80039c0: c3 a0 00 00 ret
080039c4 <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
80039c4: 37 9c ff fc addi sp,sp,-4
80039c8: 5b 9d 00 04 sw (sp+4),ra
switch ( policy ) {
80039cc: 48 01 00 05 bg r0,r1,80039e0 <sched_get_priority_min+0x1c>
80039d0: 34 02 00 02 mvi r2,2
80039d4: 4c 41 00 08 bge r2,r1,80039f4 <sched_get_priority_min+0x30><== ALWAYS TAKEN
80039d8: 34 02 00 04 mvi r2,4 <== NOT EXECUTED
80039dc: 44 22 00 06 be r1,r2,80039f4 <sched_get_priority_min+0x30> <== NOT EXECUTED
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
80039e0: f8 00 26 5b calli 800d34c <__errno>
80039e4: 34 02 00 16 mvi r2,22
80039e8: 58 22 00 00 sw (r1+0),r2
80039ec: 34 01 ff ff mvi r1,-1
80039f0: e0 00 00 02 bi 80039f8 <sched_get_priority_min+0x34>
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
80039f4: 34 01 00 01 mvi r1,1
}
80039f8: 2b 9d 00 04 lw ra,(sp+4)
80039fc: 37 9c 00 04 addi sp,sp,4
8003a00: c3 a0 00 00 ret
08003a04 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
8003a04: 37 9c ff f4 addi sp,sp,-12
8003a08: 5b 8b 00 08 sw (sp+8),r11
8003a0c: 5b 9d 00 04 sw (sp+4),ra
8003a10: b8 20 58 00 mv r11,r1
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
8003a14: 44 20 00 08 be r1,r0,8003a34 <sched_rr_get_interval+0x30> <== NEVER TAKEN
8003a18: 5b 82 00 0c sw (sp+12),r2
8003a1c: fb ff f8 a4 calli 8001cac <getpid>
8003a20: 2b 82 00 0c lw r2,(sp+12)
8003a24: 45 61 00 04 be r11,r1,8003a34 <sched_rr_get_interval+0x30>
rtems_set_errno_and_return_minus_one( ESRCH );
8003a28: f8 00 26 49 calli 800d34c <__errno>
8003a2c: 34 02 00 03 mvi r2,3
8003a30: e0 00 00 04 bi 8003a40 <sched_rr_get_interval+0x3c>
if ( !interval )
8003a34: 5c 40 00 06 bne r2,r0,8003a4c <sched_rr_get_interval+0x48>
rtems_set_errno_and_return_minus_one( EINVAL );
8003a38: f8 00 26 45 calli 800d34c <__errno>
8003a3c: 34 02 00 16 mvi r2,22
8003a40: 58 22 00 00 sw (r1+0),r2
8003a44: 34 01 ff ff mvi r1,-1
8003a48: e0 00 00 06 bi 8003a60 <sched_rr_get_interval+0x5c>
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
8003a4c: 78 01 08 01 mvhi r1,0x801
8003a50: 38 21 f8 60 ori r1,r1,0xf860
8003a54: 28 21 00 00 lw r1,(r1+0)
8003a58: f8 00 0e 76 calli 8007430 <_Timespec_From_ticks>
return 0;
8003a5c: 34 01 00 00 mvi r1,0
}
8003a60: 2b 9d 00 04 lw ra,(sp+4)
8003a64: 2b 8b 00 08 lw r11,(sp+8)
8003a68: 37 9c 00 0c addi sp,sp,12
8003a6c: c3 a0 00 00 ret
08006160 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
8006160: 37 9c ff c0 addi sp,sp,-64
8006164: 5b 8b 00 18 sw (sp+24),r11
8006168: 5b 8c 00 14 sw (sp+20),r12
800616c: 5b 8d 00 10 sw (sp+16),r13
8006170: 5b 8e 00 0c sw (sp+12),r14
8006174: 5b 8f 00 08 sw (sp+8),r15
8006178: 5b 9d 00 04 sw (sp+4),ra
800617c: 5b 83 00 2c sw (sp+44),r3
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
8006180: 78 03 08 02 mvhi r3,0x802
8006184: 5b 82 00 28 sw (sp+40),r2
8006188: 5b 84 00 30 sw (sp+48),r4
800618c: 5b 85 00 34 sw (sp+52),r5
8006190: 5b 86 00 38 sw (sp+56),r6
8006194: 5b 87 00 3c sw (sp+60),r7
8006198: 5b 88 00 40 sw (sp+64),r8
800619c: 38 63 4a c0 ori r3,r3,0x4ac0
80061a0: b8 20 60 00 mv r12,r1
80061a4: 28 61 00 00 lw r1,(r3+0)
80061a8: b8 40 70 00 mv r14,r2
80061ac: 34 21 00 01 addi r1,r1,1
80061b0: 58 61 00 00 sw (r3+0),r1
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
80061b4: 20 4f 02 00 andi r15,r2,0x200
/* unsigned int value */
)
{
va_list arg;
mode_t mode;
unsigned int value = 0;
80061b8: 34 0d 00 00 mvi r13,0
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
80061bc: 45 e0 00 02 be r15,r0,80061c4 <sem_open+0x64>
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
80061c0: 2b 8d 00 30 lw r13,(sp+48)
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
80061c4: b9 80 08 00 mv r1,r12
80061c8: 37 82 00 24 addi r2,sp,36
80061cc: f8 00 1b 5d calli 800cf40 <_POSIX_Semaphore_Name_to_id>
80061d0: b8 20 58 00 mv r11,r1
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "semaphore does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
80061d4: 44 20 00 08 be r1,r0,80061f4 <sem_open+0x94>
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
80061d8: 34 01 00 02 mvi r1,2
80061dc: 5d 61 00 02 bne r11,r1,80061e4 <sem_open+0x84> <== NEVER TAKEN
80061e0: 5d e0 00 1a bne r15,r0,8006248 <sem_open+0xe8>
_Thread_Enable_dispatch();
80061e4: f8 00 0b 2a calli 8008e8c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
80061e8: f8 00 2a 43 calli 8010af4 <__errno>
80061ec: 58 2b 00 00 sw (r1+0),r11
80061f0: e0 00 00 08 bi 8006210 <sem_open+0xb0>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
80061f4: 21 ce 0a 00 andi r14,r14,0xa00
80061f8: 34 01 0a 00 mvi r1,2560
80061fc: 5d c1 00 07 bne r14,r1,8006218 <sem_open+0xb8>
_Thread_Enable_dispatch();
8006200: f8 00 0b 23 calli 8008e8c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
8006204: f8 00 2a 3c calli 8010af4 <__errno>
8006208: 34 02 00 11 mvi r2,17
800620c: 58 22 00 00 sw (r1+0),r2
8006210: 34 01 ff ff mvi r1,-1
8006214: e0 00 00 18 bi 8006274 <sem_open+0x114>
8006218: 2b 82 00 24 lw r2,(sp+36)
800621c: 78 01 08 02 mvhi r1,0x802
8006220: 37 83 00 1c addi r3,sp,28
8006224: 38 21 4c f4 ori r1,r1,0x4cf4
8006228: f8 00 07 56 calli 8007f80 <_Objects_Get>
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
the_semaphore->open_count += 1;
800622c: 28 22 00 18 lw r2,(r1+24)
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
8006230: 5b 81 00 20 sw (sp+32),r1
the_semaphore->open_count += 1;
8006234: 34 42 00 01 addi r2,r2,1
8006238: 58 22 00 18 sw (r1+24),r2
_Thread_Enable_dispatch();
800623c: f8 00 0b 14 calli 8008e8c <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
8006240: f8 00 0b 13 calli 8008e8c <_Thread_Enable_dispatch>
goto return_id;
8006244: e0 00 00 0a bi 800626c <sem_open+0x10c>
/*
* At this point, the semaphore does not exist and everything has been
* checked. We should go ahead and create a semaphore.
*/
status =_POSIX_Semaphore_Create_support(
8006248: 34 02 00 00 mvi r2,0
800624c: b9 a0 18 00 mv r3,r13
8006250: 37 84 00 20 addi r4,sp,32
8006254: b9 80 08 00 mv r1,r12
8006258: f8 00 1a d6 calli 800cdb0 <_POSIX_Semaphore_Create_support>
800625c: b8 20 58 00 mv r11,r1
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
8006260: f8 00 0b 0b calli 8008e8c <_Thread_Enable_dispatch>
if ( status == -1 )
return SEM_FAILED;
8006264: 34 01 ff ff mvi r1,-1
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
if ( status == -1 )
8006268: 45 61 00 03 be r11,r1,8006274 <sem_open+0x114>
return_id:
#if defined(RTEMS_USE_16_BIT_OBJECT)
the_semaphore->Semaphore_id = the_semaphore->Object.id;
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
800626c: 2b 81 00 20 lw r1,(sp+32)
8006270: 34 21 00 08 addi r1,r1,8
#endif
return id;
}
8006274: 2b 9d 00 04 lw ra,(sp+4)
8006278: 2b 8b 00 18 lw r11,(sp+24)
800627c: 2b 8c 00 14 lw r12,(sp+20)
8006280: 2b 8d 00 10 lw r13,(sp+16)
8006284: 2b 8e 00 0c lw r14,(sp+12)
8006288: 2b 8f 00 08 lw r15,(sp+8)
800628c: 37 9c 00 40 addi sp,sp,64
8006290: c3 a0 00 00 ret
08003868 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
8003868: 37 9c ff ec addi sp,sp,-20
800386c: 5b 8b 00 14 sw (sp+20),r11
8003870: 5b 8c 00 10 sw (sp+16),r12
8003874: 5b 8d 00 0c sw (sp+12),r13
8003878: 5b 8e 00 08 sw (sp+8),r14
800387c: 5b 9d 00 04 sw (sp+4),ra
8003880: b8 20 58 00 mv r11,r1
8003884: b8 40 60 00 mv r12,r2
8003888: b8 60 68 00 mv r13,r3
ISR_Level level;
if ( oact )
800388c: 44 60 00 0f be r3,r0,80038c8 <sigaction+0x60>
*oact = _POSIX_signals_Vectors[ sig ];
8003890: 34 02 00 01 mvi r2,1
8003894: f8 00 67 13 calli 801d4e0 <__ashlsi3>
8003898: 34 02 00 02 mvi r2,2
800389c: 78 0e 08 02 mvhi r14,0x802
80038a0: b4 2b 08 00 add r1,r1,r11
80038a4: f8 00 67 0f calli 801d4e0 <__ashlsi3>
80038a8: 39 ce 0e 10 ori r14,r14,0xe10
80038ac: b5 c1 08 00 add r1,r14,r1
80038b0: 28 23 00 00 lw r3,(r1+0)
80038b4: 28 22 00 04 lw r2,(r1+4)
80038b8: 28 21 00 08 lw r1,(r1+8)
80038bc: 59 a3 00 00 sw (r13+0),r3
80038c0: 59 a2 00 04 sw (r13+4),r2
80038c4: 59 a1 00 08 sw (r13+8),r1
if ( !sig )
80038c8: 45 60 00 07 be r11,r0,80038e4 <sigaction+0x7c>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
80038cc: 35 61 ff ff addi r1,r11,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
80038d0: 34 02 00 1f mvi r2,31
80038d4: 50 41 00 02 bgeu r2,r1,80038dc <sigaction+0x74>
80038d8: e0 00 00 03 bi 80038e4 <sigaction+0x7c>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
80038dc: 34 01 00 09 mvi r1,9
80038e0: 5d 61 00 06 bne r11,r1,80038f8 <sigaction+0x90>
rtems_set_errno_and_return_minus_one( EINVAL );
80038e4: f8 00 27 ed calli 800d898 <__errno>
80038e8: 34 02 00 16 mvi r2,22
80038ec: 58 22 00 00 sw (r1+0),r2
80038f0: 34 01 ff ff mvi r1,-1
80038f4: e0 00 00 31 bi 80039b8 <sigaction+0x150>
* 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;
80038f8: 34 01 00 00 mvi r1,0
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
80038fc: 45 80 00 2f be r12,r0,80039b8 <sigaction+0x150> <== NEVER TAKEN
/*
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
8003900: 90 00 70 00 rcsr r14,IE
8003904: 34 01 ff fe mvi r1,-2
8003908: a1 c1 08 00 and r1,r14,r1
800390c: d0 01 00 00 wcsr IE,r1
if ( act->sa_handler == SIG_DFL ) {
8003910: 29 81 00 08 lw r1,(r12+8)
8003914: 78 0d 08 02 mvhi r13,0x802
8003918: 39 ad 0e 10 ori r13,r13,0xe10
800391c: 5c 20 00 16 bne r1,r0,8003974 <sigaction+0x10c>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
8003920: b9 60 08 00 mv r1,r11
8003924: 34 02 00 01 mvi r2,1
8003928: f8 00 66 ee calli 801d4e0 <__ashlsi3>
800392c: b4 2b 58 00 add r11,r1,r11
8003930: 34 02 00 02 mvi r2,2
8003934: b9 60 08 00 mv r1,r11
8003938: f8 00 66 ea calli 801d4e0 <__ashlsi3>
800393c: b5 a1 68 00 add r13,r13,r1
8003940: 34 02 00 02 mvi r2,2
8003944: 78 0c 08 01 mvhi r12,0x801
8003948: b9 60 08 00 mv r1,r11
800394c: f8 00 66 e5 calli 801d4e0 <__ashlsi3>
8003950: 39 8c ee cc ori r12,r12,0xeecc
8003954: b5 81 08 00 add r1,r12,r1
8003958: 28 23 00 00 lw r3,(r1+0)
800395c: 28 22 00 04 lw r2,(r1+4)
8003960: 28 21 00 08 lw r1,(r1+8)
8003964: 59 a3 00 00 sw (r13+0),r3
8003968: 59 a2 00 04 sw (r13+4),r2
800396c: 59 a1 00 08 sw (r13+8),r1
8003970: e0 00 00 10 bi 80039b0 <sigaction+0x148>
} else {
_POSIX_signals_Clear_process_signals( sig );
8003974: b9 60 08 00 mv r1,r11
8003978: f8 00 18 f1 calli 8009d3c <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
800397c: 34 02 00 01 mvi r2,1
8003980: b9 60 08 00 mv r1,r11
8003984: f8 00 66 d7 calli 801d4e0 <__ashlsi3>
8003988: 34 02 00 02 mvi r2,2
800398c: b4 2b 08 00 add r1,r1,r11
8003990: f8 00 66 d4 calli 801d4e0 <__ashlsi3>
8003994: 29 83 00 00 lw r3,(r12+0)
8003998: 29 82 00 04 lw r2,(r12+4)
800399c: 29 84 00 08 lw r4,(r12+8)
80039a0: b5 a1 08 00 add r1,r13,r1
80039a4: 58 23 00 00 sw (r1+0),r3
80039a8: 58 22 00 04 sw (r1+4),r2
80039ac: 58 24 00 08 sw (r1+8),r4
}
_ISR_Enable( level );
80039b0: d0 0e 00 00 wcsr IE,r14
* 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;
80039b4: 34 01 00 00 mvi r1,0
}
80039b8: 2b 9d 00 04 lw ra,(sp+4)
80039bc: 2b 8b 00 14 lw r11,(sp+20)
80039c0: 2b 8c 00 10 lw r12,(sp+16)
80039c4: 2b 8d 00 0c lw r13,(sp+12)
80039c8: 2b 8e 00 08 lw r14,(sp+8)
80039cc: 37 9c 00 14 addi sp,sp,20
80039d0: c3 a0 00 00 ret
08003e64 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
8003e64: 37 9c ff dc addi sp,sp,-36
8003e68: 5b 8b 00 18 sw (sp+24),r11
8003e6c: 5b 8c 00 14 sw (sp+20),r12
8003e70: 5b 8d 00 10 sw (sp+16),r13
8003e74: 5b 8e 00 0c sw (sp+12),r14
8003e78: 5b 8f 00 08 sw (sp+8),r15
8003e7c: 5b 9d 00 04 sw (sp+4),ra
8003e80: b8 20 68 00 mv r13,r1
8003e84: b8 40 58 00 mv r11,r2
8003e88: b8 60 60 00 mv r12,r3
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
8003e8c: 44 20 00 09 be r1,r0,8003eb0 <sigtimedwait+0x4c>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
8003e90: 44 60 00 0b be r3,r0,8003ebc <sigtimedwait+0x58>
if ( !_Timespec_Is_valid( timeout ) )
8003e94: b8 60 08 00 mv r1,r3
8003e98: f8 00 0e dc calli 8007a08 <_Timespec_Is_valid>
8003e9c: 44 20 00 05 be r1,r0,8003eb0 <sigtimedwait+0x4c>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
8003ea0: b9 80 08 00 mv r1,r12
8003ea4: f8 00 0e f7 calli 8007a80 <_Timespec_To_ticks>
8003ea8: b8 20 10 00 mv r2,r1
if ( !interval )
8003eac: 5c 20 00 05 bne r1,r0,8003ec0 <sigtimedwait+0x5c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
8003eb0: f8 00 28 46 calli 800dfc8 <__errno>
8003eb4: 34 02 00 16 mvi r2,22
8003eb8: e0 00 00 61 bi 800403c <sigtimedwait+0x1d8>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
8003ebc: 34 02 00 00 mvi r2,0
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
8003ec0: 5d 60 00 02 bne r11,r0,8003ec8 <sigtimedwait+0x64>
8003ec4: 37 8b 00 1c addi r11,sp,28
the_thread = _Thread_Executing;
8003ec8: 78 01 08 02 mvhi r1,0x802
8003ecc: 38 21 1d c4 ori r1,r1,0x1dc4
8003ed0: 28 23 00 0c lw r3,(r1+12)
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
8003ed4: 28 6e 01 20 lw r14,(r3+288)
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
8003ed8: 90 00 78 00 rcsr r15,IE
8003edc: 34 01 ff fe mvi r1,-2
8003ee0: a1 e1 08 00 and r1,r15,r1
8003ee4: d0 01 00 00 wcsr IE,r1
if ( *set & api->signals_pending ) {
8003ee8: 29 a5 00 00 lw r5,(r13+0)
8003eec: 29 c1 00 d4 lw r1,(r14+212)
8003ef0: a0 a1 20 00 and r4,r5,r1
8003ef4: 44 80 00 0f be r4,r0,8003f30 <sigtimedwait+0xcc>
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
8003ef8: fb ff ff bc calli 8003de8 <_POSIX_signals_Get_lowest>
8003efc: b8 20 10 00 mv r2,r1
8003f00: 59 61 00 00 sw (r11+0),r1
_POSIX_signals_Clear_signals(
8003f04: b9 60 18 00 mv r3,r11
8003f08: b9 c0 08 00 mv r1,r14
8003f0c: 34 04 00 00 mvi r4,0
8003f10: 34 05 00 00 mvi r5,0
8003f14: f8 00 1a 49 calli 800a838 <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
8003f18: d0 0f 00 00 wcsr IE,r15
the_info->si_code = SI_USER;
8003f1c: 34 01 00 01 mvi r1,1
8003f20: 59 61 00 04 sw (r11+4),r1
the_info->si_value.sival_int = 0;
8003f24: 59 60 00 08 sw (r11+8),r0
return the_info->si_signo;
8003f28: 29 6c 00 00 lw r12,(r11+0)
8003f2c: e0 00 00 46 bi 8004044 <sigtimedwait+0x1e0>
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
8003f30: 78 01 08 02 mvhi r1,0x802
8003f34: 38 21 20 04 ori r1,r1,0x2004
8003f38: 28 21 00 00 lw r1,(r1+0)
8003f3c: a0 a1 28 00 and r5,r5,r1
8003f40: 44 a4 00 0f be r5,r4,8003f7c <sigtimedwait+0x118>
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
8003f44: fb ff ff a9 calli 8003de8 <_POSIX_signals_Get_lowest>
8003f48: b8 20 60 00 mv r12,r1
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
8003f4c: b9 80 10 00 mv r2,r12
8003f50: b9 c0 08 00 mv r1,r14
8003f54: b9 60 18 00 mv r3,r11
8003f58: 34 04 00 01 mvi r4,1
8003f5c: 34 05 00 00 mvi r5,0
8003f60: f8 00 1a 36 calli 800a838 <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
8003f64: d0 0f 00 00 wcsr IE,r15
the_info->si_signo = signo;
the_info->si_code = SI_USER;
8003f68: 34 01 00 01 mvi r1,1
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
_ISR_Enable( level );
the_info->si_signo = signo;
8003f6c: 59 6c 00 00 sw (r11+0),r12
the_info->si_code = SI_USER;
8003f70: 59 61 00 04 sw (r11+4),r1
the_info->si_value.sival_int = 0;
8003f74: 59 60 00 08 sw (r11+8),r0
return signo;
8003f78: e0 00 00 33 bi 8004044 <sigtimedwait+0x1e0>
}
the_info->si_signo = -1;
8003f7c: 34 01 ff ff mvi r1,-1
8003f80: 59 61 00 00 sw (r11+0),r1
8003f84: 78 01 08 02 mvhi r1,0x802
8003f88: 38 21 19 18 ori r1,r1,0x1918
8003f8c: 28 24 00 00 lw r4,(r1+0)
8003f90: 34 84 00 01 addi r4,r4,1
8003f94: 58 24 00 00 sw (r1+0),r4
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
8003f98: 34 04 00 04 mvi r4,4
8003f9c: 58 64 00 34 sw (r3+52),r4
the_thread->Wait.option = *set;
8003fa0: 29 a4 00 00 lw r4,(r13+0)
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
8003fa4: 78 01 08 02 mvhi r1,0x802
8003fa8: 38 21 1f 9c ori r1,r1,0x1f9c
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
8003fac: 58 64 00 30 sw (r3+48),r4
the_thread->Wait.return_argument = the_info;
8003fb0: 58 6b 00 28 sw (r3+40),r11
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
8003fb4: 58 61 00 44 sw (r3+68),r1
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
8003fb8: 34 03 00 01 mvi r3,1
8003fbc: 58 23 00 30 sw (r1+48),r3
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
the_thread->Wait.return_argument = the_info;
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
8003fc0: d0 0f 00 00 wcsr IE,r15
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
8003fc4: 78 01 08 02 mvhi r1,0x802
8003fc8: 78 03 08 00 mvhi r3,0x800
8003fcc: 38 21 1f 9c ori r1,r1,0x1f9c
8003fd0: 38 63 76 98 ori r3,r3,0x7698
8003fd4: f8 00 0c 87 calli 80071f0 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
8003fd8: f8 00 0b 1e calli 8006c50 <_Thread_Enable_dispatch>
/*
* When the thread is set free by a signal, it is need to eliminate
* the signal.
*/
_POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false );
8003fdc: 29 62 00 00 lw r2,(r11+0)
8003fe0: b9 c0 08 00 mv r1,r14
8003fe4: b9 60 18 00 mv r3,r11
8003fe8: 34 04 00 00 mvi r4,0
8003fec: 34 05 00 00 mvi r5,0
8003ff0: f8 00 1a 12 calli 800a838 <_POSIX_signals_Clear_signals>
/* Set errno only if return code is not EINTR or
* if EINTR was caused by a signal being caught, which
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
8003ff4: 78 01 08 02 mvhi r1,0x802
8003ff8: 38 21 1d c4 ori r1,r1,0x1dc4
8003ffc: 28 21 00 0c lw r1,(r1+12)
8004000: 28 22 00 34 lw r2,(r1+52)
8004004: 34 01 00 04 mvi r1,4
8004008: 5c 41 00 08 bne r2,r1,8004028 <sigtimedwait+0x1c4>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
800400c: 29 6c 00 00 lw r12,(r11+0)
8004010: 34 01 00 01 mvi r1,1
8004014: 35 82 ff ff addi r2,r12,-1
8004018: f8 00 66 e7 calli 801dbb4 <__ashlsi3>
800401c: 29 a2 00 00 lw r2,(r13+0)
8004020: a0 22 08 00 and r1,r1,r2
8004024: 5c 20 00 08 bne r1,r0,8004044 <sigtimedwait+0x1e0>
errno = _Thread_Executing->Wait.return_code;
8004028: f8 00 27 e8 calli 800dfc8 <__errno>
800402c: 78 02 08 02 mvhi r2,0x802
8004030: 38 42 1d c4 ori r2,r2,0x1dc4
8004034: 28 42 00 0c lw r2,(r2+12)
8004038: 28 42 00 34 lw r2,(r2+52)
800403c: 58 22 00 00 sw (r1+0),r2
return -1;
8004040: 34 0c ff ff mvi r12,-1
}
return the_info->si_signo;
}
8004044: b9 80 08 00 mv r1,r12
8004048: 2b 9d 00 04 lw ra,(sp+4)
800404c: 2b 8b 00 18 lw r11,(sp+24)
8004050: 2b 8c 00 14 lw r12,(sp+20)
8004054: 2b 8d 00 10 lw r13,(sp+16)
8004058: 2b 8e 00 0c lw r14,(sp+12)
800405c: 2b 8f 00 08 lw r15,(sp+8)
8004060: 37 9c 00 24 addi sp,sp,36
8004064: c3 a0 00 00 ret
08006278 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
8006278: 37 9c ff f8 addi sp,sp,-8
800627c: 5b 8b 00 08 sw (sp+8),r11
8006280: 5b 9d 00 04 sw (sp+4),ra
int status;
status = sigtimedwait( set, NULL, NULL );
8006284: 34 03 00 00 mvi r3,0
int sigwait(
const sigset_t *set,
int *sig
)
{
8006288: b8 40 58 00 mv r11,r2
int status;
status = sigtimedwait( set, NULL, NULL );
800628c: 34 02 00 00 mvi r2,0
8006290: fb ff ff 72 calli 8006058 <sigtimedwait>
8006294: b8 20 18 00 mv r3,r1
if ( status != -1 ) {
8006298: 34 01 ff ff mvi r1,-1
800629c: 44 61 00 05 be r3,r1,80062b0 <sigwait+0x38>
if ( sig )
*sig = status;
return 0;
80062a0: 34 01 00 00 mvi r1,0
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
80062a4: 45 60 00 05 be r11,r0,80062b8 <sigwait+0x40> <== NEVER TAKEN
*sig = status;
80062a8: 59 63 00 00 sw (r11+0),r3
80062ac: e0 00 00 03 bi 80062b8 <sigwait+0x40>
return 0;
}
return errno;
80062b0: f8 00 26 b0 calli 800fd70 <__errno>
80062b4: 28 21 00 00 lw r1,(r1+0)
}
80062b8: 2b 9d 00 04 lw ra,(sp+4)
80062bc: 2b 8b 00 08 lw r11,(sp+8)
80062c0: 37 9c 00 08 addi sp,sp,8
80062c4: c3 a0 00 00 ret
08004428 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
8004428: 37 9c ff f4 addi sp,sp,-12
800442c: 5b 8b 00 0c sw (sp+12),r11
8004430: 5b 8c 00 08 sw (sp+8),r12
8004434: 5b 9d 00 04 sw (sp+4),ra
8004438: b8 20 60 00 mv r12,r1
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
800443c: 28 41 00 3c lw r1,(r2+60)
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
8004440: b8 40 58 00 mv r11,r2
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
8004444: 20 21 0e 78 andi r1,r1,0xe78
8004448: 44 20 00 0c be r1,r0,8004478 <siproc+0x50> <== NEVER TAKEN
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
800444c: 28 41 00 18 lw r1,(r2+24)
8004450: 34 03 00 00 mvi r3,0
8004454: 34 02 00 00 mvi r2,0
8004458: f8 00 05 7b calli 8005a44 <rtems_semaphore_obtain>
i = iproc (c, tty);
800445c: b9 80 08 00 mv r1,r12
8004460: b9 60 10 00 mv r2,r11
8004464: fb ff ff 84 calli 8004274 <iproc>
8004468: b8 20 60 00 mv r12,r1
rtems_semaphore_release (tty->osem);
800446c: 29 61 00 18 lw r1,(r11+24)
8004470: f8 00 05 c5 calli 8005b84 <rtems_semaphore_release>
8004474: e0 00 00 04 bi 8004484 <siproc+0x5c>
}
else {
i = iproc (c, tty);
8004478: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
800447c: fb ff ff 7e calli 8004274 <iproc> <== NOT EXECUTED
8004480: b8 20 60 00 mv r12,r1 <== NOT EXECUTED
}
return i;
}
8004484: b9 80 08 00 mv r1,r12
8004488: 2b 9d 00 04 lw ra,(sp+4)
800448c: 2b 8b 00 0c lw r11,(sp+12)
8004490: 2b 8c 00 08 lw r12,(sp+8)
8004494: 37 9c 00 0c addi sp,sp,12
8004498: c3 a0 00 00 ret
080050d4 <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
80050d4: 37 9c ff dc addi sp,sp,-36
80050d8: 5b 8b 00 10 sw (sp+16),r11
80050dc: 5b 8c 00 0c sw (sp+12),r12
80050e0: 5b 8d 00 08 sw (sp+8),r13
80050e4: 5b 9d 00 04 sw (sp+4),ra
80050e8: b8 20 58 00 mv r11,r1
80050ec: b8 40 68 00 mv r13,r2
* 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 ) )
80050f0: 37 8c 00 14 addi r12,sp,20
80050f4: f8 00 32 67 calli 8011a90 <strlen>
80050f8: b8 20 10 00 mv r2,r1
80050fc: 34 03 00 00 mvi r3,0
8005100: b9 60 08 00 mv r1,r11
8005104: b9 80 20 00 mv r4,r12
8005108: 34 05 00 01 mvi r5,1
800510c: fb ff fa 21 calli 8003990 <rtems_filesystem_evaluate_path>
return -1;
8005110: 34 0b ff ff mvi r11,-1
* 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 ) )
8005114: 5c 20 00 0e bne r1,r0,800514c <statvfs+0x78> <== NEVER TAKEN
return -1;
mt_entry = loc.mt_entry;
8005118: 2b 8b 00 24 lw r11,(sp+36)
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
800511c: 34 02 00 00 mvi r2,0
8005120: 34 03 00 38 mvi r3,56
8005124: b9 a0 08 00 mv r1,r13
8005128: f8 00 2d b8 calli 8010808 <memset>
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
800512c: 29 61 00 28 lw r1,(r11+40)
8005130: b9 a0 10 00 mv r2,r13
8005134: 28 23 00 44 lw r3,(r1+68)
8005138: 35 61 00 1c addi r1,r11,28
800513c: d8 60 00 00 call r3
8005140: b8 20 58 00 mv r11,r1
rtems_filesystem_freenode( &loc );
8005144: b9 80 08 00 mv r1,r12
8005148: fb ff fa 5a calli 8003ab0 <rtems_filesystem_freenode>
return result;
}
800514c: b9 60 08 00 mv r1,r11
8005150: 2b 9d 00 04 lw ra,(sp+4)
8005154: 2b 8b 00 10 lw r11,(sp+16)
8005158: 2b 8c 00 0c lw r12,(sp+12)
800515c: 2b 8d 00 08 lw r13,(sp+8)
8005160: 37 9c 00 24 addi sp,sp,36
8005164: c3 a0 00 00 ret
080039dc <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
80039dc: 37 9c ff f4 addi sp,sp,-12
80039e0: 5b 8b 00 0c sw (sp+12),r11
80039e4: 5b 8c 00 08 sw (sp+8),r12
80039e8: 5b 9d 00 04 sw (sp+4),ra
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
80039ec: 28 22 01 18 lw r2,(r1+280)
if ( this_reent ) {
80039f0: 44 40 00 0c be r2,r0,8003a20 <sync_per_thread+0x44> <== NEVER TAKEN
current_reent = _Thread_Executing->libc_reent;
80039f4: 78 0b 08 01 mvhi r11,0x801
80039f8: 39 6b 6d 74 ori r11,r11,0x6d74
80039fc: 29 63 00 0c lw r3,(r11+12)
8003a00: 28 6c 01 18 lw r12,(r3+280)
_Thread_Executing->libc_reent = this_reent;
8003a04: 58 62 01 18 sw (r3+280),r2
_fwalk (t->libc_reent, sync_wrapper);
8003a08: 28 21 01 18 lw r1,(r1+280)
8003a0c: 78 02 08 00 mvhi r2,0x800
8003a10: 38 42 3a 34 ori r2,r2,0x3a34
8003a14: f8 00 2b b3 calli 800e8e0 <_fwalk>
_Thread_Executing->libc_reent = current_reent;
8003a18: 29 61 00 0c lw r1,(r11+12)
8003a1c: 58 2c 01 18 sw (r1+280),r12
}
}
8003a20: 2b 9d 00 04 lw ra,(sp+4)
8003a24: 2b 8b 00 0c lw r11,(sp+12)
8003a28: 2b 8c 00 08 lw r12,(sp+8)
8003a2c: 37 9c 00 0c addi sp,sp,12
8003a30: c3 a0 00 00 ret
08002298 <tcflow>:
int tcflow (
int fd __attribute__((unused)),
int action
)
{
8002298: 37 9c ff fc addi sp,sp,-4 <== NOT EXECUTED
800229c: 5b 9d 00 04 sw (sp+4),ra <== NOT EXECUTED
case TCOOFF:
case TCOON:
case TCIOFF:
case TCION:
default:
rtems_set_errno_and_return_minus_one( EINVAL );
80022a0: f8 00 1f e8 calli 800a240 <__errno> <== NOT EXECUTED
80022a4: 34 02 00 16 mvi r2,22 <== NOT EXECUTED
80022a8: 58 22 00 00 sw (r1+0),r2 <== NOT EXECUTED
/* fd is not validated */
/* When this is supported, implement it here */
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
80022ac: 34 01 ff ff mvi r1,-1 <== NOT EXECUTED
80022b0: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
80022b4: 37 9c 00 04 addi sp,sp,4 <== NOT EXECUTED
80022b8: c3 a0 00 00 ret <== NOT EXECUTED
080022bc <tcflush>:
int tcflush (
int fd __attribute__((unused)),
int queue
)
{
80022bc: 37 9c ff fc addi sp,sp,-4 <== NOT EXECUTED
80022c0: 5b 9d 00 04 sw (sp+4),ra <== NOT EXECUTED
switch (queue) {
case TCIFLUSH:
case TCOFLUSH:
case TCIOFLUSH:
default:
rtems_set_errno_and_return_minus_one( EINVAL );
80022c4: f8 00 1f df calli 800a240 <__errno> <== NOT EXECUTED
80022c8: 34 02 00 16 mvi r2,22 <== NOT EXECUTED
80022cc: 58 22 00 00 sw (r1+0),r2 <== NOT EXECUTED
/* fd is not validated */
/* When this is supported, implement it here */
rtems_set_errno_and_return_minus_one( ENOTSUP );
return 0;
}
80022d0: 34 01 ff ff mvi r1,-1 <== NOT EXECUTED
80022d4: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
80022d8: 37 9c 00 04 addi sp,sp,4 <== NOT EXECUTED
80022dc: c3 a0 00 00 ret <== NOT EXECUTED
080022e0 <tcgetpgrp>:
#include <sys/types.h>
#include <unistd.h>
pid_t tcgetpgrp(int fd __attribute__((unused)))
{
80022e0: 37 9c ff fc addi sp,sp,-4 <== NOT EXECUTED
80022e4: 5b 9d 00 04 sw (sp+4),ra <== NOT EXECUTED
return getpid();
80022e8: fb ff fc 73 calli 80014b4 <getpid> <== NOT EXECUTED
}
80022ec: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
80022f0: 37 9c 00 04 addi sp,sp,4 <== NOT EXECUTED
80022f4: c3 a0 00 00 ret <== NOT EXECUTED
080022f8 <tcsendbreak>:
int tcsendbreak (
int fd __attribute__((unused)),
int duration __attribute__((unused)) )
{
return 0;
}
80022f8: 34 01 00 00 mvi r1,0 <== NOT EXECUTED
80022fc: c3 a0 00 00 ret <== NOT EXECUTED
0800c328 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
800c328: 37 9c ff f4 addi sp,sp,-12
800c32c: 5b 8b 00 0c sw (sp+12),r11
800c330: 5b 8c 00 08 sw (sp+8),r12
800c334: 5b 9d 00 04 sw (sp+4),ra
800c338: b8 20 60 00 mv r12,r1
800c33c: b8 60 58 00 mv r11,r3
switch (opt) {
800c340: 44 40 00 0d be r2,r0,800c374 <tcsetattr+0x4c>
800c344: 34 03 00 01 mvi r3,1
800c348: 44 43 00 06 be r2,r3,800c360 <tcsetattr+0x38>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
800c34c: f8 00 12 2f calli 8010c08 <__errno>
800c350: 34 02 00 86 mvi r2,134
800c354: 58 22 00 00 sw (r1+0),r2
800c358: 34 02 ff ff mvi r2,-1
800c35c: e0 00 00 0b bi 800c388 <tcsetattr+0x60>
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
800c360: 34 02 00 03 mvi r2,3
800c364: 34 03 00 00 mvi r3,0
800c368: fb ff fe ce calli 800bea0 <ioctl>
return -1;
800c36c: 34 02 ff ff mvi r2,-1
switch (opt) {
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
800c370: 48 01 00 06 bg r0,r1,800c388 <tcsetattr+0x60> <== NEVER TAKEN
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
800c374: 34 02 00 02 mvi r2,2
800c378: b9 80 08 00 mv r1,r12
800c37c: b9 60 18 00 mv r3,r11
800c380: fb ff fe c8 calli 800bea0 <ioctl>
800c384: b8 20 10 00 mv r2,r1
}
}
800c388: b8 40 08 00 mv r1,r2
800c38c: 2b 9d 00 04 lw ra,(sp+4)
800c390: 2b 8b 00 0c lw r11,(sp+12)
800c394: 2b 8c 00 08 lw r12,(sp+8)
800c398: 37 9c 00 0c addi sp,sp,12
800c39c: c3 a0 00 00 ret
08002300 <tcsetpgrp>:
int tcsetpgrp(
int fd __attribute__((unused)),
pid_t pid __attribute__((unused)) )
{
return 0;
}
8002300: 34 01 00 00 mvi r1,0 <== NOT EXECUTED
8002304: c3 a0 00 00 ret <== NOT EXECUTED
08002e60 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
8002e60: 37 9c ff ec addi sp,sp,-20
8002e64: 5b 8b 00 14 sw (sp+20),r11
8002e68: 5b 8c 00 10 sw (sp+16),r12
8002e6c: 5b 8d 00 0c sw (sp+12),r13
8002e70: 5b 8e 00 08 sw (sp+8),r14
8002e74: 5b 9d 00 04 sw (sp+4),ra
8002e78: b8 40 60 00 mv r12,r2
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
8002e7c: 34 02 00 01 mvi r2,1
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
8002e80: b8 60 68 00 mv r13,r3
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
8002e84: 5c 22 00 0c bne r1,r2,8002eb4 <timer_create+0x54>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
8002e88: 44 60 00 0b be r3,r0,8002eb4 <timer_create+0x54>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
8002e8c: 45 80 00 0d be r12,r0,8002ec0 <timer_create+0x60>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
8002e90: 29 82 00 00 lw r2,(r12+0)
8002e94: 34 42 ff ff addi r2,r2,-1
8002e98: 50 22 00 02 bgeu r1,r2,8002ea0 <timer_create+0x40> <== ALWAYS TAKEN
8002e9c: e0 00 00 06 bi 8002eb4 <timer_create+0x54> <== NOT EXECUTED
( evp->sigev_notify != SIGEV_SIGNAL ) ) {
/* The value of the field sigev_notify is not valid */
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !evp->sigev_signo )
8002ea0: 29 81 00 04 lw r1,(r12+4)
8002ea4: 44 20 00 04 be r1,r0,8002eb4 <timer_create+0x54> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
8002ea8: 34 21 ff ff addi r1,r1,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
8002eac: 34 02 00 1f mvi r2,31
8002eb0: 50 41 00 04 bgeu r2,r1,8002ec0 <timer_create+0x60> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
8002eb4: f8 00 29 bc calli 800d5a4 <__errno>
8002eb8: 34 02 00 16 mvi r2,22
8002ebc: e0 00 00 0e bi 8002ef4 <timer_create+0x94>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
8002ec0: 78 01 08 01 mvhi r1,0x801
8002ec4: 38 21 f9 18 ori r1,r1,0xf918
8002ec8: 28 22 00 00 lw r2,(r1+0)
8002ecc: 34 42 00 01 addi r2,r2,1
8002ed0: 58 22 00 00 sw (r1+0),r2
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void )
{
return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information );
8002ed4: 78 01 08 01 mvhi r1,0x801
8002ed8: 38 21 fb 8c ori r1,r1,0xfb8c
8002edc: f8 00 07 0c calli 8004b0c <_Objects_Allocate>
8002ee0: b8 20 58 00 mv r11,r1
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
8002ee4: 5c 20 00 07 bne r1,r0,8002f00 <timer_create+0xa0>
_Thread_Enable_dispatch();
8002ee8: f8 00 0b df calli 8005e64 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
8002eec: f8 00 29 ae calli 800d5a4 <__errno>
8002ef0: 34 02 00 0b mvi r2,11
8002ef4: 58 22 00 00 sw (r1+0),r2
8002ef8: 34 01 ff ff mvi r1,-1
8002efc: e0 00 00 25 bi 8002f90 <timer_create+0x130>
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
8002f00: 34 01 00 02 mvi r1,2
8002f04: 31 61 00 3c sb (r11+60),r1
ptimer->thread_id = _Thread_Executing->Object.id;
8002f08: 78 01 08 01 mvhi r1,0x801
8002f0c: 38 21 fd c4 ori r1,r1,0xfdc4
8002f10: 28 21 00 0c lw r1,(r1+12)
8002f14: 28 21 00 08 lw r1,(r1+8)
8002f18: 59 61 00 38 sw (r11+56),r1
if ( evp != NULL ) {
8002f1c: 45 80 00 07 be r12,r0,8002f38 <timer_create+0xd8>
ptimer->inf.sigev_notify = evp->sigev_notify;
8002f20: 29 81 00 00 lw r1,(r12+0)
8002f24: 59 61 00 40 sw (r11+64),r1
ptimer->inf.sigev_signo = evp->sigev_signo;
8002f28: 29 81 00 04 lw r1,(r12+4)
8002f2c: 59 61 00 44 sw (r11+68),r1
ptimer->inf.sigev_value = evp->sigev_value;
8002f30: 29 81 00 08 lw r1,(r12+8)
8002f34: 59 61 00 48 sw (r11+72),r1
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
8002f38: 29 6c 00 08 lw r12,(r11+8)
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
_Thread_Enable_dispatch();
return 0;
}
8002f3c: 78 01 08 01 mvhi r1,0x801
8002f40: 38 21 fb 8c ori r1,r1,0xfb8c
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8002f44: 28 2e 00 1c lw r14,(r1+28)
8002f48: 34 02 00 02 mvi r2,2
ptimer->inf.sigev_notify = evp->sigev_notify;
ptimer->inf.sigev_signo = evp->sigev_signo;
ptimer->inf.sigev_value = evp->sigev_value;
}
ptimer->overrun = 0;
8002f4c: 59 60 00 68 sw (r11+104),r0
ptimer->timer_data.it_value.tv_sec = 0;
8002f50: 59 60 00 5c sw (r11+92),r0
ptimer->timer_data.it_value.tv_nsec = 0;
8002f54: 59 60 00 60 sw (r11+96),r0
ptimer->timer_data.it_interval.tv_sec = 0;
8002f58: 59 60 00 54 sw (r11+84),r0
ptimer->timer_data.it_interval.tv_nsec = 0;
8002f5c: 59 60 00 58 sw (r11+88),r0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
8002f60: 59 60 00 18 sw (r11+24),r0
the_watchdog->routine = routine;
8002f64: 59 60 00 2c sw (r11+44),r0
the_watchdog->id = id;
8002f68: 59 60 00 30 sw (r11+48),r0
the_watchdog->user_data = user_data;
8002f6c: 59 60 00 34 sw (r11+52),r0
8002f70: 21 81 ff ff andi r1,r12,0xffff
8002f74: f8 00 62 cd calli 801baa8 <__ashlsi3>
8002f78: b5 c1 08 00 add r1,r14,r1
8002f7c: 58 2b 00 00 sw (r1+0),r11
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
8002f80: 59 60 00 0c sw (r11+12),r0
_Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL );
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
8002f84: 59 ac 00 00 sw (r13+0),r12
_Thread_Enable_dispatch();
8002f88: f8 00 0b b7 calli 8005e64 <_Thread_Enable_dispatch>
return 0;
8002f8c: 34 01 00 00 mvi r1,0
}
8002f90: 2b 9d 00 04 lw ra,(sp+4)
8002f94: 2b 8b 00 14 lw r11,(sp+20)
8002f98: 2b 8c 00 10 lw r12,(sp+16)
8002f9c: 2b 8d 00 0c lw r13,(sp+12)
8002fa0: 2b 8e 00 08 lw r14,(sp+8)
8002fa4: 37 9c 00 14 addi sp,sp,20
8002fa8: c3 a0 00 00 ret
08002fac <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
8002fac: 37 9c ff cc addi sp,sp,-52
8002fb0: 5b 8b 00 18 sw (sp+24),r11
8002fb4: 5b 8c 00 14 sw (sp+20),r12
8002fb8: 5b 8d 00 10 sw (sp+16),r13
8002fbc: 5b 8e 00 0c sw (sp+12),r14
8002fc0: 5b 8f 00 08 sw (sp+8),r15
8002fc4: 5b 9d 00 04 sw (sp+4),ra
8002fc8: b8 20 78 00 mv r15,r1
8002fcc: b8 40 58 00 mv r11,r2
8002fd0: b8 60 60 00 mv r12,r3
8002fd4: b8 80 68 00 mv r13,r4
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
8002fd8: 44 60 00 69 be r3,r0,800317c <timer_settime+0x1d0> <== NEVER TAKEN
/*
* First, it verifies if the structure "value" is correct
* if the number of nanoseconds is not correct return EINVAL
*/
if ( !_Timespec_Is_valid( &(value->it_value) ) ) {
8002fdc: 34 61 00 08 addi r1,r3,8
8002fe0: f8 00 0f 0a calli 8006c08 <_Timespec_Is_valid>
8002fe4: 44 20 00 66 be r1,r0,800317c <timer_settime+0x1d0>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
8002fe8: b9 80 08 00 mv r1,r12
8002fec: f8 00 0f 07 calli 8006c08 <_Timespec_Is_valid>
8002ff0: 44 20 00 63 be r1,r0,800317c <timer_settime+0x1d0> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
8002ff4: 7d 62 00 00 cmpnei r2,r11,0
8002ff8: 7d 61 00 04 cmpnei r1,r11,4
8002ffc: a0 41 08 00 and r1,r2,r1
8003000: 5c 20 00 5f bne r1,r0,800317c <timer_settime+0x1d0>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
8003004: 29 81 00 0c lw r1,(r12+12)
8003008: 29 84 00 00 lw r4,(r12+0)
800300c: 29 83 00 04 lw r3,(r12+4)
8003010: 29 82 00 08 lw r2,(r12+8)
8003014: 5b 81 00 28 sw (sp+40),r1
8003018: 5b 84 00 1c sw (sp+28),r4
800301c: 5b 83 00 20 sw (sp+32),r3
8003020: 5b 82 00 24 sw (sp+36),r2
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
8003024: 34 01 00 04 mvi r1,4
8003028: 5d 61 00 0d bne r11,r1,800305c <timer_settime+0xb0>
struct timespec now;
_TOD_Get( &now );
800302c: 37 8b 00 2c addi r11,sp,44
8003030: b9 60 08 00 mv r1,r11
8003034: f8 00 04 ef calli 80043f0 <_TOD_Get>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
8003038: 37 8e 00 24 addi r14,sp,36
800303c: b9 60 08 00 mv r1,r11
8003040: b9 c0 10 00 mv r2,r14
8003044: f8 00 0e e6 calli 8006bdc <_Timespec_Greater_than>
8003048: 5c 20 00 4d bne r1,r0,800317c <timer_settime+0x1d0>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
800304c: b9 60 08 00 mv r1,r11
8003050: b9 c0 10 00 mv r2,r14
8003054: b9 c0 18 00 mv r3,r14
8003058: f8 00 0e f8 calli 8006c38 <_Timespec_Subtract>
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
800305c: 78 03 08 01 mvhi r3,0x801
8003060: b8 60 08 00 mv r1,r3
8003064: b9 e0 10 00 mv r2,r15
8003068: 38 21 fb 8c ori r1,r1,0xfb8c
800306c: 37 83 00 34 addi r3,sp,52
8003070: f8 00 07 f5 calli 8005044 <_Objects_Get>
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
8003074: 2b 82 00 34 lw r2,(sp+52)
8003078: b8 20 58 00 mv r11,r1
800307c: 5c 40 00 40 bne r2,r0,800317c <timer_settime+0x1d0>
case OBJECTS_LOCAL:
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
8003080: 2b 81 00 24 lw r1,(sp+36)
8003084: 5c 22 00 19 bne r1,r2,80030e8 <timer_settime+0x13c>
8003088: 2b 8e 00 28 lw r14,(sp+40)
800308c: 5d c1 00 17 bne r14,r1,80030e8 <timer_settime+0x13c>
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
8003090: 35 61 00 10 addi r1,r11,16
8003094: f8 00 10 60 calli 8007214 <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
8003098: 45 ae 00 09 be r13,r14,80030bc <timer_settime+0x110>
*ovalue = ptimer->timer_data;
800309c: 29 64 00 54 lw r4,(r11+84)
80030a0: 29 63 00 58 lw r3,(r11+88)
80030a4: 29 62 00 5c lw r2,(r11+92)
80030a8: 29 61 00 60 lw r1,(r11+96)
80030ac: 59 a4 00 00 sw (r13+0),r4
80030b0: 59 a3 00 04 sw (r13+4),r3
80030b4: 59 a2 00 08 sw (r13+8),r2
80030b8: 59 a1 00 0c sw (r13+12),r1
/* The new data are set */
ptimer->timer_data = normalize;
80030bc: 2b 81 00 1c lw r1,(sp+28)
80030c0: 59 61 00 54 sw (r11+84),r1
80030c4: 2b 81 00 20 lw r1,(sp+32)
80030c8: 59 61 00 58 sw (r11+88),r1
80030cc: 2b 81 00 24 lw r1,(sp+36)
80030d0: 59 61 00 5c sw (r11+92),r1
80030d4: 2b 81 00 28 lw r1,(sp+40)
80030d8: 59 61 00 60 sw (r11+96),r1
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
80030dc: 34 01 00 04 mvi r1,4
80030e0: 31 61 00 3c sb (r11+60),r1
80030e4: e0 00 00 23 bi 8003170 <timer_settime+0x1c4>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
80030e8: b9 80 08 00 mv r1,r12
80030ec: f8 00 0e e5 calli 8006c80 <_Timespec_To_ticks>
80030f0: 59 61 00 64 sw (r11+100),r1
initial_period = _Timespec_To_ticks( &normalize.it_value );
80030f4: 37 81 00 24 addi r1,sp,36
80030f8: f8 00 0e e2 calli 8006c80 <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
80030fc: 29 63 00 08 lw r3,(r11+8)
8003100: 78 04 08 00 mvhi r4,0x800
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
initial_period = _Timespec_To_ticks( &normalize.it_value );
8003104: b8 20 10 00 mv r2,r1
activated = _POSIX_Timer_Insert_helper(
8003108: 38 84 31 ac ori r4,r4,0x31ac
800310c: 35 61 00 10 addi r1,r11,16
8003110: b9 60 28 00 mv r5,r11
8003114: f8 00 1a fa calli 8009cfc <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
8003118: 44 20 00 16 be r1,r0,8003170 <timer_settime+0x1c4>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
800311c: 45 a0 00 09 be r13,r0,8003140 <timer_settime+0x194>
*ovalue = ptimer->timer_data;
8003120: 29 64 00 54 lw r4,(r11+84)
8003124: 29 63 00 58 lw r3,(r11+88)
8003128: 29 62 00 5c lw r2,(r11+92)
800312c: 29 61 00 60 lw r1,(r11+96)
8003130: 59 a4 00 00 sw (r13+0),r4
8003134: 59 a3 00 04 sw (r13+4),r3
8003138: 59 a2 00 08 sw (r13+8),r2
800313c: 59 a1 00 0c sw (r13+12),r1
ptimer->timer_data = normalize;
8003140: 2b 81 00 1c lw r1,(sp+28)
8003144: 59 61 00 54 sw (r11+84),r1
8003148: 2b 81 00 20 lw r1,(sp+32)
800314c: 59 61 00 58 sw (r11+88),r1
8003150: 2b 81 00 24 lw r1,(sp+36)
8003154: 59 61 00 5c sw (r11+92),r1
8003158: 2b 81 00 28 lw r1,(sp+40)
800315c: 59 61 00 60 sw (r11+96),r1
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
8003160: 34 01 00 03 mvi r1,3
8003164: 31 61 00 3c sb (r11+60),r1
_TOD_Get( &ptimer->time );
8003168: 35 61 00 6c addi r1,r11,108
800316c: f8 00 04 a1 calli 80043f0 <_TOD_Get>
_Thread_Enable_dispatch();
8003170: f8 00 0b 3d calli 8005e64 <_Thread_Enable_dispatch>
return 0;
8003174: 34 01 00 00 mvi r1,0
8003178: e0 00 00 05 bi 800318c <timer_settime+0x1e0>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
800317c: f8 00 29 0a calli 800d5a4 <__errno>
8003180: 34 02 00 16 mvi r2,22
8003184: 58 22 00 00 sw (r1+0),r2
8003188: 34 01 ff ff mvi r1,-1
}
800318c: 2b 9d 00 04 lw ra,(sp+4)
8003190: 2b 8b 00 18 lw r11,(sp+24)
8003194: 2b 8c 00 14 lw r12,(sp+20)
8003198: 2b 8d 00 10 lw r13,(sp+16)
800319c: 2b 8e 00 0c lw r14,(sp+12)
80031a0: 2b 8f 00 08 lw r15,(sp+8)
80031a4: 37 9c 00 34 addi sp,sp,52
80031a8: c3 a0 00 00 ret
08002d74 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
8002d74: 37 9c ff e8 addi sp,sp,-24
8002d78: 5b 8b 00 10 sw (sp+16),r11
8002d7c: 5b 8c 00 0c sw (sp+12),r12
8002d80: 5b 8d 00 08 sw (sp+8),r13
8002d84: 5b 9d 00 04 sw (sp+4),ra
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
8002d88: 78 0b 08 01 mvhi r11,0x801
8002d8c: 39 6b 71 98 ori r11,r11,0x7198
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
8002d90: b8 20 68 00 mv r13,r1
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
8002d94: 29 61 00 1c lw r1,(r11+28)
8002d98: 5c 20 00 09 bne r1,r0,8002dbc <ualarm+0x48>
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
8002d9c: 78 01 08 00 mvhi r1,0x800
8002da0: 38 21 2d 2c ori r1,r1,0x2d2c
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
8002da4: 59 60 00 08 sw (r11+8),r0
the_watchdog->routine = routine;
8002da8: 59 61 00 1c sw (r11+28),r1
the_watchdog->id = id;
8002dac: 59 60 00 20 sw (r11+32),r0
the_watchdog->user_data = user_data;
8002db0: 59 60 00 24 sw (r11+36),r0
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
8002db4: 34 0c 00 00 mvi r12,0
8002db8: e0 00 00 18 bi 8002e18 <ualarm+0xa4>
if ( !the_timer->routine ) {
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
8002dbc: b9 60 08 00 mv r1,r11
8002dc0: f8 00 0f 7e calli 8006bb8 <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
8002dc4: 34 21 ff fe addi r1,r1,-2
8002dc8: 34 02 00 01 mvi r2,1
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
8002dcc: 34 0c 00 00 mvi r12,0
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
8002dd0: 54 22 00 12 bgu r1,r2,8002e18 <ualarm+0xa4> <== NEVER TAKEN
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
8002dd4: 29 61 00 0c lw r1,(r11+12)
8002dd8: 29 62 00 14 lw r2,(r11+20)
8002ddc: b4 41 10 00 add r2,r2,r1
8002de0: 29 61 00 18 lw r1,(r11+24)
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
8002de4: c8 41 08 00 sub r1,r2,r1
8002de8: 37 82 00 14 addi r2,sp,20
8002dec: f8 00 0d a9 calli 8006490 <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
8002df0: 78 03 08 01 mvhi r3,0x801
8002df4: 38 63 4e 30 ori r3,r3,0x4e30
8002df8: 28 62 00 00 lw r2,(r3+0)
8002dfc: 2b 81 00 14 lw r1,(sp+20)
8002e00: f8 00 43 57 calli 8013b5c <__mulsi3>
8002e04: b8 20 60 00 mv r12,r1
remaining += tp.tv_nsec / 1000;
8002e08: 2b 81 00 18 lw r1,(sp+24)
8002e0c: 34 02 03 e8 mvi r2,1000
8002e10: f8 00 43 5f calli 8013b8c <__divsi3>
8002e14: b4 2c 60 00 add r12,r1,r12
/*
* If useconds is non-zero, then the caller wants to schedule
* the alarm repeatedly at that interval. If the interval is
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
8002e18: 45 a0 00 1a be r13,r0,8002e80 <ualarm+0x10c>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
8002e1c: 78 03 08 01 mvhi r3,0x801
8002e20: 38 63 4e 30 ori r3,r3,0x4e30
8002e24: 28 62 00 00 lw r2,(r3+0)
8002e28: b9 a0 08 00 mv r1,r13
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
ticks = _Timespec_To_ticks( &tp );
8002e2c: 37 8b 00 14 addi r11,sp,20
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
8002e30: f8 00 43 b0 calli 8013cf0 <__udivsi3>
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
8002e34: 78 03 08 01 mvhi r3,0x801
8002e38: 38 63 4e 30 ori r3,r3,0x4e30
8002e3c: 28 62 00 00 lw r2,(r3+0)
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
8002e40: 5b 81 00 14 sw (sp+20),r1
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
8002e44: b9 a0 08 00 mv r1,r13
8002e48: f8 00 43 ba calli 8013d30 <__umodsi3>
8002e4c: 34 02 03 e8 mvi r2,1000
8002e50: f8 00 43 43 calli 8013b5c <__mulsi3>
8002e54: 5b 81 00 18 sw (sp+24),r1
ticks = _Timespec_To_ticks( &tp );
8002e58: b9 60 08 00 mv r1,r11
8002e5c: f8 00 0d bb calli 8006548 <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
8002e60: b9 60 08 00 mv r1,r11
8002e64: f8 00 0d b9 calli 8006548 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
8002e68: 78 02 08 01 mvhi r2,0x801
8002e6c: 38 42 71 98 ori r2,r2,0x7198
8002e70: 58 41 00 0c sw (r2+12),r1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8002e74: 78 01 08 01 mvhi r1,0x801
8002e78: 38 21 69 e8 ori r1,r1,0x69e8
8002e7c: f8 00 0e f0 calli 8006a3c <_Watchdog_Insert>
}
return remaining;
}
8002e80: b9 80 08 00 mv r1,r12
8002e84: 2b 9d 00 04 lw ra,(sp+4)
8002e88: 2b 8b 00 10 lw r11,(sp+16)
8002e8c: 2b 8c 00 0c lw r12,(sp+12)
8002e90: 2b 8d 00 08 lw r13,(sp+8)
8002e94: 37 9c 00 18 addi sp,sp,24
8002e98: c3 a0 00 00 ret
080038c4 <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
80038c4: 37 9c ff c0 addi sp,sp,-64
80038c8: 5b 8b 00 14 sw (sp+20),r11
80038cc: 5b 8c 00 10 sw (sp+16),r12
80038d0: 5b 8d 00 0c sw (sp+12),r13
80038d4: 5b 8e 00 08 sw (sp+8),r14
80038d8: 5b 9d 00 04 sw (sp+4),ra
80038dc: b8 20 70 00 mv r14,r1
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
80038e0: fb ff fb 44 calli 80025f0 <rtems_filesystem_dirname>
80038e4: b8 20 58 00 mv r11,r1
80038e8: 37 84 00 2c addi r4,sp,44
if ( parentpathlen == 0 )
80038ec: 5c 20 00 07 bne r1,r0,8003908 <unlink+0x44>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
80038f0: b9 c0 08 00 mv r1,r14
80038f4: 37 82 00 40 addi r2,sp,64
80038f8: b8 80 18 00 mv r3,r4
80038fc: fb ff ff c0 calli 80037fc <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;
8003900: 34 0d 00 00 mvi r13,0
8003904: e0 00 00 09 bi 8003928 <unlink+0x64>
parentpathlen = rtems_filesystem_dirname ( path );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( path, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
8003908: b9 c0 08 00 mv r1,r14
800390c: b9 60 10 00 mv r2,r11
8003910: 34 03 00 02 mvi r3,2
8003914: 34 05 00 00 mvi r5,0
8003918: fb ff fb 1b calli 8002584 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
return -1;
800391c: 34 0c ff ff mvi r12,-1
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
8003920: 5c 20 00 3d bne r1,r0,8003a14 <unlink+0x150> <== NEVER TAKEN
return -1;
free_parentloc = true;
8003924: 34 0d 00 01 mvi r13,1
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
8003928: 2b 81 00 2c lw r1,(sp+44)
name = path + parentpathlen;
800392c: b5 cb 58 00 add r11,r14,r11
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
8003930: 5b 81 00 18 sw (sp+24),r1
8003934: 2b 81 00 30 lw r1,(sp+48)
8003938: 5b 81 00 1c sw (sp+28),r1
800393c: 2b 81 00 34 lw r1,(sp+52)
8003940: 5b 81 00 20 sw (sp+32),r1
8003944: 2b 81 00 38 lw r1,(sp+56)
8003948: 5b 81 00 24 sw (sp+36),r1
800394c: 2b 81 00 3c lw r1,(sp+60)
8003950: 5b 81 00 28 sw (sp+40),r1
name = path + parentpathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
8003954: b9 60 08 00 mv r1,r11
8003958: f8 00 3b 27 calli 80125f4 <strlen>
800395c: b8 20 10 00 mv r2,r1
8003960: b9 60 08 00 mv r1,r11
8003964: fb ff fb 37 calli 8002640 <rtems_filesystem_prefix_separators>
8003968: b5 61 60 00 add r12,r11,r1
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
800396c: b9 80 08 00 mv r1,r12
8003970: f8 00 3b 21 calli 80125f4 <strlen>
8003974: 37 8b 00 18 addi r11,sp,24
8003978: b8 20 10 00 mv r2,r1
800397c: 34 03 00 00 mvi r3,0
8003980: b9 80 08 00 mv r1,r12
8003984: b9 60 20 00 mv r4,r11
8003988: 34 05 00 00 mvi r5,0
800398c: fb ff fa dc calli 80024fc <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
8003990: 44 20 00 05 be r1,r0,80039a4 <unlink+0xe0>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
8003994: 34 0c ff ff mvi r12,-1
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
8003998: 37 81 00 2c addi r1,sp,44
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 )
800399c: 45 a0 00 1e be r13,r0,8003a14 <unlink+0x150> <== NEVER TAKEN
80039a0: e0 00 00 1c bi 8003a10 <unlink+0x14c>
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
80039a4: 2b 81 00 24 lw r1,(sp+36)
80039a8: 28 22 00 10 lw r2,(r1+16)
80039ac: b9 60 08 00 mv r1,r11
80039b0: d8 40 00 00 call r2
80039b4: 34 02 00 01 mvi r2,1
80039b8: 5c 22 00 0b bne r1,r2,80039e4 <unlink+0x120>
rtems_filesystem_freenode( &loc );
80039bc: b9 60 08 00 mv r1,r11
80039c0: fb ff fb 39 calli 80026a4 <rtems_filesystem_freenode>
if ( free_parentloc )
80039c4: 45 a0 00 03 be r13,r0,80039d0 <unlink+0x10c>
rtems_filesystem_freenode( &parentloc );
80039c8: 37 81 00 2c addi r1,sp,44
80039cc: fb ff fb 36 calli 80026a4 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EISDIR );
80039d0: f8 00 36 a8 calli 8011470 <__errno>
80039d4: 34 02 00 15 mvi r2,21
80039d8: 58 22 00 00 sw (r1+0),r2
80039dc: 34 0c ff ff mvi r12,-1
80039e0: e0 00 00 0d bi 8003a14 <unlink+0x150>
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
80039e4: 2b 81 00 24 lw r1,(sp+36)
80039e8: 37 8e 00 2c addi r14,sp,44
80039ec: b9 60 10 00 mv r2,r11
80039f0: 28 23 00 0c lw r3,(r1+12)
80039f4: b9 c0 08 00 mv r1,r14
80039f8: d8 60 00 00 call r3
80039fc: b8 20 60 00 mv r12,r1
rtems_filesystem_freenode( &loc );
8003a00: b9 60 08 00 mv r1,r11
8003a04: fb ff fb 28 calli 80026a4 <rtems_filesystem_freenode>
if ( free_parentloc )
8003a08: 45 a0 00 03 be r13,r0,8003a14 <unlink+0x150>
rtems_filesystem_freenode( &parentloc );
8003a0c: b9 c0 08 00 mv r1,r14
8003a10: fb ff fb 25 calli 80026a4 <rtems_filesystem_freenode>
return result;
}
8003a14: b9 80 08 00 mv r1,r12
8003a18: 2b 9d 00 04 lw ra,(sp+4)
8003a1c: 2b 8b 00 14 lw r11,(sp+20)
8003a20: 2b 8c 00 10 lw r12,(sp+16)
8003a24: 2b 8d 00 0c lw r13,(sp+12)
8003a28: 2b 8e 00 08 lw r14,(sp+8)
8003a2c: 37 9c 00 40 addi sp,sp,64
8003a30: c3 a0 00 00 ret
0800393c <unmount>:
*/
int unmount(
const char *path
)
{
800393c: 37 9c ff dc addi sp,sp,-36
8003940: 5b 8b 00 10 sw (sp+16),r11
8003944: 5b 8c 00 0c sw (sp+12),r12
8003948: 5b 8d 00 08 sw (sp+8),r13
800394c: 5b 9d 00 04 sw (sp+4),ra
8003950: b8 20 58 00 mv r11,r1
* 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 ) )
8003954: 37 8c 00 14 addi r12,sp,20
8003958: f8 00 2c 85 calli 800eb6c <strlen>
800395c: b8 20 10 00 mv r2,r1
8003960: 34 03 00 00 mvi r3,0
8003964: b9 60 08 00 mv r1,r11
8003968: b9 80 20 00 mv r4,r12
800396c: 34 05 00 01 mvi r5,1
8003970: fb ff fa 12 calli 80021b8 <rtems_filesystem_evaluate_path>
8003974: 5c 20 00 41 bne r1,r0,8003a78 <unmount+0x13c>
return -1;
mt_entry = loc.mt_entry;
8003978: 2b 8b 00 24 lw r11,(sp+36)
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
800397c: 2b 81 00 14 lw r1,(sp+20)
8003980: 29 62 00 1c lw r2,(r11+28)
8003984: 44 41 00 06 be r2,r1,800399c <unmount+0x60>
rtems_filesystem_freenode( &loc );
8003988: b9 80 08 00 mv r1,r12
800398c: fb ff fa 53 calli 80022d8 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EACCES );
8003990: f8 00 26 da calli 800d4f8 <__errno>
8003994: 34 02 00 0d mvi r2,13
8003998: e0 00 00 13 bi 80039e4 <unmount+0xa8>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
800399c: b9 80 08 00 mv r1,r12
80039a0: fb ff fa 4e calli 80022d8 <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 )
80039a4: 78 01 08 01 mvhi r1,0x801
80039a8: 38 21 71 d0 ori r1,r1,0x71d0
80039ac: 28 21 00 00 lw r1,(r1+0)
80039b0: 28 21 00 14 lw r1,(r1+20)
80039b4: 44 2b 00 0a be r1,r11,80039dc <unmount+0xa0>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
80039b8: 29 62 00 2c lw r2,(r11+44)
80039bc: 78 01 08 00 mvhi r1,0x800
80039c0: 38 21 39 30 ori r1,r1,0x3930
80039c4: fb ff fc ea calli 8002d6c <rtems_filesystem_mount_iterate>
80039c8: 5c 20 00 05 bne r1,r0,80039dc <unmount+0xa0>
* 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 )
80039cc: b9 60 08 00 mv r1,r11
80039d0: fb ff fb 5c calli 8002740 <rtems_libio_is_open_files_in_fs>
80039d4: 34 02 00 01 mvi r2,1
80039d8: 5c 22 00 05 bne r1,r2,80039ec <unmount+0xb0>
rtems_set_errno_and_return_minus_one( EBUSY );
80039dc: f8 00 26 c7 calli 800d4f8 <__errno>
80039e0: 34 02 00 10 mvi r2,16
80039e4: 58 22 00 00 sw (r1+0),r2
80039e8: e0 00 00 24 bi 8003a78 <unmount+0x13c>
* 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 )
80039ec: 29 61 00 14 lw r1,(r11+20)
return -1;
80039f0: 34 0c ff ff mvi r12,-1
* 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 )
80039f4: 28 22 00 28 lw r2,(r1+40)
80039f8: b9 60 08 00 mv r1,r11
80039fc: d8 40 00 00 call r2
8003a00: b8 20 68 00 mv r13,r1
8003a04: 5c 20 00 1e bne r1,r0,8003a7c <unmount+0x140> <== NEVER TAKEN
* NOTE: Fatal error is called in a case which should never happen
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
8003a08: 29 61 00 28 lw r1,(r11+40)
8003a0c: 28 22 00 2c lw r2,(r1+44)
8003a10: b9 60 08 00 mv r1,r11
8003a14: d8 40 00 00 call r2
8003a18: 44 2d 00 08 be r1,r13,8003a38 <unmount+0xfc> <== ALWAYS TAKEN
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
8003a1c: 29 61 00 14 lw r1,(r11+20) <== NOT EXECUTED
8003a20: 28 22 00 20 lw r2,(r1+32) <== NOT EXECUTED
8003a24: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
8003a28: d8 40 00 00 call r2 <== NOT EXECUTED
8003a2c: 44 20 00 14 be r1,r0,8003a7c <unmount+0x140> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
8003a30: 34 01 00 00 mvi r1,0 <== NOT EXECUTED
8003a34: f8 00 02 cc calli 8004564 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
8003a38: 78 0c 08 01 mvhi r12,0x801
8003a3c: 39 8c 78 b0 ori r12,r12,0x78b0
8003a40: 29 81 00 00 lw r1,(r12+0)
8003a44: 34 02 00 00 mvi r2,0
8003a48: 34 03 00 00 mvi r3,0
8003a4c: f8 00 01 97 calli 80040a8 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
8003a50: b9 60 08 00 mv r1,r11
8003a54: f8 00 03 c6 calli 800496c <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
8003a58: 29 81 00 00 lw r1,(r12+0)
*/
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
8003a5c: 34 0c 00 00 mvi r12,0
8003a60: f8 00 01 e2 calli 80041e8 <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 );
8003a64: 35 61 00 08 addi r1,r11,8
8003a68: fb ff fa 1c calli 80022d8 <rtems_filesystem_freenode>
free( mt_entry );
8003a6c: b9 60 08 00 mv r1,r11
8003a70: fb ff fa 22 calli 80022f8 <free>
return 0;
8003a74: e0 00 00 02 bi 8003a7c <unmount+0x140>
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
8003a78: 34 0c ff ff mvi r12,-1
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
8003a7c: b9 80 08 00 mv r1,r12
8003a80: 2b 9d 00 04 lw ra,(sp+4)
8003a84: 2b 8b 00 10 lw r11,(sp+16)
8003a88: 2b 8c 00 0c lw r12,(sp+12)
8003a8c: 2b 8d 00 08 lw r13,(sp+8)
8003a90: 37 9c 00 24 addi sp,sp,36
8003a94: c3 a0 00 00 ret
08017848 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
8017848: 37 9c ff ec addi sp,sp,-20
801784c: 5b 8b 00 10 sw (sp+16),r11
8017850: 5b 8c 00 0c sw (sp+12),r12
8017854: 5b 8d 00 08 sw (sp+8),r13
8017858: 5b 9d 00 04 sw (sp+4),ra
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
801785c: 78 04 08 01 mvhi r4,0x801
8017860: 38 84 90 10 ori r4,r4,0x9010
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
8017864: b8 40 68 00 mv r13,r2
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
8017868: 28 82 00 00 lw r2,(r4+0)
801786c: 54 41 00 02 bgu r2,r1,8017874 <write+0x2c>
8017870: e0 00 00 0c bi 80178a0 <write+0x58>
iop = rtems_libio_iop( fd );
8017874: 78 0b 08 01 mvhi r11,0x801
8017878: 34 02 00 06 mvi r2,6
801787c: 39 6b 98 58 ori r11,r11,0x9858
8017880: 5b 83 00 14 sw (sp+20),r3
8017884: fb ff fd a3 calli 8016f10 <__ashlsi3>
8017888: 29 6b 00 00 lw r11,(r11+0)
rtems_libio_check_is_open( iop );
801788c: 2b 83 00 14 lw r3,(sp+20)
{
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
8017890: b5 61 58 00 add r11,r11,r1
rtems_libio_check_is_open( iop );
8017894: 29 61 00 18 lw r1,(r11+24)
8017898: 20 22 01 00 andi r2,r1,0x100
801789c: 5c 40 00 04 bne r2,r0,80178ac <write+0x64>
80178a0: fb ff e6 f4 calli 8011470 <__errno>
80178a4: 34 02 00 09 mvi r2,9
80178a8: e0 00 00 08 bi 80178c8 <write+0x80>
rtems_libio_check_buffer( buffer );
80178ac: 45 a0 00 05 be r13,r0,80178c0 <write+0x78> <== NEVER TAKEN
rtems_libio_check_count( count );
80178b0: 34 0c 00 00 mvi r12,0
80178b4: 44 60 00 19 be r3,r0,8017918 <write+0xd0>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
80178b8: 20 21 00 04 andi r1,r1,0x4
80178bc: 5c 20 00 06 bne r1,r0,80178d4 <write+0x8c>
80178c0: fb ff e6 ec calli 8011470 <__errno>
80178c4: 34 02 00 16 mvi r2,22
80178c8: 58 22 00 00 sw (r1+0),r2
80178cc: 34 0c ff ff mvi r12,-1
80178d0: e0 00 00 12 bi 8017918 <write+0xd0>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
80178d4: 29 61 00 24 lw r1,(r11+36)
80178d8: b9 a0 10 00 mv r2,r13
80178dc: 28 24 00 0c lw r4,(r1+12)
80178e0: b9 60 08 00 mv r1,r11
80178e4: d8 80 00 00 call r4
80178e8: b8 20 60 00 mv r12,r1
if ( rc > 0 )
80178ec: 4c 01 00 0b bge r0,r1,8017918 <write+0xd0>
iop->offset += rc;
80178f0: 34 02 00 1f mvi r2,31
80178f4: fb ff fd ae calli 8016fac <__ashrsi3>
80178f8: 29 62 00 14 lw r2,(r11+20)
80178fc: 29 64 00 10 lw r4,(r11+16)
8017900: b5 82 10 00 add r2,r12,r2
8017904: f5 82 18 00 cmpgu r3,r12,r2
8017908: b4 24 08 00 add r1,r1,r4
801790c: b4 61 08 00 add r1,r3,r1
8017910: 59 61 00 10 sw (r11+16),r1
8017914: 59 62 00 14 sw (r11+20),r2
return rc;
}
8017918: b9 80 08 00 mv r1,r12
801791c: 2b 9d 00 04 lw ra,(sp+4)
8017920: 2b 8b 00 10 lw r11,(sp+16)
8017924: 2b 8c 00 0c lw r12,(sp+12)
8017928: 2b 8d 00 08 lw r13,(sp+8)
801792c: 37 9c 00 14 addi sp,sp,20
8017930: c3 a0 00 00 ret
08003d1c <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
8003d1c: 37 9c ff e4 addi sp,sp,-28
8003d20: 5b 8b 00 1c sw (sp+28),r11
8003d24: 5b 8c 00 18 sw (sp+24),r12
8003d28: 5b 8d 00 14 sw (sp+20),r13
8003d2c: 5b 8e 00 10 sw (sp+16),r14
8003d30: 5b 8f 00 0c sw (sp+12),r15
8003d34: 5b 90 00 08 sw (sp+8),r16
8003d38: 5b 9d 00 04 sw (sp+4),ra
8003d3c: b8 60 78 00 mv r15,r3
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
8003d40: 78 03 08 01 mvhi r3,0x801
8003d44: 38 63 60 10 ori r3,r3,0x6010
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
8003d48: b8 40 68 00 mv r13,r2
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
8003d4c: 28 62 00 00 lw r2,(r3+0)
8003d50: 54 41 00 02 bgu r2,r1,8003d58 <writev+0x3c>
8003d54: e0 00 00 0a bi 8003d7c <writev+0x60>
iop = rtems_libio_iop( fd );
8003d58: 78 0b 08 01 mvhi r11,0x801
8003d5c: 34 02 00 06 mvi r2,6
8003d60: 39 6b 67 8c ori r11,r11,0x678c
8003d64: f8 00 3c 5a calli 8012ecc <__ashlsi3>
8003d68: 29 6c 00 00 lw r12,(r11+0)
8003d6c: b5 81 60 00 add r12,r12,r1
rtems_libio_check_is_open( iop );
8003d70: 29 81 00 18 lw r1,(r12+24)
8003d74: 20 22 01 00 andi r2,r1,0x100
8003d78: 5c 40 00 04 bne r2,r0,8003d88 <writev+0x6c>
8003d7c: f8 00 26 67 calli 800d718 <__errno>
8003d80: 34 02 00 09 mvi r2,9
8003d84: e0 00 00 1c bi 8003df4 <writev+0xd8>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
8003d88: 20 21 00 04 andi r1,r1,0x4
8003d8c: 44 20 00 18 be r1,r0,8003dec <writev+0xd0> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
8003d90: 45 a0 00 17 be r13,r0,8003dec <writev+0xd0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
8003d94: 49 e0 00 02 bg r15,r0,8003d9c <writev+0x80>
8003d98: e0 00 00 15 bi 8003dec <writev+0xd0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
8003d9c: 34 01 04 00 mvi r1,1024
8003da0: 4c 2f 00 02 bge r1,r15,8003da8 <writev+0x8c> <== ALWAYS TAKEN
8003da4: e0 00 00 12 bi 8003dec <writev+0xd0> <== NOT EXECUTED
8003da8: b9 a0 08 00 mv r1,r13
8003dac: 34 02 00 01 mvi r2,1
8003db0: 34 04 00 00 mvi r4,0
8003db4: 34 03 00 00 mvi r3,0
8003db8: e0 00 00 02 bi 8003dc0 <writev+0xa4>
if ( iov[v].iov_len )
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
8003dbc: b8 a0 18 00 mv r3,r5
/*
* 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 )
8003dc0: 28 25 00 00 lw r5,(r1+0)
8003dc4: 44 a0 00 0a be r5,r0,8003dec <writev+0xd0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
8003dc8: 28 25 00 04 lw r5,(r1+4)
all_zeros = false;
8003dcc: 64 a6 00 00 cmpei r6,r5,0
/* check for wrap */
old = total;
total += iov[v].iov_len;
8003dd0: b4 65 28 00 add r5,r3,r5
*/
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
8003dd4: c8 06 30 00 sub r6,r0,r6
8003dd8: a0 46 10 00 and r2,r2,r6
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
8003ddc: e8 65 18 00 cmpg r3,r3,r5
8003de0: 68 a6 7f ff cmpgi r6,r5,32767
8003de4: b8 c3 18 00 or r3,r6,r3
8003de8: 44 60 00 05 be r3,r0,8003dfc <writev+0xe0>
rtems_set_errno_and_return_minus_one( EINVAL );
8003dec: f8 00 26 4b calli 800d718 <__errno>
8003df0: 34 02 00 16 mvi r2,22
8003df4: 58 22 00 00 sw (r1+0),r2
8003df8: e0 00 00 22 bi 8003e80 <writev+0x164>
* 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++ ) {
8003dfc: 34 84 00 01 addi r4,r4,1
8003e00: 34 21 00 08 addi r1,r1,8
8003e04: 49 e4 ff ee bg r15,r4,8003dbc <writev+0xa0>
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
return 0;
8003e08: 34 0b 00 00 mvi r11,0
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
8003e0c: 5c 40 00 1e bne r2,r0,8003e84 <writev+0x168>
8003e10: 34 10 00 00 mvi r16,0
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
8003e14: 29 a3 00 04 lw r3,(r13+4)
8003e18: 44 60 00 16 be r3,r0,8003e70 <writev+0x154> <== NEVER TAKEN
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
8003e1c: 29 81 00 24 lw r1,(r12+36)
8003e20: 29 a2 00 00 lw r2,(r13+0)
8003e24: 28 24 00 0c lw r4,(r1+12)
8003e28: b9 80 08 00 mv r1,r12
8003e2c: d8 80 00 00 call r4
8003e30: b8 20 70 00 mv r14,r1
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
8003e34: 48 01 00 13 bg r0,r1,8003e80 <writev+0x164> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
8003e38: 44 20 00 0c be r1,r0,8003e68 <writev+0x14c> <== NEVER TAKEN
iop->offset += bytes;
8003e3c: 34 02 00 1f mvi r2,31
8003e40: f8 00 3c 4a calli 8012f68 <__ashrsi3>
8003e44: 29 82 00 14 lw r2,(r12+20)
8003e48: 29 84 00 10 lw r4,(r12+16)
total += bytes;
8003e4c: b5 6e 58 00 add r11,r11,r14
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
iop->offset += bytes;
8003e50: b5 c2 10 00 add r2,r14,r2
8003e54: f5 c2 18 00 cmpgu r3,r14,r2
8003e58: b4 24 08 00 add r1,r1,r4
8003e5c: b4 61 08 00 add r1,r3,r1
8003e60: 59 81 00 10 sw (r12+16),r1
8003e64: 59 82 00 14 sw (r12+20),r2
total += bytes;
}
if (bytes != iov[ v ].iov_len)
8003e68: 29 a1 00 04 lw r1,(r13+4)
8003e6c: 5d c1 00 06 bne r14,r1,8003e84 <writev+0x168> <== NEVER TAKEN
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
8003e70: 36 10 00 01 addi r16,r16,1
8003e74: 35 ad 00 08 addi r13,r13,8
8003e78: 49 f0 ff e7 bg r15,r16,8003e14 <writev+0xf8>
8003e7c: e0 00 00 02 bi 8003e84 <writev+0x168>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
8003e80: 34 0b ff ff mvi r11,-1
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
8003e84: b9 60 08 00 mv r1,r11
8003e88: 2b 9d 00 04 lw ra,(sp+4)
8003e8c: 2b 8b 00 1c lw r11,(sp+28)
8003e90: 2b 8c 00 18 lw r12,(sp+24)
8003e94: 2b 8d 00 14 lw r13,(sp+20)
8003e98: 2b 8e 00 10 lw r14,(sp+16)
8003e9c: 2b 8f 00 0c lw r15,(sp+12)
8003ea0: 2b 90 00 08 lw r16,(sp+8)
8003ea4: 37 9c 00 1c addi sp,sp,28
8003ea8: c3 a0 00 00 ret